void vApplicationIdleHook( void ) { const unsigned long ulMSToSleep = 5; /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files is created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function. */ #if F_FS_THREAD_AWARE == 1 { static BaseType_t xCreatedSampleFiles = pdFALSE; /* Initialise the drive and file system, then create a few example files. The output from this function just goes to the stdout window, allowing the output to be viewed when the UDP command console is not connected. */ if( xCreatedSampleFiles == pdFALSE ) { vCreateAndVerifySampleFiles(); xCreatedSampleFiles = pdTRUE; } } #endif /* This function is called on each cycle of the idle task if configUSE_IDLE_HOOK is set to 1 in FreeRTOSConfig.h. Sleep to reduce CPU load. */ Sleep( ulMSToSleep ); }
int main( void ) { const uint32_t ulLongTime_ms = 250UL; /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files are created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function vApplicationIdleHook() - which is defined in this file. */ #if F_FS_THREAD_AWARE == 0 { /* Initialise the drive and file system, then create a few example files. The output from this function just goes to the stdout window, allowing the output to be viewed when the UDP command console is not connected. */ vCreateAndVerifySampleFiles(); } #endif /* Register generic commands with the FreeRTOS+CLI command interpreter. */ vRegisterSampleCLICommands(); /* Register file system related commands with the FreeRTOS+CLI command interpreter. */ vRegisterFileSystemCLICommands(); /* Create the task that handles the CLI on a UDP port. The port number is set using the configUDP_CLI_PORT_NUMBER setting in FreeRTOSConfig.h. */ xTaskCreate( vUDPCommandInterpreterTask, /* The function that implements the command interpreter IO handling. */ "CLI", /* The name of the task - just to assist debugging. */ configMINIMAL_STACK_SIZE, NULL, /* The size of the stack allocated to the task. */ mainUDP_CLI_TASK_PRIORITY, /* The priority at which the task will run. */ NULL ); /* A handle to the task is not required, so NULL is passed. */ /* Start the RTOS scheduler. */ 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 (this is standard text that is not not really applicable to the Win32 simulator port). */ for( ;; ) { Sleep( ulLongTime_ms ); } }
void vFullDemoIdleHook( void ) { static TimerHandle_t xCheckTimer = NULL; if( xCheckTimer == NULL ) { /* Create the software timer that performs the 'check' functionality, in the full demo. This is not done before the scheduler is started as to do so would prevent the standard demo timer tasks from passing their tests (they expect the timer command queue to be empty. */ xCheckTimer = xTimerCreate( "CheckTimer", /* A text name, purely to help debugging. */ ( mainCHECK_TIMER_PERIOD_MS ), /* The timer period, in this case 3000ms (3s). */ pdTRUE, /* This is an auto-reload timer, so xAutoReload is set to pdTRUE. */ ( void * ) 0, /* The ID is not used, so can be set to anything. */ prvCheckTimerCallback ); /* The callback function that inspects the status of all the other tasks. */ if( xCheckTimer != NULL ) { xTimerStart( xCheckTimer, mainDONT_BLOCK ); } /* Also start some timers that just flash LEDs. */ vStartLEDFlashTimers( mainNUM_FLASH_TIMER_LEDS ); } /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files is created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function. */ #if( F_FS_THREAD_AWARE == 1 ) { static portBASE_TYPE xCreatedSampleFiles = pdFALSE; /* Initialise the drive and file system, then create a few example files. The output from this function just goes to the stdout window, allowing the output to be viewed when the UDP command console is not connected. */ if( xCreatedSampleFiles == pdFALSE ) { vCreateAndVerifySampleFiles(); xCreatedSampleFiles = pdTRUE; } } #endif }
void vApplicationIdleHook( void ) { volatile size_t xFreeHeapSpace; /* 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(); /* Remove compiler warning about xFreeHeapSpace being set but never used. */ ( void ) xFreeHeapSpace; #if mainCREATE_SIMPLE_BLINKY_DEMO_ONLY != 1 { /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files is created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function. */ #if F_FS_THREAD_AWARE == 1 { static portBASE_TYPE xCreatedSampleFiles = pdFALSE; /* Initialise the drive and file system, then create a few example files. The output from this function just goes to the stdout window, allowing the output to be viewed when the UDP command console is not connected. */ if( xCreatedSampleFiles == pdFALSE ) { vCreateAndVerifySampleFiles(); xCreatedSampleFiles = pdTRUE; } } #endif } #endif }
static void prvPrepareForFullDemo( void ) { /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files are created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function vApplicationIdleHook() - which is defined in this file. */ #if F_FS_THREAD_AWARE == 0 { /* Initialise the drive and file system, then create a few example files. The output from this function just goes to the stdout window, allowing the output to be viewed when the UDP command console is not connected. */ vCreateAndVerifySampleFiles(); } #endif /* Register both the standard and file system related CLI commands. */ vRegisterSampleCLICommands(); vRegisterFileSystemCLICommands(); }
void vFullDemoIdleHook( void ) { /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files is created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function. */ #if( F_FS_THREAD_AWARE == 1 ) { static portBASE_TYPE xCreatedSampleFiles = pdFALSE; /* Initialise the drive and file system, then create a few example files. The output from this function just goes to the stdout window, allowing the output to be viewed when the UDP command console is not connected. */ if( xCreatedSampleFiles == pdFALSE ) { vCreateAndVerifySampleFiles(); xCreatedSampleFiles = pdTRUE; } } #endif }
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. */ #if configCREATE_SIMPLE_BLINKY_DEMO_ONLY != 1 { /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files is created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function. */ #if F_FS_THREAD_AWARE == 1 { static portBASE_TYPE xCreatedSampleFiles = pdFALSE; /* Initialise the drive and file system, then create a few example files. The output from this function just goes to the stdout window, allowing the output to be viewed when the UDP command console is not connected. */ if( xCreatedSampleFiles == pdFALSE ) { vCreateAndVerifySampleFiles(); xCreatedSampleFiles = pdTRUE; } } #endif } #endif }
int main_full( void ) { /* Usage instructions on http://www.FreeRTOS.org/Atmel_SAM4E_RTOS_Demo.html */ /* Initialise the LCD and output a bitmap. The IP address will also be displayed on the LCD when it has been obtained. */ vInitialiseLCD(); /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files are created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function vApplicationIdleHook(). */ #if( F_FS_THREAD_AWARE == 0 ) { /* Initialise the drive and file system, then create a few example files. The files can be viewed and accessed via the CLI. View the documentation page for this demo (link at the top of this file) for more information. */ vCreateAndVerifySampleFiles(); } #endif /* Register example generic, file system related and UDP related CLI commands respectively. Type 'help' into the command console to view a list of registered commands. */ vRegisterSampleCLICommands(); vRegisterFileSystemCLICommands(); vRegisterUDPCLICommands(); /* Initialise the network interface. Tasks that use the network are created in the network event hook when the network is connected and ready for use. The address values passed in here are used if ipconfigUSE_DHCP is set to 0, or if ipconfigUSE_DHCP is set to 1 but a DHCP server cannot be contacted. The IP address actually used is displayed on the LCD (after DHCP has completed if DHCP is used). */ FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress ); /* Create all the other standard demo tasks. */ vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); vStartCountingSemaphoreTasks(); vStartDynamicPriorityTasks(); vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_TASK_PRIORITY ); vStartQueueSetTasks(); vStartRecursiveMutexTasks(); vStartEventGroupTasks(); vStartTaskNotifyTask(); vStartInterruptSemaphoreTasks(); vStartTimerDemoTask( mainTIMER_TEST_PERIOD ); vStartInterruptQueueTasks(); /* Create the register check tasks, as described at the top of this file */ xTaskCreate( prvRegTest1Task, "Reg1", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( prvRegTest2Task, "Reg2", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL ); /* Start the scheduler itself. */ 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. */ for( ;; ); }
int main_full( void ) { TimerHandle_t xTimer = NULL; /* Usage instructions on http://www.FreeRTOS.org/Atmel_SAM4E_RTOS_Demo.html */ /* Initialise the LCD and output a bitmap. The IP address will also be displayed on the LCD when it has been obtained. */ vInitialiseLCD(); /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files are created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function vApplicationIdleHook(). */ #if( F_FS_THREAD_AWARE == 0 ) { /* Initialise the drive and file system, then create a few example files. The files can be viewed and accessed via the CLI. View the documentation page for this demo (link at the top of this file) for more information. */ vCreateAndVerifySampleFiles(); } #endif /* Register example generic, file system related and UDP related CLI commands respectively. Type 'help' into the command console to view a list of registered commands. */ vRegisterSampleCLICommands(); vRegisterFileSystemCLICommands(); vRegisterUDPCLICommands(); /* Initialise the network interface. Tasks that use the network are created in the network event hook when the network is connected and ready for use. The address values passed in here are used if ipconfigUSE_DHCP is set to 0, or if ipconfigUSE_DHCP is set to 1 but a DHCP server cannot be contacted. The IP address actually used is displayed on the LCD (after DHCP has completed if DHCP is used). */ FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress ); /* Create all the other standard demo tasks. */ vStartLEDFlashTimers( mainNUM_FLASH_TIMER_LEDS ); vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); vStartCountingSemaphoreTasks(); vStartDynamicPriorityTasks(); vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_TASK_PRIORITY ); vStartQueueSetTasks(); vStartRecursiveMutexTasks(); vStartEventGroupTasks(); /* Create the software timer that performs the 'check' functionality, as described at the top of this file. */ xTimer = xTimerCreate( "CheckTimer", /* A text name, purely to help debugging. */ ( mainCHECK_TIMER_PERIOD_MS ), /* The timer period, in this case 3000ms (3s). */ pdTRUE, /* This is an auto-reload timer, so xAutoReload is set to pdTRUE. */ ( void * ) 0, /* The ID is not used, so can be set to anything. */ prvCheckTimerCallback ); /* The callback function that inspects the status of all the other tasks. */ if( xTimer != NULL ) { xTimerStart( xTimer, mainDONT_BLOCK ); } /* Start the scheduler itself. */ 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. */ for( ;; ); }
void main_full( void ) { /* The baud rate setting here has no effect, hence it is set to 0 to make that obvious. */ xSerialPortInitMinimal( 0, mainUART_QUEUE_LENGTHS ); /* If the file system is only going to be accessed from one task then F_FS_THREAD_AWARE can be set to 0 and the set of example files are created before the RTOS scheduler is started. If the file system is going to be access from more than one task then F_FS_THREAD_AWARE must be set to 1 and the set of sample files are created from the idle task hook function vApplicationIdleHook() - which is defined in this file. */ #if ( mainINCLUDE_FAT_SL_DEMO == 1 )&& ( F_FS_THREAD_AWARE == 0 ) { /* Initialise the drive and file system, then create a few example files. The output from this function just goes to the stdout window, allowing the output to be viewed when the UDP command console is not connected. */ vCreateAndVerifySampleFiles(); } #endif /* Start all the other standard demo/test tasks. The have not particular functionality, but do demonstrate how to use the FreeRTOS API and test the kernel port. */ vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartCountingSemaphoreTasks(); vStartGenericQueueTasks( tskIDLE_PRIORITY ); vStartRecursiveMutexTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartMathTasks( mainFLOP_TASK_PRIORITY ); vStartTimerDemoTask( mainTIMER_TEST_PERIOD ); vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_PRIORITY ); #if mainINCLUDE_FAT_SL_DEMO == 1 { /* Start the tasks that implements the command console on the UART, as described above. */ vUARTCommandConsoleStart( mainUART_COMMAND_CONSOLE_STACK_SIZE, mainUART_COMMAND_CONSOLE_TASK_PRIORITY ); /* Register both the standard and file system related CLI commands. */ vRegisterSampleCLICommands(); vRegisterFileSystemCLICommands(); } #else { /* The COM test tasks can use the UART if the CLI is not used by the FAT SL demo. The COM test tasks require a UART connector to be fitted to the UART port. */ vAltStartComTestTasks( mainCOM_TEST_TASK_PRIORITY, mainBAUD_RATE, mainCOM_TEST_LED ); } #endif /* Create the register check tasks, as described at the top of this file */ xTaskCreate( prvRegTestTaskEntry1, ( signed char * ) "Reg1", configMINIMAL_STACK_SIZE, mainREG_TEST_TASK_1_PARAMETER, tskIDLE_PRIORITY, NULL ); xTaskCreate( prvRegTestTaskEntry2, ( signed char * ) "Reg2", configMINIMAL_STACK_SIZE, mainREG_TEST_TASK_2_PARAMETER, tskIDLE_PRIORITY, NULL ); /* Create the task that performs the 'check' functionality, as described at the top of this file. */ xTaskCreate( prvCheckTask, ( signed char * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* The set of tasks created by the following function call have to be created last as they keep account of the number of tasks they expect to see running. */ vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY ); /* Start the scheduler. */ 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 either insufficient FreeRTOS heap memory available for the idle and/or timer tasks to be created, or vTaskStartScheduler() was called from User mode. See the memory management section on the FreeRTOS web site for more details on the FreeRTOS heap http://www.freertos.org/a00111.html. The mode from which main() is called is set in the C start up code and must be a privileged mode (not user mode). */ for( ;; ); }