forked from ROMEO/obsw
248 lines
8.8 KiB
C
248 lines
8.8 KiB
C
/* Standard includes. */
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
|
|
/* Scheduler include files. */
|
|
#include "FreeRTOS.h"
|
|
#include "semphr.h"
|
|
#include "task.h"
|
|
|
|
/* Xilinx includes. */
|
|
// #include "platform.h"
|
|
#include "xil_exception.h"
|
|
#include "xparameters.h"
|
|
#include "xscugic.h"
|
|
#include "xscutimer.h"
|
|
#include "xuartps_hw.h"
|
|
|
|
/*
|
|
* Configure the hardware as necessary to run this demo.
|
|
*/
|
|
static void prvSetupHardware(void);
|
|
|
|
/*
|
|
* The Xilinx projects use a BSP that do not allow the start up code to be
|
|
* altered easily. Therefore the vector table used by FreeRTOS is defined in
|
|
* FreeRTOS_asm_vectors.S, which is part of this project. Switch to use the
|
|
* FreeRTOS vector table.
|
|
*/
|
|
extern void vPortInstallFreeRTOSVectorTable(void);
|
|
|
|
/* Prototypes for the standard FreeRTOS callback/hook functions implemented
|
|
within this file. */
|
|
void vApplicationMallocFailedHook(void);
|
|
void vApplicationIdleHook(void);
|
|
void vApplicationStackOverflowHook(TaskHandle_t pxTask, char *pcTaskName);
|
|
void vApplicationTickHook(void);
|
|
|
|
/* The private watchdog is used as the timer that generates run time
|
|
stats. This frequency means it will overflow quite quickly. */
|
|
XScuWdt xWatchDogInstance;
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/* The interrupt controller is initialised in this file, and made available to
|
|
other modules. */
|
|
XScuGic xInterruptController;
|
|
|
|
extern SemaphoreHandle_t malloc_mutex;
|
|
|
|
int get_descriptor_rw() {
|
|
return 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------*/
|
|
void mission(void);
|
|
|
|
void initFreeRTOSHelper();
|
|
|
|
int main(void) {
|
|
|
|
/* Configure the hardware ready to run. */
|
|
prvSetupHardware();
|
|
|
|
mission();
|
|
}
|
|
|
|
static void prvSetupHardware(void) {
|
|
BaseType_t xStatus;
|
|
XScuGic_Config *pxGICConfig;
|
|
|
|
/* Ensure no interrupts execute while the scheduler is in an inconsistent
|
|
state. Interrupts are automatically enabled when the scheduler is
|
|
started. */
|
|
portDISABLE_INTERRUPTS();
|
|
|
|
/* Obtain the configuration of the GIC. */
|
|
pxGICConfig = XScuGic_LookupConfig(XPAR_SCUGIC_SINGLE_DEVICE_ID);
|
|
|
|
/* Sanity check the FreeRTOSConfig.h settings are correct for the
|
|
hardware. */
|
|
configASSERT(pxGICConfig);
|
|
configASSERT(pxGICConfig->CpuBaseAddress ==
|
|
(configINTERRUPT_CONTROLLER_BASE_ADDRESS +
|
|
configINTERRUPT_CONTROLLER_CPU_INTERFACE_OFFSET));
|
|
configASSERT(pxGICConfig->DistBaseAddress ==
|
|
configINTERRUPT_CONTROLLER_BASE_ADDRESS);
|
|
|
|
/* Install a default handler for each GIC interrupt. */
|
|
xStatus = XScuGic_CfgInitialize(&xInterruptController, pxGICConfig,
|
|
pxGICConfig->CpuBaseAddress);
|
|
configASSERT(xStatus == XST_SUCCESS);
|
|
(void)xStatus; /* Remove compiler warning if configASSERT() is not defined. */
|
|
|
|
// TODO we can alter the startup code...
|
|
/* The Xilinx projects use a BSP that do not allow the start up code to be
|
|
altered easily. Therefore the vector table used by FreeRTOS is defined in
|
|
FreeRTOS_asm_vectors.S, which is part of this project. Switch to use the
|
|
FreeRTOS vector table. */
|
|
vPortInstallFreeRTOSVectorTable();
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
void vInitialiseTimerForRunTimeStats(void) {
|
|
XScuWdt_Config *pxWatchDogInstance;
|
|
uint32_t ulValue;
|
|
const uint32_t ulMaxDivisor = 0xff, ulDivisorShift = 0x08;
|
|
|
|
pxWatchDogInstance = XScuWdt_LookupConfig(XPAR_SCUWDT_0_DEVICE_ID);
|
|
XScuWdt_CfgInitialize(&xWatchDogInstance, pxWatchDogInstance,
|
|
pxWatchDogInstance->BaseAddr);
|
|
|
|
ulValue = XScuWdt_GetControlReg(&xWatchDogInstance);
|
|
ulValue |= ulMaxDivisor << ulDivisorShift;
|
|
XScuWdt_SetControlReg(&xWatchDogInstance, ulValue);
|
|
|
|
XScuWdt_LoadWdt(&xWatchDogInstance, UINT_MAX);
|
|
XScuWdt_SetTimerMode(&xWatchDogInstance);
|
|
XScuWdt_Start(&xWatchDogInstance);
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the
|
|
application must provide an implementation of vApplicationGetTimerTaskMemory()
|
|
to provide the memory that is used by the Timer service task. */
|
|
|
|
void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
|
|
StackType_t **ppxTimerTaskStackBuffer,
|
|
uint32_t *pulTimerTaskStackSize);
|
|
|
|
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;
|
|
static StackType_t uxTimerTaskStack[configTIMER_TASK_STACK_DEPTH];
|
|
|
|
/* 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;
|
|
}
|
|
|
|
// Marker for debugging sessions
|
|
__attribute__((noinline)) void done() { asm(""); }
|
|
|
|
void vApplicationIdleHook(void) {
|
|
volatile size_t xFreeHeapSpace, xMinimumEverFreeHeapSpace;
|
|
|
|
/* 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 http://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. */
|
|
// xFreeHeapSpace = xPortGetFreeHeapSize();
|
|
// xMinimumEverFreeHeapSpace = xPortGetMinimumEverFreeHeapSize();
|
|
|
|
// /* Remove compiler warning about xFreeHeapSpace being set but never used.
|
|
// */ (void)xFreeHeapSpace; (void)xMinimumEverFreeHeapSpace;
|
|
}
|
|
|
|
void vApplicationTickHook(void) {
|
|
#if (mainSELECTED_APPLICATION == 1)
|
|
{
|
|
/* The full demo includes a software timer demo/test that requires
|
|
prodding periodically from the tick interrupt. */
|
|
vTimerPeriodicISRTests();
|
|
|
|
/* Call the periodic queue overwrite from ISR demo. */
|
|
vQueueOverwritePeriodicISRDemo();
|
|
|
|
/* Call the periodic event group from ISR demo. */
|
|
vPeriodicEventGroupsProcessing();
|
|
|
|
/* Use task notifications from an interrupt. */
|
|
xNotifyTaskFromISR();
|
|
|
|
/* Use mutexes from interrupts. */
|
|
vInterruptSemaphorePeriodicTest();
|
|
|
|
/* Writes to stream buffer byte by byte to test the stream buffer trigger
|
|
level functionality. */
|
|
vPeriodicStreamBufferProcessing();
|
|
|
|
/* Writes a string to a string buffer four bytes at a time to demonstrate
|
|
a stream being sent from an interrupt to a task. */
|
|
vBasicStreamBufferSendFromISR();
|
|
|
|
#if (configUSE_QUEUE_SETS == 1)
|
|
{ vQueueSetAccessQueueSetFromISR(); }
|
|
#endif
|
|
|
|
/* Test flop alignment in interrupts - calling printf from an interrupt
|
|
is BAD! */
|
|
#if (configASSERT_DEFINED == 1)
|
|
{
|
|
char cBuf[20];
|
|
UBaseType_t uxSavedInterruptStatus;
|
|
|
|
uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
|
|
{ sprintf(cBuf, "%1.3f", 1.234); }
|
|
portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
|
|
|
|
configASSERT(strcmp(cBuf, "1.234") == 0);
|
|
}
|
|
#endif /* configASSERT_DEFINED */
|
|
}
|
|
#endif
|
|
}
|
|
|