static void prvOptionallyCreateComprehensveTestApplication( void ) { #if ( mainCREATE_SIMPLE_LED_FLASHER_DEMO_ONLY == 0 ) { xTimerHandle xCheckTimer = NULL; /* Configure the interrupts used to test FPU registers being used from nested interrupts. */ prvSetupNestedFPUInterruptsTest(); /* Start all the other standard demo/test tasks. */ vStartIntegerMathTasks( tskIDLE_PRIORITY ); vStartDynamicPriorityTasks(); vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartCountingSemaphoreTasks(); vStartGenericQueueTasks( tskIDLE_PRIORITY ); vStartRecursiveMutexTasks(); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); /* Most importantly, start the tasks that use the FPU. */ vStartMathTasks( mainFLOP_TASK_PRIORITY ); /* Create the register check tasks, as described at the top of this file */ xTaskCreate( vRegTest1Task, "Reg1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( vRegTest2Task, "Reg2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* Create the semaphore that is used to demonstrate a task being synchronised with an interrupt. */ vSemaphoreCreateBinary( xTestSemaphore ); /* Create the task that is unblocked by the demonstration interrupt. */ xTaskCreate( prvButtonTestTask, "BtnTest", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* Create the software timer that performs the 'check' functionality, as described at the top of this file. */ 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 ); } /* 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 ) vRegTest1Task; ( void ) vRegTest2Task; ( void ) prvCheckTimerCallback; ( void ) prvSetupNestedFPUInterruptsTest; } #endif /* mainCREATE_SIMPLE_LED_FLASHER_DEMO_ONLY */ }
int main(void) { /* Configure the NVIC, LED outputs and button inputs. */ prvSetupHardware(); /* Create the queue. */ xQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( unsigned long ) ); if( xQueue != NULL ) { /* Start the two application specific demo tasks, as described in the comments at the top of this file. */ xTaskCreate( prvQueueReceiveTask, ( signed char * ) "Rx", configMINIMAL_STACK_SIZE, NULL, mainQUEUE_RECEIVE_TASK_PRIORITY, NULL ); xTaskCreate( prvQueueSendTask, ( signed char * ) "TX", configMINIMAL_STACK_SIZE, NULL, mainQUEUE_SEND_TASK_PRIORITY, NULL ); /* Create the software timer that is responsible for turning off the LED if the button is not pushed within 5000ms, as described at the top of this file. */ xLEDTimer = xTimerCreate( ( const signed char * ) "LEDTimer", /* A text name, purely to help debugging. */ ( mainLED_TIMER_PERIOD_MS ), /* The timer period, in this case 5000ms (5s). */ pdFALSE, /* This is a one shot timer, so xAutoReload is set to pdFALSE. */ ( void * ) 0, /* The ID is not used, so can be set to anything. */ prvLEDTimerCallback /* The callback function that switches the LED off. */ ); /* 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. */ ); /* Create the software timer that performs the 'digit counting' functionality, as described at the top of this file. */ xDigitCounterTimer = xTimerCreate( ( const signed char * ) "DigitCounter", /* A text name, purely to help debugging. */ ( mainDIGIT_COUNTER_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. */ prvDigitCounterTimerCallback /* The callback function that inspects the status of all the other tasks. */ ); /* Create a lot of 'standard demo' tasks. Over 40 tasks are created in this demo. For a much simpler demo, select the 'blinky' build configuration. */ vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); vCreateBlockTimeTasks(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY ); vStartQueuePeekTasks(); vStartRecursiveMutexTasks(); vStartTimerDemoTask( mainTIMER_TEST_PERIOD ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartCountingSemaphoreTasks(); vStartDynamicPriorityTasks(); /* 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 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. */ for( ;; ); }
int main( void ) { /* MTJ: initialize syscalls -- *must* be first */ // syscalls.c contains the files upon which the standard (and portable) C libraries rely init_syscalls(); // Set up the LED ports and turn them off vtInitLED(); /* Configure the hardware for use by this demo. */ prvSetupHardware(); #if USE_FREERTOS_DEMO == 1 /* 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(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); vStartRecursiveMutexTasks(); vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY ); #endif #if USE_WEB_SERVER == 1 // Not a standard demo -- but also not one of mine (MTJ) /* Create the uIP task. The WEB server runs in this task. */ xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL ); #endif #if USE_MTJ_LCD == 1 // MTJ: My LCD demonstration task StartLCDTask(&vtLCDdata,mainLCD_TASK_PRIORITY); // LCD Task creates a queue to receive messages -- what it does with those messages will depend on how the task is configured (see LCDtask.c) // Here we set up a timer that will send messages to the LCD task. You don't have to have this timer for the LCD task, it is just showing // how to use a timer and how to send messages from that timer. //Commented out by Matthew Ibarra 2/2/2013 //startTimerForLCD(&vtLCDdata); #endif #if USE_MTJ_V4Temp_Sensor == 1 // MTJ: My i2cTemp demonstration task // First, start up an I2C task and associate it with the I2C0 hardware on the ARM (there are 3 I2C devices, we need this one) // See vtI2C.h & vtI2C.c for more details on this task and the API to access the task // Initialize I2C0 for I2C0 at an I2C clock speed of 100KHz if (vtI2CInit(&vtI2C0,0,mainI2CMONITOR_TASK_PRIORITY,100000) != vtI2CInitSuccess) { VT_HANDLE_FATAL_ERROR(0); } // Now, start up the task that is going to handle the temperature sensor sampling (it will talk to the I2C task and LCD task using their APIs) #if USE_MTJ_LCD == 1 vStarti2cTempTask(&tempSensorData,mainI2CTEMP_TASK_PRIORITY,&vtI2C0,&vtLCDdata); #else vStarti2cTempTask(&tempSensorData,mainI2CTEMP_TASK_PRIORITY,&vtI2C0,NULL); #endif // Here we set up a timer that will send messages to the Temperature sensing task. The timer will determine how often the sensor is sampled startTimerForTemperature(&tempSensorData); // start up a "conductor" task that will move messages around vStartConductorTask(&conductorData,mainCONDUCTOR_TASK_PRIORITY,&vtI2C0,&tempSensorData); #endif /* Create the USB task. MTJ: This routine has been modified from the original example (which is not a FreeRTOS standard demo) */ #if USE_MTJ_USE_USB == 1 initUSB(); // MTJ: This is my routine used to make sure we can do printf() with USB xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, mainUSB_TASK_PRIORITY, NULL ); #endif /* Start the scheduler. */ // IMPORTANT: Once you start the scheduler, any variables on the stack from main (local variables in main) can be (will be...) written over // because the stack is used by the interrupt handler vTaskStartScheduler(); /* Will only get here if there was insufficient memory to create the idle task. The idle task is created within vTaskStartScheduler(). */ for( ;; ); }
void main_full( void ) { TimerHandle_t xTimer = NULL; /* Start all the standard demo/test tasks. These 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 ); vStartMathTasks( mainFLOP_TASK_PRIORITY ); vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED ); /* Create the register test tasks, as described at the top of this file. */ xTaskCreate( vRegTestTask1, "Reg1...", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); xTaskCreate( vRegTestTask2, "Reg2...", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL ); /* 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 ); } /* Create the software timer that performs the 'LED spin' functionality, as described at the top of this file. */ xTimer = xTimerCreate( "LEDTimer", /* A text name, purely to help debugging. */ ( mainLED_TIMER_PERIOD_MS ),/* The timer period, in this case 75ms. */ 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. */ prvLEDTimerCallback /* The callback function that toggles the white LEDs. */ ); if( xTimer != NULL ) { xTimerStart( xTimer, 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( ;; ); }
/*--------------------------------------------------------------------------- * main() *---------------------------------------------------------------------------*/ 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. */ #if ( INCLUDE_StartLEDFlashTasks == 1 ) vStartLEDFlashTasks( mainLED_TASK_PRIORITY ); #endif #if ( INCLUDE_StartIntegerMathTasks == 1 ) vStartIntegerMathTasks( tskIDLE_PRIORITY ); #endif #if ( INCLUDE_AltStartComTestTasks == 1 ) vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED - 1 ); #endif #if ( INCLUDE_StartPolledQueueTasks == 1 ) vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); #endif #if ( INCLUDE_StartSemaphoreTasks == 1 ) vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); #endif #if ( INCLUDE_StartBlockingQueueTasks == 1 ) vStartBlockingQueueTasks( mainQUEUE_BLOCK_PRIORITY ); #endif #if ( INCLUDE_StartDynamicPriorityTasks == 1 ) vStartDynamicPriorityTasks(); #endif #if ( INCLUDE_StartMathTasks == 1 ) vStartMathTasks( tskIDLE_PRIORITY ); #endif #if ( INCLUDE_StartFlashCoRoutines == 1 ) vStartFlashCoRoutines( ledNUMBER_OF_LEDS ); #endif #if ( INCLUDE_StartHookCoRoutines == 1 ) vStartHookCoRoutines(); #endif #if ( INCLUDE_StartGenericQueueTasks == 1 ) vStartGenericQueueTasks( mainGENERIC_QUEUE_PRIORITY ); #endif #if ( INCLUDE_StartQueuePeekTasks == 1 ) vStartQueuePeekTasks(); #endif #if ( INCLUDE_CreateBlockTimeTasks == 1 ) vCreateBlockTimeTasks(); #endif #if ( INCLUDE_CreateSuicidalTasks == 1 ) vCreateSuicidalTasks( mainDEATH_PRIORITY ); #endif #if ( INCLUDE_TraceListTasks == 1 ) vTraceListTasks( TASK_UTILITY_PRIORITY ); #endif /* Start the 'Check' task which is defined in this file. */ xTaskCreate( vErrorChecks, (signed portCHAR *) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); vTaskStartScheduler(); /* Should not reach here */ while( 1 ) { __asm( " NOP " ); /* // */ } }
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( ;; ); }
int main( void ) { /* MTJ: initialize syscalls -- *must* be first */ // syscalls.c contains the files upon which the standard (and portable) C libraries rely init_syscalls(); // Set up the LED ports and turn them off vtInitLED(); /* Configure the hardware for use by this demo. */ prvSetupHardware(); #if USE_FREERTOS_DEMO == 1 /* 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(); vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY ); vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); vStartQueuePeekTasks(); vStartRecursiveMutexTasks(); vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY ); #endif // Not a standard demo -- but also not one of mine (MTJ) /* Create the uIP task. The WEB server runs in this task. */ xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL ); // MTJ: My LCD demonstration task #if USE_MTJ_LCD == 1 vStartLCDTask( mainLCD_TASK_PRIORITY,&vtLCDdata); #endif // MTJ: My i2cTemp demonstration task #if USE_MTJ_V4Temp_Sensor == 1 vtI2C0.devNum = 0; vtI2C0.taskPriority = mainI2CMONITOR_TASK_PRIORITY; // Initialize I2C0 int retVal; if ((retVal = vtI2CInit(&vtI2C0,100000)) != vtI2CInitSuccess) { VT_HANDLE_FATAL_ERROR(retVal); } tempSensorParams.dev = &vtI2C0; #if USE_MTJ_LCD == 1 tempSensorParams.lcdData = &vtLCDdata; #else tempSensorParams.lcdData = NULL; #endif //vStarti2cTempTask(mainI2CTEMP_TASK_PRIORITY,&tempSensorParams); vStartSomeTask(mainI2CTEMP_TASK_PRIORITY, &tempSensorParams); #endif /* Create the USB task. MTJ: This routine has been modified from the original example (which is not a FreeRTOS standard demo) */ #if USE_MTJ_USE_USB == 1 initUSB(); // MTJ: This is my routine used to make sure we can do printf() with USB xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, mainUSB_TASK_PRIORITY, NULL ); #endif /* Start the scheduler. */ // IMPORTANT: Once you start the scheduler, any variables on the stack from main (local variables in main) can be (will be...) writtenover // because the stack is used by the interrupt handler vTaskStartScheduler(); /* Will only get here if there was insufficient memory to create the idle task. The idle task is created within vTaskStartScheduler(). */ for( ;; ); }