Synchronization between ISR and thread

[cz8pru]

I have a problem with simple example, where interrupt set semaphore and thread take this semaphore. It does not work for me when ISR is executed with period less than 50 ms. My example toggle with LEDs in ISQ as well as in thread.

During tracing I see following:
01:00:07.551944290] (+0.000015899) 0 isr_exit:
[01:00:07.572413760] (+0.020469470) 0 thread_switched_out: { thread_id = 536871688, name = "tracing_thread" }
[01:00:07.572463242] (+0.000049482) 0 thread_switched_in: { thread_id = 536871248, name = "thread_a" }
[01:00:07.572489760] (+0.000026518) 0 semaphore_take_exit: { id = 536871212, timeout = 500, ret = 0 }
[01:00:07.572515760] (+0.000026000) 0 semaphore_take_enter: { id = 536871212, timeout = 500 }
[01:00:07.572535391] (+0.000019631) 0 semaphore_take_blocking: { id = 536871212, timeout = 500 }
[01:00:07.572576093] (+0.000040702) 0 thread_switched_out: { thread_id = 536871248, name = "thread_a" }
[01:00:07.572608557] (+0.000032464) 0 thread_switched_in: { thread_id = 536872128, name = "idle 00" }
[01:00:07.572632682] (+0.000024125) 0 idle:
[01:00:07.601871706] (+0.029239024) 0 isr_enter:
[01:00:07.601895081] (+0.000023375) 0 semaphore_give_enter: { id = 536871212 }
[01:00:07.601927200] (+0.000032119) 0 semaphore_give_exit: { id = 536871212 }
[01:00:07.601943093] (+0.000015893) 0 isr_exit:
[01:00:07.601957641] (+0.000014548) 0 idle:
[01:00:07.651871706] (+0.049914065) 0 isr_enter:
[01:00:07.651895438] (+0.000023732) 0 semaphore_give_enter: { id = 536871212 }
[01:00:07.651914593] (+0.000019155) 0 semaphore_give_exit: { id = 536871212 }
[01:00:07.651930462] (+0.000015869) 0 isr_exit:
[01:00:07.651944837] (+0.000014375) 0 idle:
[01:00:07.672173325] (+0.020228488) 0 thread_switched_out: { thread_id = 536872128, name = "idle 00" }
[01:00:07.672205861] (+0.000032536) 0 thread_switched_in: { thread_id = 536871248, name = "thread_a" }
[01:00:07.672232379] (+0.000026518) 0 semaphore_take_exit: { id = 536871212, timeout = 500, ret = 0 }
[01:00:07.672256754] (+0.000024375) 0 semaphore_take_enter: { id = 536871212, timeout = 500 }
[01:00:07.672277034] (+0.000020280) 0 semaphore_take_exit: { id = 536871212, timeout = 500, ret = 0 }
[01:00:07.672303117] (+0.000026083) 0 semaphore_take_enter: { id = 536871212, timeout = 500 }
[01:00:07.672322742] (+0.000019625) 0 semaphore_take_blocking: { id = 536871212, timeout = 500 }
[01:00:07.672381498] (+0.000058756) 0 semaphore_give_enter: { id = 536871228 }
[01:00:07.672411194] (+0.000029696) 0 semaphore_give_exit: { id = 536871228 }
[01:00:11.967330728] (+4.294919534) 0 thread_switched_out: { thread_id = 536871248, name = "thread_a" }
[01:00:11.967434383] (+0.000103655) 0 thread_switched_in: { thread_id = 536871688, name = "tracing_thread" }
[01:00:11.996838240] (+0.029403857) 0 isr_enter:
[01:00:11.996861806] (+0.000023566) 0 semaphore_give_enter: { id = 536871212 }
[01:00:11.996894675] (+0.000032869) 0 semaphore_give_exit: { id = 536871212 }
[01:00:11.996910568] (+0.000015893) 0 isr_exit:

It looks, that idle is NOT interrupted by thread_a.

/* main.c - Hello World demo */

/*

• Copyright (c) 2012-2014 Wind River Systems, Inc.
• SPDX-License-Identifier: Apache-2.0
  */

#include <zephyr.h>
#include <sys/printk.h>
#include <device.h>
#include <drivers/gpio.h>
#include <devicetree.h>
#include <drivers/counter.h>

//#include <logging/log.h>
//LOG_MODULE_REGISTER(counters, LOG_LEVEL_INF);

struct counter_top_cfg top_cfg;

#define COUNTER_PERIOD 50000 /* = 50 ms [us] /
//#define COUNTER_PERIOD 100000 / = 100 ms [us] */

#define LED0_NODE DT_ALIAS(led0)
#define LED1_NODE DT_ALIAS(led1)

#if !DT_NODE_HAS_STATUS(LED0_NODE, okay)
#error "Unsupported board: led0 devicetree alias is not defined"
#endif

#if !DT_NODE_HAS_STATUS(LED1_NODE, okay)
#error "Unsupported board: led1 devicetree alias is not defined"
#endif

struct led {
struct gpio_dt_spec spec;
const char *gpio_pin_name;
};

static const struct led ld1 = {
.spec = GPIO_DT_SPEC_GET_OR(LED0_NODE, gpios, {0}),
.gpio_pin_name = DT_PROP_OR(LED0_NODE, label, ""),
};

static const struct led ld2 = {
.spec = GPIO_DT_SPEC_GET_OR(LED1_NODE, gpios, {0}),
.gpio_pin_name = DT_PROP_OR(LED1_NODE, label, ""),
};

const struct gpio_dt_spec *ld1_spec = &ld1.spec;
const struct gpio_dt_spec *ld2_spec = &ld2.spec;

volatile uint8_t g_cnt_counter_ld1=0;
volatile uint8_t g_cnt_counter_ld2=0;

static const char * const devices_counter[] = {
#ifdef CONFIG_COUNTER_TIMER_STM32
#define STM32_COUNTER_LABEL(idx)
DT_LABEL(DT_INST(idx, st_stm32_counter)),
#define DT_DRV_COMPAT st_stm32_counter
DT_INST_FOREACH_STATUS_OKAY(STM32_COUNTER_LABEL)
#undef DT_DRV_COMPAT
#undef STM32_COUNTER_LABEL
#endif
};

/* size of stack area used by each thread */
#define STACKSIZE 1024

/* scheduling priority used by each thread /
/ https://docs.zephyrproject.org/latest/reference/kernel/threads/index.html#thread-priorities /
//#define PRIORITY -1 / Idle thread (cooperative) /
//#define PRIORITY -2 / Cooperative /
#define PRIORITY -(CONFIG_NUM_PREEMPT_PRIORITIES-1) / Cooperative /
//#define PRIORITY 10 / Preemptive */

/* define semaphores */
K_SEM_DEFINE(threadB_sem, 0, 1);

static void counter_interrupt_callback(const struct device *dev, void *user_data)
{
gpio_pin_set(ld1_spec->port, ld1_spec->pin, g_cnt_counter_ld1 % 2);
g_cnt_counter_ld1++;

/* #21111 */
k_sem_give(&threadB_sem);
}

void counter_interrupt_period_setup(const struct device *p_counter_dev)
{
int err;

top_cfg.flags = 0;
top_cfg.ticks = counter_us_to_ticks(p_counter_dev, COUNTER_PERIOD)-1;
top_cfg.callback = counter_interrupt_callback;
top_cfg.user_data = &top_cfg;

printk("%u ticks\n", top_cfg.ticks);

err = counter_set_top_value(p_counter_dev, &top_cfg);
if (err == -ENOTSUP) {
	/* If resetting is not support, attempt without reset. */
	top_cfg.flags = COUNTER_TOP_CFG_DONT_RESET;
	err = counter_set_top_value(p_counter_dev, &top_cfg);

}

}

void threadA(void *dummy1, void *dummy2, void *dummy3)
{
for(;;) {
//if ( k_sem_take(&threadB_sem, K_MSEC(200)) == 0)
// if ( k_sem_take(&threadB_sem, K_NO_WAIT) == 0)
// {
// gpio_pin_set(ld2_spec->port, ld2_spec->pin, g_cnt_counter_ld2 % 2);
// g_cnt_counter_ld2++;
// }

// k_sem_take(&threadB_sem, K_FOREVER);
// gpio_pin_set(ld2_spec->port, ld2_spec->pin, g_cnt_counter_ld2 % 2);
// g_cnt_counter_ld2++;



	if ( k_sem_take(&threadB_sem, K_MSEC(500)) == 0)
{
  gpio_pin_set(ld2_spec->port, ld2_spec->pin, g_cnt_counter_ld2 % 2);
  g_cnt_counter_ld2++;
}

}
}

K_THREAD_STACK_DEFINE(threadA_stack_area, STACKSIZE);
static struct k_thread threadA_data;

void main(void)
{
const struct device *counter_dev;

int i;

int ret;
int err;

device_is_ready(ld1_spec->port);
gpio_pin_configure_dt(ld1_spec, GPIO_OUTPUT);

device_is_ready(ld2_spec->port);
gpio_pin_configure_dt(ld2_spec, GPIO_OUTPUT);

k_thread_create(&threadA_data, threadA_stack_area,
		K_THREAD_STACK_SIZEOF(threadA_stack_area),
		threadA, NULL, NULL, NULL,
		PRIORITY, 0, K_NO_WAIT);
k_thread_name_set(&threadA_data, "thread_a");

//k_thread_start(&threadA_data);

for (i = 0; i < ARRAY_SIZE(devices_counter); i++) {
	counter_dev = device_get_binding(devices_counter[i]);
	if( counter_dev != NULL )
{
  k_object_access_grant(counter_dev, k_current_get());
}

}

counter_interrupt_period_setup(counter_dev);

err = counter_start(counter_dev);

}

/*
"st-util" "-p" "50000" "-v" "--no-reset"
"/home/e9924876/zephyr-sdk-0.12.4/arm-zephyr-eabi/bin/arm-none-eabi-gdb" "-q" "--interpreter=mi2"

*/

[cz8pru]

The issue with rescheduling is solved when ISR_DIRECT_DECLARE returns different value to 0. This needs to be managed in STM32 Counter driver, see: https://github.com/zephyrproject-rtos/zephyr/blob/6a838bfaba59f75675b5641305277f6ec9bdff76/drivers/counter/counter_ll_stm32_timer.c#L587

Explanation, rescheduling after interrupt happen when z_arm_int_exit() is called when ISR finish. This can be done in ISR_DIRECT_FOOTER().