/* * 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 * */ /* * * vMain() is effectively the demo application entry point. It is called by * the main() function generated by the Processor Expert application. * * vMain() creates all the demo application tasks, then starts the scheduler. * The WEB documentation provides more details of the demo application tasks. * * Main.c also creates a task called "Check". This only executes every three * seconds but has the highest priority so is guaranteed to get processor time. * Its main function is to check that all the other tasks are still operational. * Each task (other than the "flash" tasks) maintains a unique count that is * incremented each time the task successfully completes its function. Should * any error occur within such a task the count is permanently halted. The * check task inspects the count of each task to ensure it has changed since * the last time the check task executed. If all the count variables have * changed all the tasks are still executing error free, and the check task * toggles the onboard LED. Should any task contain an error at any time * the LED toggle rate will change from 3 seconds to 500ms. * * This file also includes the functionality normally implemented within the * standard demo application file integer.c. Due to the limited memory * available on the microcontroller the functionality has been included within * the idle task hook [vApplicationIdleHook()] - instead of within the usual * separate task. See the documentation within integer.c for the rationale * of the integer task functionality. * * * * The demo applications included with other FreeRTOS ports make use of the * standard ComTest tasks. These use a loopback connector to transmit and * receive RS232 characters between two tasks. The test is important for two * reasons: * * 1) It tests the mechanism of context switching from within an application * ISR. * * 2) It generates some randomised timing. * * The demo board used to develop this port does not include an RS232 interface * so the ComTest tasks could not easily be included. Instead these two tests * are created using a 'Button Push' task. * * The 'Button Push' task blocks on a queue, waiting for data to arrive. A * simple interrupt routine connected to the PP0 input on the demo board places * data in the queue each time the PP0 button is pushed (this button is built * onto the demo board). As the 'Button Push' task is created with a * relatively high priority it will unblock and want to execute as soon as data * arrives in the queue - resulting in a context switch within the PP0 input * ISR. If the data retrieved from the queue is that expected the 'Button Push' * task toggles LED 5. Therefore correct operation is indicated by the LED * toggling each time the PP0 button is pressed. * * This test is not as satisfactory as the ComTest method - but the simple * nature of the port makes is just about adequate. * */ /* Kernel includes. */ #include "FreeRTOS.h" #include "task.h" #include "queue.h" /* Demo application includes. */ #include "flash.h" #include "PollQ.h" #include "dynamic.h" #include "partest.h" /* Processor expert includes. */ #include "ButtonInterrupt.h" /*----------------------------------------------------------- * Definitions. * -----------------------------------------------------------*/ /* Priorities assigned to demo application tasks. */ #define mainFLASH_PRIORITY ( tskIDLE_PRIORITY + 2 ) #define mainCHECK_TASK_PRIORITY ( tskIDLE_PRIORITY + 3 ) #define mainBUTTON_TASK_PRIORITY ( tskIDLE_PRIORITY + 3 ) #define mainQUEUE_POLL_PRIORITY ( tskIDLE_PRIORITY + 2 ) /* LED that is toggled by the check task. The check task periodically checks * that all the other tasks are operating without error. If no errors are found * the LED is toggled with mainCHECK_PERIOD frequency. If an error is found * then the toggle rate increases to mainERROR_CHECK_PERIOD. */ #define mainCHECK_TASK_LED ( 7 ) #define mainCHECK_PERIOD ( ( TickType_t ) 3000 / portTICK_PERIOD_MS ) #define mainERROR_CHECK_PERIOD ( ( TickType_t ) 500 / portTICK_PERIOD_MS ) /* LED that is toggled by the button push interrupt. */ #define mainBUTTON_PUSH_LED ( 5 ) /* The constants used in the idle task calculation. */ #define intgCONST1 ( ( long ) 123 ) #define intgCONST2 ( ( long ) 234567 ) #define intgCONST3 ( ( long ) -3 ) #define intgCONST4 ( ( long ) 7 ) #define intgEXPECTED_ANSWER ( ( ( intgCONST1 + intgCONST2 ) * intgCONST3 ) / intgCONST4 ) /* The length of the queue between is button push ISR and the Button Push task * is greater than 1 to account for switch bounces generating multiple inputs. */ #define mainBUTTON_QUEUE_SIZE 6 /*----------------------------------------------------------- * Local functions prototypes. * -----------------------------------------------------------*/ /* * The 'Check' task function. See the explanation at the top of the file. */ static void vErrorChecks( void * pvParameters ); /* * The 'Button Push' task. See the explanation at the top of the file. */ static void vButtonTask( void * pvParameters ); /* * The idle task hook - in which the integer task is implemented. See the * explanation at the top of the file. */ void vApplicationIdleHook( void ); /* * Checks the unique counts of other tasks to ensure they are still operational. */ static long prvCheckOtherTasksAreStillRunning( void ); /*----------------------------------------------------------- * Local variables. * -----------------------------------------------------------*/ /* A few tasks are defined within this file. This flag is used to indicate * their status. If an error is detected in one of the locally defined tasks then * this flag is set to pdTRUE. */ portBASE_TYPE xLocalError = pdFALSE; /* The queue used to send data from the button push ISR to the Button Push * task. */ static QueueHandle_t xButtonQueue; /*-----------------------------------------------------------*/ /* * This is called from the main() function generated by the Processor Expert. */ void vMain( void ) { /* Start some of the standard demo tasks. */ vStartLEDFlashTasks( mainFLASH_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartDynamicPriorityTasks(); /* Start the locally defined tasks. There is also a task implemented as * the idle hook. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); xTaskCreate( vButtonTask, "Button", configMINIMAL_STACK_SIZE, NULL, mainBUTTON_TASK_PRIORITY, NULL ); /* All the tasks have been created - start the scheduler. */ vTaskStartScheduler(); /* Should not reach here! */ for( ; ; ) { } } /*-----------------------------------------------------------*/ static void vErrorChecks( void * pvParameters ) { TickType_t xDelayPeriod = mainCHECK_PERIOD; TickType_t xLastWakeTime; /* Initialise xLastWakeTime to ensure the first call to vTaskDelayUntil() * functions correctly. */ xLastWakeTime = xTaskGetTickCount(); for( ; ; ) { /* Delay until it is time to execute again. The delay period is * shorter following an error. */ vTaskDelayUntil( &xLastWakeTime, xDelayPeriod ); /* Check all the demo application tasks are executing without * error. If an error is found the delay period is shortened - this * has the effect of increasing the flash rate of the 'check' task * LED. */ if( prvCheckOtherTasksAreStillRunning() == pdFAIL ) { /* An error has been detected in one of the tasks - flash faster. */ xDelayPeriod = mainERROR_CHECK_PERIOD; } /* Toggle the LED each cycle round. */ vParTestToggleLED( mainCHECK_TASK_LED ); } } /*-----------------------------------------------------------*/ static long prvCheckOtherTasksAreStillRunning( void ) { portBASE_TYPE xAllTasksPassed = pdPASS; if( xArePollingQueuesStillRunning() != pdTRUE ) { xAllTasksPassed = pdFAIL; } if( xAreDynamicPriorityTasksStillRunning() != pdTRUE ) { xAllTasksPassed = pdFAIL; } /* Also check the status flag for the tasks defined within this function. */ if( xLocalError != pdFALSE ) { xAllTasksPassed = pdFAIL; } return xAllTasksPassed; } /*-----------------------------------------------------------*/ void vApplicationIdleHook( void ) { /* This variable is effectively set to a constant so it is made volatile to * ensure the compiler does not just get rid of it. */ volatile long lValue; /* Keep performing a calculation and checking the result against a constant. */ for( ; ; ) { /* Perform the calculation. This will store partial value in * registers, resulting in a good test of the context switch mechanism. */ lValue = intgCONST1; lValue += intgCONST2; lValue *= intgCONST3; lValue /= intgCONST4; /* Did we perform the calculation correctly with no corruption? */ if( lValue != intgEXPECTED_ANSWER ) { /* Error! */ portENTER_CRITICAL(); xLocalError = pdTRUE; portEXIT_CRITICAL(); } /* Yield in case cooperative scheduling is being used. */ #if configUSE_PREEMPTION == 0 { taskYIELD(); } #endif } } /*-----------------------------------------------------------*/ static void vButtonTask( void * pvParameters ) { unsigned portBASE_TYPE uxExpected = 1, uxReceived; /* Create the queue used by the producer and consumer. */ xButtonQueue = xQueueCreate( mainBUTTON_QUEUE_SIZE, ( unsigned portBASE_TYPE ) sizeof( unsigned portBASE_TYPE ) ); if( xButtonQueue ) { /* Now the queue is created it is safe to enable the button interrupt. */ ButtonInterrupt_Enable(); for( ; ; ) { /* Simply wait for data to arrive from the button push interrupt. */ if( xQueueReceive( xButtonQueue, &uxReceived, portMAX_DELAY ) == pdPASS ) { /* Was the data we received that expected? */ if( uxReceived != uxExpected ) { /* Error! */ portENTER_CRITICAL(); xLocalError = pdTRUE; portEXIT_CRITICAL(); } else { /* Toggle the LED for every successful push. */ vParTestToggleLED( mainBUTTON_PUSH_LED ); } uxExpected++; } } } /* Will only get here if the queue could not be created. */ for( ; ; ) { } } /*-----------------------------------------------------------*/ #pragma CODE_SEG __NEAR_SEG NON_BANKED /* Button push ISR. */ void interrupt vButtonPush( void ) { static unsigned portBASE_TYPE uxValToSend = 0; static unsigned long xHigherPriorityTaskWoken; xHigherPriorityTaskWoken = pdFALSE; /* Send an incrementing value to the button push task each run. */ uxValToSend++; /* Clear the interrupt flag. */ PIFP = 1; /* Send the incremented value down the queue. The button push task is * blocked waiting for the data. As the button push task is high priority * it will wake and a context switch should be performed before leaving * the ISR. */ xQueueSendFromISR( xButtonQueue, &uxValToSend, &xHigherPriorityTaskWoken ); if( xHigherPriorityTaskWoken ) { /* NOTE: This macro can only be used if there are no local * variables defined. This function uses a static variable so it's * use is permitted. If the variable were not static portYIELD() * would have to be used in it's place. */ portTASK_SWITCH_FROM_ISR(); } } #pragma CODE_SEG DEFAULT