/* * FreeRTOS V202212.00 * Copyright (C) 2020 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. * * https://www.FreeRTOS.org * https://github.com/FreeRTOS * */ /****************************************************************************** * NOTE 1: This project provides two demo applications. A simple blinky style * project, and a more comprehensive test and demo application. The * mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting in main.c is used to select * between the two. See the notes on using mainCREATE_SIMPLE_BLINKY_DEMO_ONLY * in main.c. This file implements the simply blinky style version. * * NOTE 2: This file only contains the source code that is specific to the * basic demo. Generic functions, such FreeRTOS hook functions, and functions * required to configure the hardware, along with an example interrupt service * routine, are defined in main.c. ****************************************************************************** * * main_blinky() creates one queue, and two tasks. It then starts the * scheduler. * * The Queue Send Task: * The queue send task is implemented by the prvQueueSendTask() function in * this file. prvQueueSendTask() sits in a loop that causes it to repeatedly * block for 200 milliseconds, before sending the value 100 to the queue that * was created within main_blinky(). Once the value is sent, the task loops * back around to block for another 200 milliseconds. * * The Queue Receive Task: * The queue receive task is implemented by the prvQueueReceiveTask() function * in this file. prvQueueReceiveTask() sits in a loop where it repeatedly * blocks on attempts to read data from the queue that was created within * main_blinky(). When data is received, the task checks the value of the * data, and if the value equals the expected 100, toggles the LED. The 'block * time' parameter passed to the queue receive function specifies that the * task should be held in the Blocked state indefinitely to wait for data to * be available on the queue. The queue receive task will only leave the * Blocked state when the queue send task writes to the queue. As the queue * send task writes to the queue every 200 milliseconds, the queue receive * task leaves the Blocked state every 200 milliseconds, and therefore toggles * the LED every 200 milliseconds. */ /* Standard includes. */ #include /* Kernel includes. */ #include "FreeRTOS.h" #include "task.h" #include "semphr.h" /* Eval board specific definitions. */ #include "demo_specific_io.h" /* Priorities at which the tasks are created. */ #define mainQUEUE_RECEIVE_TASK_PRIORITY ( tskIDLE_PRIORITY + 2 ) #define mainQUEUE_SEND_TASK_PRIORITY ( tskIDLE_PRIORITY + 1 ) /* The rate at which data is sent to the queue. The 200ms value is converted * to ticks using the portTICK_PERIOD_MS constant. */ #define mainQUEUE_SEND_FREQUENCY_MS ( 200 / portTICK_PERIOD_MS ) /* The number of items the queue can hold. This is 1 as the receive task * will remove items as they are added, meaning the send task should always find * the queue empty. */ #define mainQUEUE_LENGTH ( 1 ) /* Used to check the task parameter passing in both supported memory models. */ #if __DATA_MODEL__ == __DATA_MODEL_FAR__ #define mainQUEUE_SEND_PARAMETER ( ( void * ) 0x12345678UL ) #define mainQUEUE_RECEIVE_PARAMETER ( ( void * ) 0x11223344UL ) #else #define mainQUEUE_SEND_PARAMETER ( ( void * ) 0x1234U ) #define mainQUEUE_RECEIVE_PARAMETER ( ( void * ) 0x1122U ) #endif /*-----------------------------------------------------------*/ /* * The tasks as described in the comments at the top of this file. */ static void prvQueueReceiveTask( void * pvParameters ); static void prvQueueSendTask( void * pvParameters ); /* * Called by main() to create the simply blinky style application if * mainCREATE_SIMPLE_BLINKY_DEMO_ONLY is set to 1. */ void main_blinky( void ); /*-----------------------------------------------------------*/ /* The queue used by both tasks. */ static QueueHandle_t xQueue = NULL; /*-----------------------------------------------------------*/ void main_blinky( void ) { /* Create the queue. */ xQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( unsigned long ) ); if( xQueue != NULL ) { /* Start the two tasks as described in the comments at the top of this * file. */ xTaskCreate( prvQueueReceiveTask, /* The function that implements the task. */ "Rx", /* The text name assigned to the task - for debug only as it is not used by the kernel. */ configMINIMAL_STACK_SIZE, /* The size of the stack to allocate to the task. */ mainQUEUE_RECEIVE_PARAMETER, /* The parameter passed to the task - just used to check the port in this case. */ mainQUEUE_RECEIVE_TASK_PRIORITY, /* The priority assigned to the task. */ NULL ); /* The task handle is not required, so NULL is passed. */ xTaskCreate( prvQueueSendTask, "TX", configMINIMAL_STACK_SIZE, mainQUEUE_SEND_PARAMETER, mainQUEUE_SEND_TASK_PRIORITY, NULL ); /* Start the tasks and timer running. */ vTaskStartScheduler(); } /* If all is well, the scheduler will now be running, and the following * line will never be reached. If the following line does execute, then * there was insufficient FreeRTOS heap memory available for the idle and/or * timer tasks to be created. See the memory management section on the * FreeRTOS web site for more details. http://www.freertos.org/a00111.html. */ for( ; ; ) { } } /*-----------------------------------------------------------*/ static void prvQueueSendTask( void * pvParameters ) { TickType_t xNextWakeTime; const unsigned long ulValueToSend = 100UL; /* Check the parameter was passed in correctly. */ configASSERT( pvParameters == mainQUEUE_SEND_PARAMETER ) /* Initialise xNextWakeTime - this only needs to be done once. */ xNextWakeTime = xTaskGetTickCount(); for( ; ; ) { /* Place this task in the blocked state until it is time to run again. */ vTaskDelayUntil( &xNextWakeTime, mainQUEUE_SEND_FREQUENCY_MS ); /* * Send to the queue - causing the queue receive task to unblock and * toggle the LED. 0 is used as the block time so the sending operation * will not block - it shouldn't need to block as the queue should always * be empty at this point in the code. */ xQueueSend( xQueue, &ulValueToSend, 0U ); } } /*-----------------------------------------------------------*/ static void prvQueueReceiveTask( void * pvParameters ) { unsigned long ulReceivedValue; const unsigned long ulExpectedValue = 100UL; /* Check the parameter was passed in correctly. */ configASSERT( pvParameters == mainQUEUE_RECEIVE_PARAMETER ) for( ; ; ) { /* * Wait until something arrives in the queue - this task will block * indefinitely provided INCLUDE_vTaskSuspend is set to 1 in * FreeRTOSConfig.h. */ xQueueReceive( xQueue, &ulReceivedValue, portMAX_DELAY ); /* * To get here something must have been received from the queue, but * is it the expected value? If it is, toggle the LED. */ if( ulReceivedValue == ulExpectedValue ) { LED_BIT = !LED_BIT; ulReceivedValue = 0U; } } } /*-----------------------------------------------------------*/