STM32H753 × FreeRTOS: Learning about queue/semaphore inter-task communication with just 4 LEDs (no interrupts)

4.2 LED Control Guidelines (Active Low)

Because it is Active Low, the meaning of GPIO is as follows:

• Lighting: HAL_GPIO_WritePin(..., GPIO_PIN_RESET)
• Turning off the light: HAL_GPIO_WritePin(..., GPIO_PIN_SET)

This sample includes the following helper files in main.c.

static void LED_On(GPIO_TypeDef *port, uint16_t pin)
{
  HAL_GPIO_WritePin(port, pin, GPIO_PIN_RESET);
}

static void LED_Off(GPIO_TypeDef *port, uint16_t pin)
{
  HAL_GPIO_WritePin(port, pin, GPIO_PIN_SET);
}

static void LED_Toggle(GPIO_TypeDef *port, uint16_t pin)
{
  HAL_GPIO_TogglePin(port, pin);
}

Additionally, the initial output value during GPIO initialization is set to all LEDs off (SET) to prevent the LEDs from remaining lit immediately after startup.

HAL_GPIO_WritePin(GPIOK, GPIO_PIN_5|GPIO_PIN_4|GPIO_PIN_6|GPIO_PIN_3, GPIO_PIN_SET);

4.3 Task Configuration (No Interrupts)

This sample demonstrates how to handle task queues and semaphores using the CMSIS-RTOS2 API (cmsis_os.h).

• StartDefaultTask (LED1): Heartbeat
• PatternProducerTask: Create a blinking pattern for LED2 and send it to the queue.
• LedDriverTask: Receives a queue and blinks LED2.
• SyncTask: Gives a semaphore (signal) at regular intervals.
• SemBlinkTask: Takes a semaphore and blinks LED3.

4.4 Expected appearance (operational image)

• LED1: Flashes with a 500ms cycle (always moving)
• LED2: The pattern changes every second, with the number of flashes changing from 1→2→3→5…
• LED3: Blinks briefly at a 700ms cycle.
• LED4: Toggles only if queue transmission fails (normally it is not expected to change).

5.2 Data Design for Queues

The blinking instructions for LED2 are expressed in the following three ways.

• blink_count: How many times does it blink?
• on_ms: lighting time
• off_ms: Lights-off time

typedef struct
{
  uint16_t blink_count;
  uint16_t on_ms;
  uint16_t off_ms;
} LedBlinkMsg_t;

The queue is created with a depth of 4.

Here, "depth 4" means that up to four unprocessed messages can be stored. Increasing the depth allows the system to "accommodate slightly faster senders," but it also increases memory consumption.

g_led2Queue = osMessageQueueNew(4, sizeof(LedBlinkMsg_t), NULL);

5.3 Implementation: Sending side (PatternProducerTask)

The sender sequentially submits several flashing patterns to a queue.

• Use osMessageQueuePut()
• If transmission fails (e.g., queue full), LED4 will toggle to allow visual confirmation.

const LedBlinkMsg_t patterns[] = {
  { .blink_count = 1, .on_ms = 80,  .off_ms = 120 },
  { .blink_count = 2, .on_ms = 80,  .off_ms = 120 },
  { .blink_count = 3, .on_ms = 80,  .off_ms = 120 },
  { .blink_count = 5, .on_ms = 40,  .off_ms = 60  },
};

const osStatus_t st = osMessageQueuePut(g_led2Queue, &msg, 0U, 0U);
if (st != osOK)
{
  LED_Toggle(LED4_GPIO_Port, LED4_Pin);
}

5.4 Implementation: Receiving side (LedDriverTask)

The receiving end waits using osMessageQueueGet() and blinks LED2 according to the content of the received data.

if (osMessageQueueGet(g_led2Queue, &msg, NULL, osWaitForever) == osOK)
{
  for (uint16_t i = 0; i < msg.blink_count; i++)
  {
    LED_On(LED2_GPIO_Port, LED2_Pin);
    osDelay(msg.on_ms);
    LED_Off(LED2_GPIO_Port, LED2_Pin);
    osDelay(msg.off_ms);
  }
}

There are two key points.

• Blocking the waiting period (osWaitForever) prevents unnecessary CPU usage.
• Since it's Active Low, there's no risk of confusing ON/OFF (this is handled by a helper function).

6.2 Implementation: Give side (SyncTask)

The binary semaphore is generated as follows (initial count 0):

g_semBlink = osSemaphoreNew(1, 0, NULL);

SyncTask releases periodically.

Here, we are creating a period using osDelay(700),

• If periodic accuracy is critical, use the equivalent of osDelayUntil (the osDelayUntil function in CMSIS-RTOS2).
• If you need multiple periodic events, consider using a software timer.

These are common occurrences in practical work.

(void)osSemaphoreRelease(g_semBlink);
osDelay(700);

6.3 Implementation: Take side (SemBlinkTask)

SemBlinkTask waits for osSemaphoreAcquire().

Because it's blocked by osWaitForever, it doesn't consume CPU until a signal is received. This is a very important way to create a "wait" state and is one of the advantages of using an RTOS.

if (osSemaphoreAcquire(g_semBlink, osWaitForever) == osOK)
{
  LED_On(LED3_GPIO_Port, LED3_Pin);
  osDelay(50);
  LED_Off(LED3_GPIO_Port, LED3_Pin);
}

8.2 Operation Checklist

• The LED does not stay lit immediately after POWER SUPPLIES-on (the initial Active Low value is appropriate).
• LED1 blinks with a period of 500ms.
• The blinking frequency of LED2 changes periodically (queue operation).
• LED3 blinks briefly at a cycle of approximately 700ms (semaphore synchronization).
• If LED4 is constantly blinking, the queue transmission has failed (insufficient queue depth, slow receiver, etc.).