/* | |
* FreeRTOS Kernel V10.0.1 | |
* Copyright (C) 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy of | |
* this software and associated documentation files (the "Software"), to deal in | |
* the Software without restriction, including without limitation the rights to | |
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of | |
* the Software, and to permit persons to whom the Software is furnished to do so, | |
* subject to the following conditions: | |
* | |
* The above copyright notice and this permission notice shall be included in all | |
* copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS | |
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR | |
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER | |
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
* | |
* http://www.FreeRTOS.org | |
* http://aws.amazon.com/freertos | |
* | |
* 1 tab == 4 spaces! | |
*/ | |
/****************************************************************************** | |
* This project provides two demo applications. A simple blinky style project, | |
* and a more comprehensive test and demo application. The | |
* configCREATE_SIMPLE_TICKLESS_DEMO setting (defined in FreeRTOSConfig.h) is | |
* used to select between the two. The simply blinky demo is implemented and | |
* described in main_blinky.c. The more comprehensive test and demo application | |
* is implemented and described in main_full.c. | |
* | |
* The blinky demo uses FreeRTOS's tickless idle mode to reduce power | |
* consumption. See the notes on the web page below regarding the difference | |
* in power saving that can be achieved between using the generic tickless | |
* implementation (as used by the blinky demo) and a tickless implementation | |
* that is tailored specifically to the CC3220. | |
* | |
* This file implements the code that is not demo specific. | |
* | |
* See http://www.FreeRTOS.org/TI_CC3220_SimpleLink_FreeRTOS_Demo.html for | |
* instructions. | |
* | |
*/ | |
/* Standard includes. */ | |
#include <stdio.h> | |
/* TI includes. */ | |
#include <ti/drivers/GPIO.h> | |
#include <ti/boards/CC3220SF_LAUNCHXL/Board.h> | |
/* Kernel includes. */ | |
#include "FreeRTOS.h" | |
#include "task.h" | |
/*-----------------------------------------------------------*/ | |
/* | |
* Set up the hardware ready to run this demo. | |
*/ | |
static void prvSetupHardware( void ); | |
/* | |
* main_blinky() is used when configCREATE_SIMPLE_TICKLESS_DEMO is set to 1. | |
* main_full() is used when configCREATE_SIMPLE_TICKLESS_DEMO is set to 0. | |
*/ | |
extern void main_blinky( void ); | |
extern void main_full( void ); | |
/*-----------------------------------------------------------*/ | |
int main( void ) | |
{ | |
/* See http://www.FreeRTOS.org/TI_CC3220_SimpleLink_FreeRTOS_Demo.html for | |
instructions. */ | |
/* Prepare the hardware to run this demo. */ | |
prvSetupHardware(); | |
/* The configCREATE_SIMPLE_TICKLESS_DEMO setting is described at the top | |
of this file. */ | |
#if( configCREATE_SIMPLE_TICKLESS_DEMO == 1 ) | |
{ | |
main_blinky(); | |
} | |
#else | |
{ | |
main_full(); | |
} | |
#endif | |
return 0; | |
} | |
/*-----------------------------------------------------------*/ | |
static void prvSetupHardware( void ) | |
{ | |
/* Call board init functions */ | |
Board_initGeneral(); | |
Board_initGPIO(); | |
GPIO_write( Board_LED0, Board_GPIO_LED_OFF ); | |
} | |
/*-----------------------------------------------------------*/ | |
void vMainToggleLED( void ) | |
{ | |
static uint32_t ulLEDState = Board_GPIO_LED_OFF; | |
ulLEDState = !ulLEDState; | |
GPIO_write( Board_LED0, ulLEDState ); | |
} | |
/*-----------------------------------------------------------*/ | |
void vApplicationMallocFailedHook( void ) | |
{ | |
/* 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). */ | |
taskDISABLE_INTERRUPTS(); | |
for( ;; ); | |
} | |
/*-----------------------------------------------------------*/ | |
void vApplicationIdleHook( void ) | |
{ | |
/* vApplicationIdleHook() will only be called if configUSE_IDLE_HOOK is set | |
to 1 in FreeRTOSConfig.h. It will be called on each iteration of the idle | |
task. It is essential that code added to this hook function never attempts | |
to block in any way (for example, call xQueueReceive() with a block time | |
specified, or call vTaskDelay()). If the application makes use of the | |
vTaskDelete() API function (as this demo application does) then it is also | |
important that vApplicationIdleHook() is permitted to return to its calling | |
function, because it is the responsibility of the idle task to clean up | |
memory allocated by the kernel to any task that has since been deleted. */ | |
} | |
/*-----------------------------------------------------------*/ | |
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName ) | |
{ | |
( void ) pcTaskName; | |
( void ) pxTask; | |
/* 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 *malloc( size_t xSize ) | |
{ | |
/* There should not be a heap defined, so trap any attempts to call | |
malloc. */ | |
taskDISABLE_INTERRUPTS(); | |
for( ;; ); | |
} | |
/*-----------------------------------------------------------*/ | |
/* 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 ) | |
{ | |
/* 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; | |
} | |
/*-----------------------------------------------------------*/ | |
/* Catch asserts so the file and line number of the assert can be viewed. */ | |
void vMainAssertCalled( const char *pcFileName, uint32_t ulLineNumber ) | |
{ | |
volatile BaseType_t xSetToNonZeroToStepOutOfLoop = 0; | |
taskENTER_CRITICAL(); | |
while( xSetToNonZeroToStepOutOfLoop == 0 ) | |
{ | |
/* Use the variables to prevent compiler warnings and in an attempt to | |
ensure they can be viewed in the debugger. If the variables get | |
optimised away then set copy their values to file scope or globals then | |
view the variables they are copied to. */ | |
( void ) pcFileName; | |
( void ) ulLineNumber; | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
/* To enable the libraries to build. */ | |
void PowerCC32XX_enterLPDS( void *driverlibFunc ) | |
{ | |
( void ) driverlibFunc; | |
/* This function is not implemented so trap any calls to it by halting | |
here. */ | |
configASSERT( driverlibFunc == NULL ); | |
} |