main.c

Go to the documentation of this file.

 
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "FreeRTOS.h"
#include "core_stop.h"
#include "error_handler.h"
#include "hardware.h"
#include "rtc.h"
#include "scheduler.h"
#include "task.h"
#include "timers.h"
 
/* Private variables ---------------------------------------------------------*/
TaskHandle_t taskHandleLedBlink = NULL;
 
TaskHandle_t taskHandleLedSteady = NULL;
 
/* Private function prototypes -----------------------------------------------*/
void TaskLedBlink(void* arg);
void TaskLedSteady(void* arg);
 
void JobShortPeriodCallback(void);
void JobLongPeriodCallback(void);
 
/* External functions --------------------------------------------------------*/
extern TickType_t GetExpectedIdleTime(void);
extern UBaseType_t IsDelayedTaskListEmpty(void);
 
int main(void)
{
    HAL_Init();
    SystemClockConfig();
    GpioInit();
    RtcInit();
    SchedulerInit();
 
    SchedulerAddJob(5U, JobShortPeriodCallback);
    SchedulerAddJob(10U, JobLongPeriodCallback);
 
    if(xTaskCreate(TaskLedBlink,             /* Task function */
                   "task_led_blink",         /* Task name */
                   configMINIMAL_STACK_SIZE, /* Stack size */
                   NULL,                     /* Arguments */
                   2,                        /* Task priority */
                   &taskHandleLedBlink) != pdPASS)
    {
        ErrorHandler();
    }
 
    if(xTaskCreate(TaskLedSteady,            /* Task function */
                   "task_led_steady",        /* Task name */
                   configMINIMAL_STACK_SIZE, /* Stack size */
                   NULL,                     /* Arguments */
                   1,                        /* Task priority */
                   &taskHandleLedSteady) != pdPASS)
    {
        ErrorHandler();
    }
 
    /* RTOS Kernel Start */
    vTaskStartScheduler();
 
    /* This line must not be reached */
    ErrorHandler();
}
 
void JobShortPeriodCallback(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 
    /* Unblock the Led Blink Task */
    vTaskNotifyGiveFromISR(taskHandleLedBlink, &xHigherPriorityTaskWoken);
 
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
 
void JobLongPeriodCallback(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 
    /* Unblock the Led Steady Task */
    vTaskNotifyGiveFromISR(taskHandleLedSteady, &xHigherPriorityTaskWoken);
 
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
 
void TaskLedBlink(void* arg)
{
    UNUSED(arg);
    uint32_t isTaskUnblocked;
 
    for(;;)
    {
        isTaskUnblocked = ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        if(isTaskUnblocked != 0U)
        {
            for(uint8_t i = 0U; i < 4U; ++i)
            {
                LedLd3Toggle();
                vTaskDelay(pdMS_TO_TICKS(250));
            }
        }
    }
}
 
void TaskLedSteady(void* arg)
{
    UNUSED(arg);
    uint32_t isTaskUnblocked;
 
    for(;;)
    {
        isTaskUnblocked = ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        if(isTaskUnblocked != 0U)
        {
            LedLd2On();
            vTaskDelay(pdMS_TO_TICKS(1000));
            LedLd2Off();
        }
    }
}
 
void vApplicationDaemonTaskStartupHook(void)
{
    SchedulerProcess();
}
 
void vApplicationIdleHook(void)
{
    const uint32_t expectedIdleTime = GetExpectedIdleTime();
 
    if((expectedIdleTime > pdMS_TO_TICKS(IDLE_TIME_BEFORE_SLEEP)) &&
       (IsDelayedTaskListEmpty() == pdTRUE))
    {
        EnterStop2Mode();
        ResumeFromStop2Mode();
    }
}
 
void vApplicationStackOverflowHook(TaskHandle_t xTask, char* pcTaskName)
{
    UNUSED(xTask);
    UNUSED(pcTaskName);
 
    ErrorHandler();
}
 
void vApplicationMallocFailedHook(void)
{
    ErrorHandler();
}