toaster-oven-bluepill/Core/Src/freertos.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : freertos.c
  * Description        : Code for freertos applications
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "snprintf.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
typedef StaticTask_t osStaticThreadDef_t;
typedef StaticQueue_t osStaticMessageQDef_t;
typedef StaticTimer_t osStaticTimerDef_t;
typedef StaticSemaphore_t osStaticMutexDef_t;
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */

/* USER CODE END Variables */
/* Definitions for mainTsk */
osThreadId_t mainTskHandle;
uint32_t defaultTaskBuffer[ 256 ];
osStaticThreadDef_t defaultTaskControlBlock;
const osThreadAttr_t mainTsk_attributes = {
  .name = "mainTsk",
  .cb_mem = &defaultTaskControlBlock,
  .cb_size = sizeof(defaultTaskControlBlock),
  .stack_mem = &defaultTaskBuffer[0],
  .stack_size = sizeof(defaultTaskBuffer),
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for heaterTsk */
osThreadId_t heaterTskHandle;
uint32_t heaterTskBuffer[ 128 ];
osStaticThreadDef_t heaterTskControlBlock;
const osThreadAttr_t heaterTsk_attributes = {
  .name = "heaterTsk",
  .cb_mem = &heaterTskControlBlock,
  .cb_size = sizeof(heaterTskControlBlock),
  .stack_mem = &heaterTskBuffer[0],
  .stack_size = sizeof(heaterTskBuffer),
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for guiTsk */
osThreadId_t guiTskHandle;
uint32_t guiTskBuffer[ 256 ];
osStaticThreadDef_t guiTskControlBlock;
const osThreadAttr_t guiTsk_attributes = {
  .name = "guiTsk",
  .cb_mem = &guiTskControlBlock,
  .cb_size = sizeof(guiTskControlBlock),
  .stack_mem = &guiTskBuffer[0],
  .stack_size = sizeof(guiTskBuffer),
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for guiEventQue */
osMessageQueueId_t guiEventQueHandle;
uint8_t guiEventQueBuffer[ 16 * 8 ];
osStaticMessageQDef_t guiEventQueControlBlock;
const osMessageQueueAttr_t guiEventQue_attributes = {
  .name = "guiEventQue",
  .cb_mem = &guiEventQueControlBlock,
  .cb_size = sizeof(guiEventQueControlBlock),
  .mq_mem = &guiEventQueBuffer,
  .mq_size = sizeof(guiEventQueBuffer)
};
/* Definitions for beepTimer */
osTimerId_t beepTimerHandle;
osStaticTimerDef_t beepTimerControlBlock;
const osTimerAttr_t beepTimer_attributes = {
  .name = "beepTimer",
  .cb_mem = &beepTimerControlBlock,
  .cb_size = sizeof(beepTimerControlBlock),
};
/* Definitions for heaterMutex */
osMutexId_t heaterMutexHandle;
osStaticMutexDef_t heaterMutexControlBlock;
const osMutexAttr_t heaterMutex_attributes = {
  .name = "heaterMutex",
  .cb_mem = &heaterMutexControlBlock,
  .cb_size = sizeof(heaterMutexControlBlock),
};

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */

/* USER CODE END FunctionPrototypes */

void app_task_main(void *argument);
extern void app_task_heater(void *argument);
extern void app_task_gui(void *argument);
extern void app_beep_end(void *argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/* Hook prototypes */
void vApplicationStackOverflowHook(TaskHandle_t xTask, signed char *pcTaskName);
void vApplicationMallocFailedHook(void);

/* USER CODE BEGIN 4 */
void vApplicationStackOverflowHook(TaskHandle_t xTask, signed char *pcTaskName)
{
   PRINTF("vApplicationStackOverflowHook: %s\r\n", pcTaskName);
   /* Run time stack overflow checking is performed if
   configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook function is
   called if a stack overflow is detected. */
}
/* USER CODE END 4 */

/* USER CODE BEGIN 5 */
void vApplicationMallocFailedHook(void)
{
   PUTS("vApplicationMallocFailedHook\r\n");
   /* vApplicationMallocFailedHook() will only be called if
   configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h. It is a hook
   function that will get called if a call to pvPortMalloc() fails.
   pvPortMalloc() is called internally by the kernel whenever a task, queue,
   timer or semaphore is created. It is also called by various parts of the
   demo application. If heap_1.c or heap_2.c are used, then the size of the
   heap available to pvPortMalloc() is defined by configTOTAL_HEAP_SIZE in
   FreeRTOSConfig.h, and the xPortGetFreeHeapSize() API function can be used
   to query the size of free heap space that remains (although it does not
   provide information on how the remaining heap might be fragmented). */
}
/* USER CODE END 5 */

/**
  * @brief  FreeRTOS initialization
  * @param  None
  * @retval None
  */
void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */

  /* USER CODE END Init */
  /* Create the mutex(es) */
  /* creation of heaterMutex */
  heaterMutexHandle = osMutexNew(&heaterMutex_attributes);

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* Create the timer(s) */
  /* creation of beepTimer */
  beepTimerHandle = osTimerNew(app_beep_end, osTimerOnce, NULL, &beepTimer_attributes);

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* Create the queue(s) */
  /* creation of guiEventQue */
  guiEventQueHandle = osMessageQueueNew (16, 8, &guiEventQue_attributes);

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* creation of mainTsk */
  mainTskHandle = osThreadNew(app_task_main, NULL, &mainTsk_attributes);

  /* creation of heaterTsk */
  heaterTskHandle = osThreadNew(app_task_heater, NULL, &heaterTsk_attributes);

  /* creation of guiTsk */
  guiTskHandle = osThreadNew(app_task_gui, NULL, &guiTsk_attributes);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

  /* USER CODE BEGIN RTOS_EVENTS */
  /* add events, ... */
  /* USER CODE END RTOS_EVENTS */

}

/* USER CODE BEGIN Header_app_task_main */
/**
  * @brief  Function implementing the mainTsk thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_app_task_main */
__weak void app_task_main(void *argument)
{
  /* USER CODE BEGIN app_task_main */
  /* Infinite loop */
  for(;;)
  {
  }
  /* USER CODE END app_task_main */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

/* USER CODE END Application */