| /* |
| FreeRTOS V9.0.1 - Copyright (C) 2017 Real Time Engineers Ltd. |
| All rights reserved |
| |
| VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION. |
| |
| This file is part of the FreeRTOS distribution. |
| |
| FreeRTOS is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License (version 2) as published by the |
| Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception. |
| |
| *************************************************************************** |
| >>! NOTE: The modification to the GPL is included to allow you to !<< |
| >>! distribute a combined work that includes FreeRTOS without being !<< |
| >>! obliged to provide the source code for proprietary components !<< |
| >>! outside of the FreeRTOS kernel. !<< |
| *************************************************************************** |
| |
| FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| FOR A PARTICULAR PURPOSE. Full license text is available on the following |
| link: http://www.freertos.org/a00114.html |
| |
| *************************************************************************** |
| * * |
| * FreeRTOS provides completely free yet professionally developed, * |
| * robust, strictly quality controlled, supported, and cross * |
| * platform software that is more than just the market leader, it * |
| * is the industry's de facto standard. * |
| * * |
| * Help yourself get started quickly while simultaneously helping * |
| * to support the FreeRTOS project by purchasing a FreeRTOS * |
| * tutorial book, reference manual, or both: * |
| * http://www.FreeRTOS.org/Documentation * |
| * * |
| *************************************************************************** |
| |
| http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading |
| the FAQ page "My application does not run, what could be wrong?". Have you |
| defined configASSERT()? |
| |
| http://www.FreeRTOS.org/support - In return for receiving this top quality |
| embedded software for free we request you assist our global community by |
| participating in the support forum. |
| |
| http://www.FreeRTOS.org/training - Investing in training allows your team to |
| be as productive as possible as early as possible. Now you can receive |
| FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers |
| Ltd, and the world's leading authority on the world's leading RTOS. |
| |
| http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, |
| including FreeRTOS+Trace - an indispensable productivity tool, a DOS |
| compatible FAT file system, and our tiny thread aware UDP/IP stack. |
| |
| http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate. |
| Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS. |
| |
| http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High |
| Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS |
| licenses offer ticketed support, indemnification and commercial middleware. |
| |
| http://www.SafeRTOS.com - High Integrity Systems also provide a safety |
| engineered and independently SIL3 certified version for use in safety and |
| mission critical applications that require provable dependability. |
| |
| 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 ) |
| { |
| taskENTER_CRITICAL(); |
| for( ;; ) |
| { |
| /* 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 ); |
| } |