125 lines
4.9 KiB
C
Executable File
125 lines
4.9 KiB
C
Executable File
#define SYS_LOG_DOMAIN "OS"
|
|
#include "os/os.h"
|
|
#include "sys_log.h"
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
|
|
StackType_t uxTimerTaskStack[configTIMER_TASK_STACK_DEPTH];
|
|
|
|
void vAssertCalled(void);
|
|
void vApplicationStackOverflowHook(TaskHandle_t pxTask, char *pcTaskName);
|
|
void vApplicationMallocFailedHook(void);
|
|
void vApplicationIdleHook(void);
|
|
void vApplicationTickHook(void);
|
|
void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
|
|
StackType_t **ppxTimerTaskStackBuffer,
|
|
uint32_t *pulTimerTaskStackSize);
|
|
void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
|
|
StackType_t **ppxIdleTaskStackBuffer,
|
|
uint32_t *pulIdleTaskStackSize);
|
|
|
|
void vAssertCalled(void)
|
|
{
|
|
volatile unsigned long looping = 0;
|
|
|
|
os_interrupt_disable();
|
|
{
|
|
/* Use the debugger to set ul to a non-zero value in order to step out
|
|
* of this function to determine why it was called. */
|
|
while (looping == 0LU)
|
|
{
|
|
}
|
|
}
|
|
os_interrupt_enable();
|
|
}
|
|
|
|
void vApplicationStackOverflowHook(TaskHandle_t pxTask, char *pcTaskName)
|
|
{
|
|
SYS_LOG_ERR("task %p(%s) stack over flow\n", pxTask, 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. */
|
|
taskDISABLE_INTERRUPTS();
|
|
|
|
for (;;)
|
|
{
|
|
}
|
|
}
|
|
|
|
void vApplicationMallocFailedHook(void)
|
|
{
|
|
/* Called if a call to pvPortMalloc() fails because there is insufficient
|
|
* free memory available in the FreeRTOS heap. pvPortMalloc() is called
|
|
* internally by FreeRTOS API functions that create tasks, queues, software
|
|
* timers, and semaphores. The size of the FreeRTOS heap is set by the
|
|
* configTOTAL_HEAP_SIZE configuration constant in FreeRTOSConfig.h. */
|
|
taskDISABLE_INTERRUPTS();
|
|
|
|
for (;;)
|
|
{
|
|
}
|
|
}
|
|
|
|
void vApplicationIdleHook(void)
|
|
{
|
|
/* This is just a trivial example of an idle hook. It is called on each
|
|
* cycle of the idle task. It must *NOT* attempt to block. In this case the
|
|
* idle task just queries the amount of FreeRTOS heap that remains. See the
|
|
* memory management section on the https://www.FreeRTOS.org web site for memory
|
|
* management options. If there is a lot of heap memory free then the
|
|
* configTOTAL_HEAP_SIZE value in FreeRTOSConfig.h can be reduced to free up
|
|
* RAM. */
|
|
}
|
|
|
|
void vApplicationTickHook(void)
|
|
{
|
|
}
|
|
|
|
void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
|
|
StackType_t **ppxTimerTaskStackBuffer,
|
|
uint32_t *pulTimerTaskStackSize)
|
|
{
|
|
/* If the buffers to be provided to the Timer task are declared inside this
|
|
* function then they must be declared static - otherwise they will be allocated on
|
|
* the stack and so not exists after this function exits. */
|
|
static StaticTask_t xTimerTaskTCB;
|
|
|
|
/* Pass out a pointer to the StaticTask_t structure in which the Timer
|
|
* task's state will be stored. */
|
|
*ppxTimerTaskTCBBuffer = &xTimerTaskTCB;
|
|
|
|
/* Pass out the array that will be used as the Timer task's stack. */
|
|
*ppxTimerTaskStackBuffer = uxTimerTaskStack;
|
|
|
|
/* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
|
|
* Note that, as the array is necessarily of type StackType_t,
|
|
* configMINIMAL_STACK_SIZE is specified in words, not bytes. */
|
|
*pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
|
|
}
|
|
|
|
/* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an
|
|
* implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
|
|
* used by the Idle task. */
|
|
void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
|
|
StackType_t **ppxIdleTaskStackBuffer,
|
|
uint32_t *pulIdleTaskStackSize)
|
|
{
|
|
/* If the buffers to be provided to the Idle task are declared inside this
|
|
* function then they must be declared static - otherwise they will be allocated on
|
|
* the stack and so not exists after this function exits. */
|
|
static StaticTask_t xIdleTaskTCB;
|
|
static StackType_t uxIdleTaskStack[configMINIMAL_STACK_SIZE];
|
|
|
|
/* Pass out a pointer to the StaticTask_t structure in which the Idle task's
|
|
* state will be stored. */
|
|
*ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
|
|
|
|
/* Pass out the array that will be used as the Idle task's stack. */
|
|
*ppxIdleTaskStackBuffer = uxIdleTaskStack;
|
|
|
|
/* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
|
|
* Note that, as the array is necessarily of type StackType_t,
|
|
* configMINIMAL_STACK_SIZE is specified in words, not bytes. */
|
|
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
|
|
}
|