/* * Create the demo tasks then start the scheduler. */ int main( void ) { /* Configure any hardware required for this demo. */ prvSetupHardware(); /* Create the standard demo tasks. */ vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartFlashCoRoutines( mainNUM_FLASH_COROUTINES ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vCreateBlockTimeTasks(); /* Create the test tasks defined within this file. */ xTaskCreate( vCheckTask, "Check", mainCHECK_TAKS_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Start the task that will control the LCD. This returns the handle to the queue used to write text out to the task. */ xLCDQueue = xStartLCDTask(); /* Start the high frequency interrupt test. */ vSetupTimerTest( mainTEST_INTERRUPT_FREQUENCY ); /* Finally start the scheduler. */ vTaskStartScheduler(); /* Will only reach here if there is insufficient heap available to start the scheduler. */ return 0; }
/* * Starts all the other tasks, then starts the scheduler. */ int main( void ) { /* Setup the hardware for use with the Olimex demo board. */ prvSetupHardware(); /* Start the demo/test application tasks. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartMathTasks( tskIDLE_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); /* Start the check task - which is defined in this file. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Now all the tasks have been started - start the scheduler. NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode. The processor MUST be in supervisor mode when vTaskStartScheduler is called. The demo applications included in the FreeRTOS.org download switch to supervisor mode prior to main being called. If you are not using one of these demo application projects then ensure Supervisor mode is used here. */ vTaskStartScheduler(); /* Should never reach here! */ return 0; }
int main( void ) { /* Prepare the hardware. */ prvSetupHardware(); /* Create the queue used by the LCD task. Messages for display on the LCD are received via this queue. */ xLCDQueue = xQueueCreate( mainLCD_QUEUE_SIZE, sizeof( xLCDMessage ) ); /* Start the standard demo tasks. These do nothing other than test the port and provide some APU usage examples. */ vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartRecursiveMutexTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartQueuePeekTasks(); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainBAUD_RATE, mainCOM_TEST_LED ); /* Start the tasks defined within this file/specific to this demo. */ xTaskCreate( prvLCDTask, "LCD", mainLCD_TASK_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* Start the scheduler. */ vTaskStartScheduler(); /* Will only get here if there was insufficient memory to create the idle task. */ return 0; }
/* * Starts all the other tasks, then starts the scheduler. */ void main( void ) { /* Initialise the hardware including the system clock and on board LED. */ prvSetupHardware(); /* Initialise the port that controls the external LED's utilized by the flash tasks. */ vParTestInitialise(); /* Start the used standard demo tasks. */ vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartIntegerMathTasks( mainINTEGER_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); /* Start the tasks defined in this file. The first three never block so must not be used with the co-operative scheduler. */ #if configUSE_PREEMPTION == 1 { xTaskCreate( vRegisterCheck, "RegChck", configMINIMAL_STACK_SIZE, mainDUMMY_POINTER, tskIDLE_PRIORITY, ( xTaskHandle * ) NULL ); xTaskCreate( vFLOPCheck1, "FLOP", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, ( xTaskHandle * ) NULL ); xTaskCreate( vFLOPCheck2, "FLOP", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, ( xTaskHandle * ) NULL ); } #endif xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, ( xTaskHandle * ) NULL ); /* Finally kick off the scheduler. This function should never return. */ vTaskStartScheduler(); /* Should never reach here as the tasks will now be executing under control of the scheduler. */ }
/* Create all the demo application tasks, then start the scheduler. */ int main( void ) { /* Perform any hardware setup necessary. */ prvSetupHardware(); vParTestInitialise(); /* Create the queue used to communicate with the LCD print task. */ xLCDQueue = xQueueCreate( mainLCD_QUEUE_LENGTH, sizeof( LCDMessage ) ); /* Create the standard demo application tasks. See the WEB documentation for more information on these tasks. */ vCreateBlockTimeTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartDynamicPriorityTasks(); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartIntegerMathTasks( tskIDLE_PRIORITY ); /* Create the tasks defined within this file. */ xTaskCreate( vPrintTask, ( signed char * ) "LCD", configMINIMAL_STACK_SIZE, NULL, mainLCD_TASK_PRIORITY, NULL ); xTaskCreate( vCheckTask, ( signed char * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); vTaskStartScheduler(); /* Execution will only reach here if there was insufficient heap to start the scheduler. */ return 0; }
/* * Starts all the other tasks, then starts the scheduler. */ int main( void ) { /* Setup the hardware for use with the Xilinx evaluation board. */ prvSetupHardware(); /* Start the demo/test application tasks. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStart7SegTasks( main7SEG_TASK_PRIORITY ); vStartRegTestTasks(); /* Start the check task - which is defined in this file. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Now all the tasks have been started - start the scheduler. */ vTaskStartScheduler(); /* Should never reach here! */ for( ;; ); }
short main( void ) { prvIncrementResetCount(); /* Setup the LED's for output. */ vParTestInitialise(); /* Create the standard demo tasks. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartRegTestTasks(); /* Create the tasks defined within this file. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Create the co-routines that flash the LED's. */ vStartFlashCoRoutines( mainNUM_FLASH_COROUTINES ); /* In this port, to use preemptive scheduler define configUSE_PREEMPTION as 1 in portmacro.h. To use the cooperative scheduler define configUSE_PREEMPTION as 0. */ vTaskStartScheduler(); return 0; }
/* * Starts all the other tasks, then starts the scheduler. */ void main( void ) { /* Setup any hardware that has not already been configured by the low level init routines. */ prvSetupHardware(); /* Initialise the LED outputs for use by the demo application tasks. */ vParTestInitialise(); /* Start all the standard demo application tasks. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStartDynamicPriorityTasks(); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); /* Start the check task - which is defined in this file. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Start the scheduler. NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode. The processor MUST be in supervisor mode when vTaskStartScheduler is called. The demo applications included in the FreeRTOS.org download switch to supervisor mode prior to main being called. If you are not using one of these demo application projects then ensure Supervisor mode is used here. */ vTaskStartScheduler(); /* We should never get here as control is now taken by the scheduler. */ return; }
/* * Application entry point: * Starts all the other tasks, then starts the scheduler. */ int main( void ) { /* Setup the hardware for use with the Keil demo board. */ prvSetupHardware(); /* Start the demo/test application tasks. */ vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartDynamicPriorityTasks(); /* Start the check task - which is defined in this file. This is the task that periodically checks to see that all the other tasks are executing without error. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Now all the tasks have been started - start the scheduler. NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode. The processor MUST be in supervisor mode when vTaskStartScheduler is called. The demo applications included in the FreeRTOS.org download switch to supervisor mode prior to main being called. If you are not using one of these demo application projects then ensure Supervisor mode is used here. */ vTaskStartScheduler(); /* Should never reach here! If you do then there was not enough heap available for the idle task to be created. */ for( ;; ); }
/* * Create the demo tasks then start the scheduler. */ int main( void ) { /* Configure any hardware required for this demo. */ prvSetupHardware(); /* Create the LCD task - this returns the queue to use when writing messages to the LCD. */ xLCDQueue = xStartLCDTask(); /* Create all the other standard demo tasks. */ vStartLEDFlashTasks( tskIDLE_PRIORITY ); vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartInterruptQueueTasks(); /* Create the tasks defined within this file. */ xTaskCreate( prvTestTask1, "Tst1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( prvTestTask2, "Tst2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* prvCheckTask uses sprintf so requires more stack. */ xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Finally start the scheduler. */ vTaskStartScheduler(); /* Will only reach here if there is insufficient heap available to start the scheduler. */ return 0; }
/* * Start all the tasks then start the scheduler. */ int main( void ) { /* Setup the LED's for output. */ vParTestInitialise(); /* Start the various standard demo application tasks. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartMathTasks( tskIDLE_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); /* Start the 'Check' task. */ xTaskCreate( vErrorChecks, ( signed char * )"Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* In this port, to use preemptive scheduler define configUSE_PREEMPTION as 1 in portmacro.h. To use the cooperative scheduler define configUSE_PREEMPTION as 0. */ vTaskStartScheduler(); /* Should never get here! */ return 0; }
/* * Create the demo tasks then start the scheduler. */ int main_full( void ) { TimerHandle_t xTimer = NULL; /* Create the LCD task - this returns the queue to use when writing messages to the LCD. */ xLCDQueue = xStartLCDTask(); /* Create all the other standard demo tasks. */ vStartLEDFlashTimers( mainNUM_FLASH_TIMER_LEDS ); vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); vStartInterruptQueueTasks(); /* Create the tasks defined within this file. */ xTaskCreate( prvRegTestTask1, "Reg1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( prvRegTestTask2, "Reg2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* The PIC32MX795 uses an 8 deep fifo where TX interrupts are asserted whilst the TX buffer is empty. This causes an issue with the test driver so it is not used in this demo */ #if !defined(__32MX795F512L__) vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); #endif /* 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 ); } /* A software timer is also used to start the high frequency timer test. This is to ensure the test does not start before the kernel. This time a one shot software timer is used. */ xTimer = xTimerCreate( "HighHzTimerSetup", 1, pdFALSE, ( void * ) 0, prvSetupHighFrequencyTimerTest ); if( xTimer != NULL ) { xTimerStart( xTimer, mainDONT_BLOCK ); } /* Finally 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 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( ;; ); }
/* * Starts all the other tasks, then starts the scheduler. */ void main( void ) { #ifdef DEBUG debug(); #endif /* Setup any hardware that has not already been configured by the low level init routines. */ prvSetupHardware(); /* Create the queue used to send data to the LCD task. */ xLCDQueue = xQueueCreate( mainLCD_QUEUE_LEN, sizeof( xLCDMessage ) ); /* Start all the standard demo application tasks. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStartDynamicPriorityTasks(); vStartMathTasks( tskIDLE_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartGenericQueueTasks( mainGENERIC_QUEUE_PRIORITY ); vStartQueuePeekTasks(); /* Start the tasks which are defined in this file. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); xTaskCreate( prvLCDTask, "LCD", configMINIMAL_STACK_SIZE, ( void * ) &xLCDQueue, mainLCD_TASK_PRIORITY, NULL ); xTaskCreate( prvLCDMessageTask, "MSG", configMINIMAL_STACK_SIZE, ( void * ) &xLCDQueue, mainMSG_TASK_PRIORITY, NULL ); /* Start either the uIP TCP/IP stack or the lwIP TCP/IP stack. */ #ifdef STACK_UIP /* Finally, create the WEB server task. */ xTaskCreate( vuIP_Task, "uIP", configMINIMAL_STACK_SIZE * 3, NULL, mainCHECK_TASK_PRIORITY - 1, NULL ); #endif #ifdef STACK_LWIP /* Create the lwIP task. This uses the lwIP RTOS abstraction layer.*/ vlwIPInit(); sys_set_state( ( signed portCHAR * ) "httpd", lwipBASIC_SERVER_STACK_SIZE ); sys_thread_new( vBasicWEBServer, ( void * ) NULL, basicwebWEBSERVER_PRIORITY ); sys_set_default_state(); #endif /* Start the scheduler. NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode. The processor MUST be in supervisor mode when vTaskStartScheduler is called. The demo applications included in the FreeRTOS.org download switch to supervisor mode prior to main being called. If you are not using one of these demo application projects then ensure Supervisor mode is used here. */ vTaskStartScheduler(); /* We should never get here as control is now taken by the scheduler. */ for( ;; ); }
void main( void ) { /* Configure the peripherals used by this demo application. This includes configuring the joystick input select button to generate interrupts. */ prvSetupHardware(); /* Create the queue used by tasks and interrupts to send strings to the LCD task. */ xLCDQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( xQueueMessage ) ); /* If the queue could not be created then don't create any tasks that might attempt to use the queue. */ if( xLCDQueue != NULL ) { /* Create the standard demo tasks. */ vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartDynamicPriorityTasks(); vStartGenericQueueTasks( mainGENERIC_QUEUE_TEST_PRIORITY ); vStartCountingSemaphoreTasks(); /* Note that creating the timer test/demo tasks will fill the timer command queue. This is intentional, and forms part of the test the tasks perform. It does mean however that, after this function is called, no more timer commands can be sent until after the scheduler has been started (at which point the timer daemon will drained the timer command queue, freeing up space for more commands to be received). */ vStartTimerDemoTask( mainTIMER_TEST_PERIOD ); /* Create the LCD, button poll and register test tasks, as described at the top of this file. */ xTaskCreate( prvLCDTask, ( signed char * ) "LCD", configMINIMAL_STACK_SIZE * 2, mainTASK_PARAMETER_CHECK_VALUE, mainLCD_TASK_PRIORITY, NULL ); xTaskCreate( prvButtonPollTask, ( signed char * ) "BPoll", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( vRegTest1Task, ( signed char * ) "Reg1", configMINIMAL_STACK_SIZE, NULL, 0, NULL ); xTaskCreate( vRegTest2Task, ( signed char * ) "Reg2", configMINIMAL_STACK_SIZE, NULL, 0, NULL ); /* Create the 'check' timer - the timer that periodically calls the check function as described at the top of this file. Note that, for the reasons stated in the comments above the call to vStartTimerDemoTask(), that the check timer is not actually started until after the scheduler has been started. */ xCheckTimer = xTimerCreate( ( const signed char * ) "Check timer", mainCHECK_TIMER_PERIOD, pdTRUE, ( void * ) 0, vCheckTimerCallback ); /* Start the scheduler. */ vTaskStartScheduler(); } /* If all is well then this line will never be reached. If it is reached then it is likely that there was insufficient (FreeRTOS) heap memory space to create the idle task. This may have been trapped by the malloc() failed hook function, if one is configured. */ for( ;; ); }
void main_full( void ) { xTimerHandle xCheckTimer = NULL; /* 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. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartCountingSemaphoreTasks(); vStartGenericQueueTasks( tskIDLE_PRIORITY ); vStartRecursiveMutexTasks(); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartLEDFlashTimers( mainNUMBER_OF_FLASH_TIMERS_LEDS ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartQueueSetTasks(); /* Create the software timer that performs the 'check' functionality, as described at the top of this file. */ xCheckTimer = xTimerCreate( ( const signed char * ) "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 ); } /* 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 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( ;; ); }
/* Start all the demo application tasks, then start the scheduler. */ void main(void) { /* Initialise the hardware ready for the demo. */ prvSetupHardware(); /* Start the standard demo application tasks. */ vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartIntegerMathTasks( tskIDLE_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED - 1 ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartBlockingQueueTasks ( mainQUEUE_BLOCK_PRIORITY ); vStartDynamicPriorityTasks(); vStartMathTasks( tskIDLE_PRIORITY ); vStartGenericQueueTasks( mainGENERIC_QUEUE_PRIORITY ); vStartQueuePeekTasks(); vCreateBlockTimeTasks(); vStartFlashCoRoutines( mainNUM_FLASH_CO_ROUTINES ); /* Start the 'Check' task which is defined in this file. */ xTaskCreate( prvErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Start the 'Register Test' tasks as described at the top of this file. */ xTaskCreate( vFirstRegisterTestTask, "Reg1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( vSecondRegisterTestTask, "Reg2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* Start the task that write trace information to the UART. */ vUtilityStartTraceTask( mainUTILITY_TASK_PRIORITY ); /* If we are going to service the watchdog from within a task, then create the task here. */ #if WATCHDOG == WTC_IN_TASK vStartWatchdogTask( mainWATCHDOG_TASK_PRIORITY ); #endif /* The suicide tasks must be started last as they record the number of other tasks that exist within the system. The value is then used to ensure at run time the number of tasks that exists is within expected bounds. */ vCreateSuicidalTasks( mainDEATH_PRIORITY ); /* Now start the scheduler. Following this call the created tasks should be executing. */ vTaskStartScheduler( ); /* vTaskStartScheduler() will only return if an error occurs while the idle task is being created. */ for( ;; ); }
void main( void ) { InitIrqLevels(); /* Initialize interrupts */ __set_il( 7 ); /* Allow all levels */ prvSetupHardware(); #if WATCHDOG == WTC_IN_TASK vStartWatchdogTask( WTC_TASK_PRIORITY ); #endif /* Start the standard demo application tasks. */ vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartBlockingQueueTasks( mainQUEUE_BLOCK_PRIORITY ); vStartDynamicPriorityTasks(); vStartFlashCoRoutines( mainNUM_FLASH_CO_ROUTINES ); vStartGenericQueueTasks( mainGENERIC_QUEUE_PRIORITY ); vCreateBlockTimeTasks(); /* The definition INCLUDE_TraceListTasks is set within FreeRTOSConfig.h. */ #if INCLUDE_TraceListTasks == 1 vUtilityStartTraceTask( TASK_UTILITY_PRIORITY ); #else vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED - 1 ); #endif /* Start the 'Check' task which is defined in this file. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* The suicide tasks must be started last as they record the number of other tasks that exist within the system. The value is then used to ensure at run time the number of tasks that exists is within expected bounds. */ vCreateSuicidalTasks( mainDEATH_PRIORITY ); /* Now start the scheduler. Following this call the created tasks should be executing. */ vTaskStartScheduler( ); /* vTaskStartScheduler() will only return if an error occurs while the idle task is being created. */ for( ;; ); }
/* Creates the tasks, then starts the scheduler. */ void main( void ) { /* Initialise the required hardware. */ vParTestInitialise(); /* Start a few of the standard demo tasks found in the demo\common directory. */ vAltStartComTestTasks( mainCOMM_TEST_PRIORITY, mainBAUD_RATE, mainCOMM_TX_RX_LED ); /* Start the check task defined in this file. */ xTaskCreate( vErrorChecks, ( const char * const ) "Check", portMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Start the scheduler. Will never return here. */ vTaskStartScheduler(); while(1) /* This point should never be reached. */ { } }
int main(void) { #ifdef DEBUG debug(); #endif /* Set up the clocks and memory interface. */ // prvSetupHardware(); Board_Init(); LED_Config(); /* Create the queue used by the LCD task. Messages for display on the LCD are received via this queue. */ xLCDQueue = xQueueCreate( mainLCD_QUEUE_SIZE, sizeof( xLCDMessage ) ); /* Start the standard demo tasks. */ vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY ); vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); /* Start the tasks defined within this file/specific to this demo. */ xTaskCreate( vCheckTask, ( signed portCHAR * ) "Check", mainCHECK_TASK_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); xTaskCreate( vLCDTask, ( signed portCHAR * ) "LCD", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* The suicide tasks must be created last as they need to know how many tasks were running prior to their creation in order to ascertain whether or not the correct/expected number of tasks are running at any given time. */ vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY ); /* Configure the timers used by the fast interrupt timer test. */ vSetupHighFrequencyTimer(); /* Start the scheduler. */ vTaskStartScheduler(); /* Will only get here if there was insufficient memory to create the idle task. The idle task is created within vTaskStartScheduler(). */ for( ;; ); }
/* Create all the demo tasks then start the scheduler. */ void main( void ) { /* Just sets up the LED outputs. */ prvSetupHardware(); /* Standard demo tasks. */ vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); /* Create the check task as described at the top of this file. */ xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, mainCHECK_PARAMETER, mainCHECK_TASK_PRIORITY, NULL ); /* Create the RegTest tasks as described at the top of this file. */ xTaskCreate( vRegTest1, "Reg1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( vRegTest2, "Reg2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); #ifdef __IAR_V850ES_Fx3__ { /* The extra IO required for the com test and led flashing tasks is only available on the application board, not the target boards. */ vAltStartComTestTasks( mainCOMTEST_PRIORITY, mainBAUD_RATE, mainCOMTEST_LED ); vStartLEDFlashTasks( mainFLASH_PRIORITY ); /* The Fx3 also has enough RAM to run loads more tasks. */ vStartRecursiveMutexTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); } #endif /* The suicide tasks must be created last as they need to know how many tasks were running prior to their creation in order to ascertain whether or not the correct/expected number of tasks are running at any given time. */ vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY ); /* Start the scheduler. */ vTaskStartScheduler(); /* If this line is reached then vTaskStartScheduler() returned because there was insufficient heap memory remaining for the idle task to be created. */ for( ;; ); }
void main( void ) { /* Place your initialization/startup code here (e.g. MyInst_Start()) */ prvHardwareSetup(); /* Start the standard demo tasks. These are just here to exercise the kernel port and provide examples of how the FreeRTOS API can be used. */ vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartCountingSemaphoreTasks(); vStartDynamicPriorityTasks(); vStartMathTasks( mainINTEGER_TASK_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartQueuePeekTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartLEDFlashTasks( mainFLASH_TEST_TASK_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_TASK_PRIORITY, 57600, mainCOM_LED ); vStartInterruptQueueTasks(); /* Start the error checking task. */ ( void ) xTaskCreate( vCheckTask, ( signed portCHAR * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Configure the timers used by the fast interrupt timer test. */ vSetupTimerTest(); /* The suicide tasks must be created last as they need to know how many tasks were running prior to their creation in order to ascertain whether or not the correct/expected number of tasks are running at any given time. */ vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY ); /* Will only get here if there was insufficient memory to create the idle task. The idle task is created within vTaskStartScheduler(). */ vTaskStartScheduler(); /* Should never reach here as the kernel will now be running. If vTaskStartScheduler() does return then it is very likely that there was insufficient (FreeRTOS) heap space available to create all the tasks, including the idle task that is created within vTaskStartScheduler() itself. */ for( ;; ); }
/* Creates the tasks, then starts the scheduler. */ void main( void ) { /* Initialise the required hardware. */ vParTestInitialise(); /* Initialise the block memory allocator. */ vPortInitialiseBlocks(); /* Start the standard comtest tasks as defined in demo/common/minimal. */ vAltStartComTestTasks( mainCOMM_TEST_PRIORITY, mainBAUD_RATE, mainCOMM_TX_RX_LED ); /* Start the standard 32bit calculation task as defined in demo/common/minimal. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); /* Start the check task defined in this file. */ xTaskCreate( vErrorChecks, ( const char * const ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Start the scheduler. This will never return. */ vTaskStartScheduler(); }
void main( void ) { /* Configure the peripherals used by this demo application. This includes configuring the joystick input select button to generate interrupts. */ prvSetupHardware(); /* Create the queue used by tasks and interrupts to send strings to the LCD task. */ xLCDQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( xQueueMessage ) ); /* If the queue could not be created then don't create any tasks that might attempt to use the queue. */ if( xLCDQueue != NULL ) { /* Add the created queue to the queue registry so it can be viewed in the IAR FreeRTOS state viewer plug-in. */ vQueueAddToRegistry( xLCDQueue, "LCDQueue" ); /* Create the standard demo tasks. */ vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartDynamicPriorityTasks(); vStartGenericQueueTasks( mainGENERIC_QUEUE_TEST_PRIORITY ); /* Create the LCD, button poll and register test tasks, as described at the top of this file. */ xTaskCreate( prvLCDTask, ( signed char * ) "LCD", configMINIMAL_STACK_SIZE * 2, mainTASK_PARAMETER_CHECK_VALUE, mainLCD_TASK_PRIORITY, NULL ); xTaskCreate( prvButtonPollTask, ( signed char * ) "BPoll", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( vRegTest1Task, ( signed char * ) "Reg1", configMINIMAL_STACK_SIZE, NULL, 0, NULL ); xTaskCreate( vRegTest2Task, ( signed char * ) "Reg2", configMINIMAL_STACK_SIZE, NULL, 0, NULL ); /* Start the scheduler. */ vTaskStartScheduler(); } /* If all is well then this line will never be reached. If it is reached then it is likely that there was insufficient (FreeRTOS) heap memory space to create the idle task. This may have been trapped by the malloc() failed hook function, if one is configured. */ for( ;; ); }
int main( void ) { /* Start the crystal oscillator 0 and switch the main clock to it. */ pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP); portDBG_TRACE("Starting the FreeRTOS AVR32 UC3 Demo..."); /* Setup the LED's for output. */ vParTestInitialise(); /* Start the standard demo tasks. See the WEB documentation for more information. */ vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStartMathTasks( tskIDLE_PRIORITY ); /* Start the demo tasks defined within this file, specifically the check task as described at the top of this file. */ xTaskCreate( vErrorChecks , (const signed portCHAR *)"ErrCheck" , configMINIMAL_STACK_SIZE , NULL , mainCHECK_TASK_PRIORITY , NULL ); /* Start the scheduler. */ vTaskStartScheduler(); /* Will only get here if there was insufficient memory to create the idle task. */ return 0; }
/* * Start the demo application tasks - then start the real time scheduler. */ int main( void ) { /* Setup the hardware ready for the demo. */ prvSetupHardware(); vParTestInitialise(); /* Start the standard demo application tasks. */ vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); vStartIntegerMathTasks( tskIDLE_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED - 1 ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); /* Start the 'Check' task which is defined in this file. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Start the scheduler. */ vTaskStartScheduler(); /* As the scheduler has been started the demo applications tasks will be executing and we should never get here! */ return 0; }
static void prvOptionallyCreateComprehensveTestApplication( void ) { #if mainCREATE_SIMPLE_LED_FLASHER_DEMO_ONLY == 0 { vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartCountingSemaphoreTasks(); vStartGenericQueueTasks( tskIDLE_PRIORITY ); vStartRecursiveMutexTasks(); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vSetupInterruptNestingTest(); vStartTimerDemoTask( mainTIMER_TEST_PERIOD ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); /* Create the register test tasks, as described at the top of this file. */ xTaskCreate( prvRegisterCheckTask1, ( signed char * ) "Reg 1", configMINIMAL_STACK_SIZE, &ulRegisterTest1Count, tskIDLE_PRIORITY, NULL ); xTaskCreate( prvRegisterCheckTask2, ( signed char * ) "Reg 2", configMINIMAL_STACK_SIZE, &ulRegisterTest2Count, tskIDLE_PRIORITY, NULL ); /* Start the check task - which is defined in this file. */ xTaskCreate( prvCheckTask, ( signed char * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* This task has to be created last as it keeps account of the number of tasks it expects to see running. */ vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY ); } #else /* mainCREATE_SIMPLE_LED_FLASHER_DEMO_ONLY */ { /* Just to prevent compiler warnings when the configuration options are set such that these static functions are not used. */ ( void ) prvCheckTask; ( void ) prvRegisterCheckTask1; ( void ) prvRegisterCheckTask2; } #endif /* mainCREATE_SIMPLE_LED_FLASHER_DEMO_ONLY */ }
/* * 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(); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStartIntegerMathTasks( tskIDLE_PRIORITY ); /* 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 ); /* Must be the last demo created. */ vCreateSuicidalTasks( mainDEATH_PRIORITY ); /* All the tasks have been created - start the scheduler. */ vTaskStartScheduler(); /* Should not reach here! */ for( ;; ); }
void main_full( void ) { /* 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. */ vStartInterruptQueueTasks(); vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartCountingSemaphoreTasks(); vStartGenericQueueTasks( tskIDLE_PRIORITY ); vStartRecursiveMutexTasks(); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartQueueSetTasks(); vStartTaskNotifyTask(); vStartTimerDemoTask( mainTIMER_TEST_PERIOD ); vStartEventGroupTasks(); vStartInterruptSemaphoreTasks(); /* 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 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( ;; ); }
/* * Application entry point: * Starts all the other tasks, then starts the scheduler. */ int main( void ) { /* Setup the hardware for use with the Keil demo board. */ prvSetupHardware(); /* Start the demo/test application tasks. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); #ifdef KEIL_THUMB_INTERWORK /* When using THUMB mode we can start more tasks without the executable exceeding the size limit imposed by the evaluation version of uVision3. */ vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartDynamicPriorityTasks(); #endif /* Start the check task - which is defined in this file. This is the task that periodically checks to see that all the other tasks are executing without error. */ xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); /* Now all the tasks have been started - start the scheduler. NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode. The processor MUST be in supervisor mode when vTaskStartScheduler is called. The demo applications included in the FreeRTOS.org download switch to supervisor mode prior to main being called. If you are not using one of these demo application projects then ensure Supervisor mode is used here. */ vTaskStartScheduler(); /* Should never reach here! */ return 0; }
/*-----------------------------------------------------------*/ int main() { /* Perform any hardware setup necessary to run the demo. */ prvSetupHardware(); /* First create the 'standard demo' tasks. These exist just to to demonstrate API functions being used and test the kernel port. More information is provided on the FreeRTOS.org WEB site. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartCountingSemaphoreTasks(); vStartGenericQueueTasks( tskIDLE_PRIORITY ); vStartQueuePeekTasks(); vStartRecursiveMutexTasks(); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); /* Create the check task - this is the task that checks all the other tasks are executing as expected and without reporting any errors. */ xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, configMAX_PRIORITIES - 1, NULL ); /* The death demo tasks must be started last as the sanity checks performed require knowledge of the number of other tasks in the system. */ vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY ); /* Start the scheduler. From this point on the execution will be under the control of the kernel. */ vTaskStartScheduler(); /* Will only get here if there was insufficient heap availale for the idle task to be created. */ for( ;; ); }