ECE 471/571 STM32 FreeRTOS Example - Thread safe data processing with Mutex

In STM32CubeMX

Initialize all peripherals with in default mode? - yes
System Core

find PB0, PB7, PB14, PC13

Push-Pull output: "LD1 [Green]" - PB0
Push-Pull output: "LD2 [Blue]" - PB7
Push-Pull output: "LD3 [Red]" - PB14
No pull-down/up input: "USER_Btn [B1]" - PC13
(note: by default it is set as GPIO external interrupt 13)

enable UART3

set Baud rate to 115200 bps, no parity, no hardware flow control, 1 stop bit
note that in case of longer UART connections and in case of factory floor nosy EMF environment the recommended Baud rate is 9600 bps which translates to transmitting ca. one character per millisecond.
enable UART3 interrupt

Middleware - enable FreeRTOS

choose Interface: CMSIS V1
enable vTaskDelay (already enabled)
enable vTaskDelayUntil (if you are using it in your code)
enable USE_PREEMTPTION (already enabled)
inspect task: defaultTask, osPriorityNormal, 128, StartDefaultTask, ...
add task: process_send1, osPriorityNormal, 128, task_process_send1, ...
add task: process_send2, osPriorityNormal, 128, task_process_send2, ...
add task: competing_process, osPriorityNormal, 128, task_competing_process, ...
add queue: uart3_rx_queue, 20, uint8_t, ...
add queue: uart3_tx_queue, 20, uint8_t, ...
add mutex: uart3_rx_access, ...
add mutex: uart3_tx_access, ...

System Core Again

SYS - select Timebase Source: TIM2
disable Ethernet
disable USB_OTG_FS

Adapt and compile a project

Open Core/Src/main.c

Update the following code fragment:

/* USER CODE BEGIN 0 */
signed portBASE_TYPE xSerialGetChar( char *pcRxedChar, TickType_t xBlockTime )
{
    /* Get the next character from the buffer.  Return false if no characters
    are available, or arrive before xBlockTime expires. */
    if( xQueueReceive( uart3_rx_queueHandle, pcRxedChar, xBlockTime ) )
    {
        return pdTRUE;
    } else {
        return pdFALSE;
    }
}

signed portBASE_TYPE xSerialPutChar( char cOutChar, TickType_t xBlockTime )
{
    signed portBASE_TYPE xReturn;

    if( xQueueSend( uart3_tx_queueHandle, &cOutChar, xBlockTime ) == pdPASS )
    {
        xReturn = pdPASS;
        __HAL_UART_ENABLE_IT(&huart3, UART_IT_TXE);
    } else {
        xReturn = pdFAIL;
    }

    return xReturn;
}

BaseType_t uart3_gets(char * str, BaseType_t len)
{
    BaseType_t result = 0;

    while( xSemaphoreTake(uart3_rx_accessHandle, 1000 / portTICK_PERIOD_MS ) != pdTRUE )
      ; // wait up to forever for the mutex access

    while(len>0)
    {
        while( xSerialGetChar(str, 1000) != pdTRUE )
            ; // wait up to forever to receive a character
        if ( *str == '\n' ) {
            break;
        }
        --len;
        ++result;
        ++str;
    }
    *str = '\0'; // terminate the string instead of '\n'

    xSemaphoreGive(uart3_rx_accessHandle);

    return(result);
}

BaseType_t uart3_puts(const char * str)
{
    BaseType_t result = 0;

    while( xSemaphoreTake(uart3_tx_accessHandle, 1000 / portTICK_PERIOD_MS ) != pdTRUE )
        ; // wait up to forever for the mutex access

    while( *str != '\0' ) {
        while( xSerialPutChar(*str, 1000) != pdTRUE )
            ; // wait up to forever to send a character
        ++result;
        ++str;
    }

    xSemaphoreGive(uart3_tx_accessHandle);

    return(result);
}

BaseType_t uart3_write(const void * buffer, BaseType_t len)
{
    BaseType_t result = 0;

    while( xSemaphoreTake(uart3_tx_accessHandle, 1000 / portTICK_PERIOD_MS ) != pdTRUE )
        ; // wait up to forever for the mutex access

    while( len>0 ) {
        while( xSerialPutChar(* (char*)buffer, 1000 / portTICK_PERIOD_MS ) != pdTRUE )
            ; // wait up to forever to send a character
        --len;
        ++result;
        ++buffer;
    }

    xSemaphoreGive(uart3_tx_accessHandle);

    return(result);
}
/* USER CODE END 0 */

Update the following code fragment:

  /* USER CODE BEGIN 2 */
  __HAL_UART_ENABLE_IT(&huart3, UART_IT_RXNE);
  /* USER CODE END 2 */

Update the following code fragment:

void StartDefaultTask(void const * argument)
{
  /* USER CODE BEGIN 5 */
      /* Infinite loop */
      for(;;)
      {

        osDelay(500);
      }
  /* USER CODE END 5 */ 
}

Update the following code fragment:

void StartDefaultTask(void const * argument)
{
  /* USER CODE BEGIN 5 */
      /* Infinite loop */
      for(;;)
      {

        osDelay(1000);
      }
  /* USER CODE END 5 */ 
}

Update the following code fragment:

void task_process_send1(void const * argument)
{
  /* USER CODE BEGIN task_process_send1 */
  /* Infinite loop */
  for(;;)
  {
    uart3_puts("++++");
  }
  /* USER CODE END task_process_send1 */
}

Update the following code fragment:

void task_process_send2(void const * argument)
{
  /* USER CODE BEGIN task_process_send2 */
  /* Infinite loop */
  for(;;)
  {
    uart3_puts("---");
  }
  /* USER CODE END task_process_send2 */
}

Update the following code fragment:

void task_competing_process(void const * argument)
{
  /* USER CODE BEGIN task_competing_process */
  /* Infinite loop */
  TickType_t xLastWakeTime = xTaskGetTickCount();
  for(;;)
  {
    xSerialPutChar('X', 1);
	vTaskDelayUntil( &xLastWakeTime, (100 / portTICK_PERIOD_MS) );
  }
  /* USER CODE END task_competing_process */
}

Open Core/Inc/main.h

Update the following code fragment:

/* USER CODE BEGIN Includes */
#include "cmsis_os.h"
/* USER CODE END Includes */

Update the following code fragment:

/* USER CODE BEGIN EM */
extern osMessageQId uart3_rx_queueHandle;
extern osMessageQId uart3_tx_queueHandle;
/* USER CODE END EM */

Open Core/Src/stm32f7xx_it.c

Update the following code fragment:

void USART3_IRQHandler(void)
{
  /* USER CODE BEGIN USART3_IRQn 0 */
  BaseType_t xSchedulerChanged = pdFALSE;
  uint8_t buffer;

  if( __HAL_UART_GET_IT( &huart3, UART_IT_TXE ) == SET )
  {
    /* The interrupt was caused by the THR becoming empty.  Are there any more characters to transmit? */
    if( xQueueReceiveFromISR(uart3_tx_queueHandle, &buffer, &xSchedulerChanged ) == pdTRUE )
    {
      /* A character was retrieved from the queue so can be sent to the THR now. */
      HAL_UART_Transmit(&huart3, &buffer, 1, 0);
    }
    else
    {
      __HAL_UART_DISABLE_IT( &huart3, UART_IT_TXE);
    }
  }

  HAL_StatusTypeDef status = HAL_UART_Receive(&huart3, &buffer, 1, 0); // we are inside an interrupt - timeout of 0!
  if ( HAL_OK == status ) {
    xQueueSendFromISR(uart3_rx_queueHandle, &buffer, &xSchedulerChanged);
  }
  portYIELD_FROM_ISR( xSchedulerChanged );

  /* USER CODE END USART3_IRQn 0 */
  HAL_UART_IRQHandler(&huart3);
  /* USER CODE BEGIN USART3_IRQn 1 */

  /* USER CODE END USART3_IRQn 1 */
}