自学教程：C++ vCreateSuicidalTasks函数代码示例

/* * Starts all the other tasks, then starts the scheduler. */int main( void ){	/* Configure the processor. */	prvSetupHardware();	/* Setup the port used to flash the LED's. */	vParTestInitialise();	/* Start the task that handles the TCP/IP and WEB server functionality. */    xTaskCreate( vuIP_TASK, "uIP", mainUIP_TASK_STACK_SIZE, NULL, mainUIP_PRIORITY, NULL );		/* Start the demo/test application tasks.  These are created in addition	to the TCP/IP task for demonstration and test purposes. */	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartDynamicPriorityTasks();	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartLEDFlashTasks( mainFLASH_PRIORITY );	vStartIntegerMathTasks( tskIDLE_PRIORITY );	vStartMathTasks( tskIDLE_PRIORITY );	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 );	/* Must be last to get created. */	vCreateSuicidalTasks( mainDEATH_PRIORITY );	/* Now all the tasks have been started - start the scheduler. */	vTaskStartScheduler();	/* Should never reach here because the tasks should now be executing! */	return 0;}

/* Creates the tasks, then starts the scheduler. */void main( void ){	/* Initialise the required hardware. */	vParTestInitialise();	/* Send a character so we have some visible feedback of a reset. */	xSerialPortInitMinimal( mainBAUD_RATE, mainCOMMS_QUEUE_LENGTH );	xSerialPutChar( NULL, 'X', mainNO_BLOCK );	/* Start a few of the standard demo tasks found in the demo/common directory. */	vStartLEDFlashTasks( mainLED_FLASH_PRIORITY );	/* Start the check task defined in this file. */	xTaskCreate( vErrorChecks, "Check", portMINIMAL_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 );	/* Start the scheduler.  Will never return here. */	vTaskStartScheduler();	while(1)	/* This point should never be reached. */	{	}}

/*-----------------------------------------------------------*/short main( void ){	/* Initialise hardware and utilities. */	vParTestInitialise();	vPrintInitialise();	prvInitLED();	/* CREATE ALL THE DEMO APPLICATION TASKS. */	vStartComTestTasks( mainCOM_TEST_PRIORITY, serCOM2, ser38400 );	vStartIntegerMathTasks( tskIDLE_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartBlockingQueueTasks( mainQUEUE_BLOCK_PRIORITY );	vStartLEDFlashTasks( mainLED_TASK_PRIORITY );	vStartSemaphoreTasks( mainSEMAPHORE_TASK_PRIORITY );	/* Create the "Print" task as described at the top of the file. */	xTaskCreate( vErrorChecks, "Print", mainPRINT_STACK_SIZE, NULL, mainPRINT_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 );	/* Set the scheduler running.  This function will not return unless a task	calls vTaskEndScheduler(). */	vTaskStartScheduler();	return 1;}

int main_full( void ){	/* Start the check task as described at the top of this file. */	xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* Create the standard demo tasks. */	vStartTaskNotifyTask();	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );	vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );	vStartQueuePeekTasks();	vStartMathTasks( mainFLOP_TASK_PRIORITY );	vStartRecursiveMutexTasks();	vStartCountingSemaphoreTasks();	vStartDynamicPriorityTasks();	vStartQueueSetTasks();	vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_PRIORITY );	vStartEventGroupTasks();	vStartInterruptSemaphoreTasks();	vStartQueueSetPollingTask();	vCreateBlockTimeTasks();	vCreateAbortDelayTasks();	xTaskCreate( prvDemoQueueSpaceFunctions, "QSpace", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );	xTaskCreate( prvPermanentlyBlockingSemaphoreTask, "BlockSem", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );	xTaskCreate( prvPermanentlyBlockingNotificationTask, "BlockNoti", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );	#if( configSUPPORT_STATIC_ALLOCATION == 1 )	{		vStartStaticallyAllocatedTasks();	}	#endif	#if( configUSE_PREEMPTION != 0  )	{		/* Don't expect these tasks to pass when preemption is not used. */		vStartTimerDemoTask( mainTIMER_TEST_PERIOD );	}	#endif	/* The suicide tasks must be created last as they need to know how many	tasks were running prior to their creation.  This then allows them to	ascertain whether or not the correct/expected number of tasks are running at	any given time. */	vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );	/* Create the semaphore that will be deleted in the idle task hook.  This	is done purely to test the use of vSemaphoreDelete(). */	xMutexToDelete = xSemaphoreCreateMutex();	/* Start the scheduler itself. */	vTaskStartScheduler();	/* Should never get here unless there was not enough heap space to create	the idle and other system tasks. */	return 0;}

void main_full( void ){TimerHandle_t xCheckTimer = NULL;	/* Prepare to run the full demo: Configure the IO, register the CLI	commands, and depending on configuration, generate a set of sample files on	a RAM disk. */	prvPrepareForFullDemo();	/* 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 );	/* 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 );	/* 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 );	}	/* 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( ;; );}

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 );	vStartMathTasks( mainFLOP_TASK_PRIORITY );		/* Create the register check tasks, as described at the top of this	file */	xTaskCreate( vRegTest1Task, ( signed char * ) "Reg1", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL );	xTaskCreate( vRegTest2Task, ( signed char * ) "Reg2", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL );	/* 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( ;; )	{		__asm volatile( "NOP" );	}}

/************************************************************************* * Please ensure to read http://www.freertos.org/portlm3sx965.html * which provides information on configuring and running this demo for the * various Luminary Micro EKs. *************************************************************************/int main( void ){	prvSetupHardware();	/* Create the queue used by the OLED task.  Messages for display on the OLED	are received via this queue. */	xOLEDQueue = xQueueCreate( mainOLED_QUEUE_SIZE, sizeof( xOLEDMessage ) );	/* Start the standard demo tasks. */    vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );    vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );    vStartInterruptQueueTasks();	vStartRecursiveMutexTasks();	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vCreateBlockTimeTasks();	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartQueuePeekTasks();	vStartQueueSetTasks();	vStartEventGroupTasks();	/* Exclude some tasks if using the kickstart version to ensure we stay within	the 32K code size limit. */	#if mainINCLUDE_WEB_SERVER != 0	{		/* Create the uIP task if running on a processor that includes a MAC and		PHY. */		if( SysCtlPeripheralPresent( SYSCTL_PERIPH_ETH ) )		{			xTaskCreate( vuIP_Task, "uIP", mainBASIC_WEB_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY - 1, NULL );		}	}	#endif	/* Start the tasks defined within this file/specific to this demo. */	xTaskCreate( vOLEDTask, "OLED", mainOLED_TASK_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 high frequency interrupt used to measure the interrupt	jitter time. */	vSetupHighFrequencyTimer();	/* Start the scheduler. */	vTaskStartScheduler();    /* Will only get here if there was insufficient memory to create the idle    task. */	return 0;}

static void prvOptionallyCreateComprehensveTestApplication( void ){	#if ( mainCREATE_SIMPLE_LED_FLASHER_DEMO_ONLY == 0 )	{	xTimerHandle xCheckTimer = NULL;		/* 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, ( signed char * ) "Reg1", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL );		xTaskCreate( vRegTest2Task, ( signed char * ) "Reg2", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL );		/* 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 );		}		/* 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){extern void HardwareSetup( void );	/* Renesas provided CPU configuration routine.  The clocks are configured in	here. */	HardwareSetup();	/* Turn all LEDs off. */	vParTestInitialise();	/* Start the reg test tasks which test the context switching mechanism. */	xTaskCreate( prvRegTest1Task, "RegTst1", configMINIMAL_STACK_SIZE, ( void * ) mainREG_TEST_1_PARAMETER, tskIDLE_PRIORITY, NULL );	xTaskCreate( prvRegTest2Task, "RegTst2", configMINIMAL_STACK_SIZE, ( void * ) mainREG_TEST_2_PARAMETER, tskIDLE_PRIORITY, NULL );	/* The web server task. */	xTaskCreate( vuIP_Task, "uIP", mainuIP_STACK_SIZE, NULL, mainuIP_TASK_PRIORITY, NULL );	/* Start the check task as described at the top of this file. */	xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* Create the standard demo tasks. */	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vCreateBlockTimeTasks();	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );	vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );	vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );	vStartQueuePeekTasks();	vStartRecursiveMutexTasks();	vStartInterruptQueueTasks();	vStartMathTasks( mainFLOP_TASK_PRIORITY );	/* 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 running. */	vTaskStartScheduler();	/* If all is well we will never reach here as the scheduler will now be	running.  If we do reach here then it is likely that there was insufficient	heap available for the idle task to be created. */	for( ;; );		return 0;}

void main_full( void ){	/* Start all the other standard demo/test tasks.  They have no particular	functionality, but do demonstrate how to use the FreeRTOS API and test the	kernel port. */	vStartInterruptQueueTasks();	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 );	vStartEventGroupTasks();	vStartInterruptSemaphoreTasks();	vStartQueueSetTasks();	vStartTaskNotifyTask();	/* Create the register check tasks, as described at the top of this	file */	xTaskCreate( prvRegTestTaskEntry1, "Reg1", configMINIMAL_STACK_SIZE, mainREG_TEST_TASK_1_PARAMETER, tskIDLE_PRIORITY, NULL );	xTaskCreate( prvRegTestTaskEntry2, "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, "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( ;; );}

/* 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 majority of the demo application tasks before starting the * scheduler. */void main(void){    TaskHandle_t xCreatedTask;    prvSetupHardware();    /* Start the reg test tasks which test the context switching mechanism. */    xTaskCreate( vRegTest1Task, "RegTst1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, &xCreatedTask );    xPortUsesFloatingPoint( xCreatedTask );    xTaskCreate( vRegTest2Task, "RegTst2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, &xCreatedTask );    xPortUsesFloatingPoint( xCreatedTask );    xTaskCreate( vuIP_Task, "uIP", mainuIP_STACK_SIZE, NULL, mainuIP_TASK_PRIORITY, NULL );    /* Start the check task as described at the top of this file. */    xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );    /* Start the standard demo tasks.  These don't perform any particular useful    functionality, other than to demonstrate the FreeRTOS API being used. */    vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );    vCreateBlockTimeTasks();    vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );    vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );    vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );    vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );    vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );    vStartQueuePeekTasks();    vStartRecursiveMutexTasks();    /* Start the math tasks as described at the top of this file. */    vStartMathTasks( mainFLOP_TASK_PRIORITY );    /* 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 running. */    vTaskStartScheduler();    /* Will only get here if there was insufficient heap memory to create the idle    task.  Increase the configTOTAL_HEAP_SIZE setting in FreeRTOSConfig.h. */    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( ;; );}

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( ;; );}

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( ;; );}

void main( void ){	/* Configure the NVIC, LED outputs and button inputs. */	prvSetupHardware();	/* Create the timers that are specific to this demo - other timers are	created as part of the standard demo within vStartTimerDemoTask. */	prvCreateDemoSpecificTimers();	/* Create a lot of 'standard demo' tasks.  Nearly 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 );	vStartQueuePeekTasks();	vStartRecursiveMutexTasks();	vStartTimerDemoTask( mainTIMER_TEST_PERIOD );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartCountingSemaphoreTasks();	vStartDynamicPriorityTasks();	/* The web server task. */	xTaskCreate( vuIP_Task, "uIP", mainuIP_STACK_SIZE, NULL, mainuIP_TASK_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 );	/* Start the tasks and timers 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( ;; );}

void main_full( void ){	/* Start the reg test tasks which test the context switching mechanism. */	xTaskCreate( prvRegTest1Task, "RegTst1", configMINIMAL_STACK_SIZE, ( void * ) mainREG_TEST_1_PARAMETER, tskIDLE_PRIORITY, NULL );	xTaskCreate( prvRegTest2Task, "RegTst2", configMINIMAL_STACK_SIZE, ( void * ) mainREG_TEST_2_PARAMETER, tskIDLE_PRIORITY, NULL );	/* Create the standard demo tasks. */	vCreateBlockTimeTasks();	vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );	vStartRecursiveMutexTasks();	/* 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 );	/* 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 5000ms (5s). */								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. */							  );	configASSERT( xCheckTimer );	/* Start the check timer.  It will actually start when the scheduler is	started. */	xTimerStart( xCheckTimer, mainDONT_BLOCK );	/* Start the tasks running. */	vTaskStartScheduler();	/* If all is well execution will never reach here as the scheduler will be	running.  If this null loop is reached then it is likely there was	insufficient FreeRTOS heap available for the idle task and/or timer task to	be created.  See http://www.freertos.org/a00111.html. */	for( ;; );}

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 */}

int main_full( void ){	/* Start the check task as described at the top of this file. */	xTaskCreate( prvCheckTask, ( signed char * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* Create the standard demo tasks. */	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );	vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );	vStartQueuePeekTasks();	vStartMathTasks( mainFLOP_TASK_PRIORITY );	vStartRecursiveMutexTasks();	vStartTimerDemoTask( mainTIMER_TEST_PERIOD );	vStartCountingSemaphoreTasks();	vStartDynamicPriorityTasks();	vStartQueueSetTasks();	vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_PRIORITY );		xTaskCreate( prvDemoQueueSpaceFunctions, ( signed char * ) "QSpace", 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.  This then allows them to 	ascertain whether or not the correct/expected number of tasks are running at 	any given time. */	vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );	/* Create the semaphore that will be deleted in the idle task hook.  This	is done purely to test the use of vSemaphoreDelete(). */	xMutexToDelete = xSemaphoreCreateMutex();	/* Start the scheduler itself. */	vTaskStartScheduler();    /* Should never get here unless there was not enough heap space to create 	the idle and other system tasks. */    return 0;}

/*  * 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( ;; );}

int main (void){	/* Setup the led's on the MCB2300 board */	vParTestInitialise();	/* Create the queue used by the LCD task.  Messages for display on the LCD	are received via this queue. */	xLCDQueue = xQueueCreate( mainQUEUE_SIZE, sizeof( xLCDMessage ) );	/* Create the lwIP task.  This uses the lwIP RTOS abstraction layer.*/    xTaskCreate( vuIP_Task, "uIP", mainBASIC_WEB_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY - 1, NULL );	/* Start the standard demo tasks - these serve no useful purpose other than	to demonstrate the FreeRTOS API being used and to test the port. */	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );    vCreateBlockTimeTasks();    vStartLEDFlashTasks( mainFLASH_PRIORITY );    vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );    vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );    vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );	/* Start the tasks defined within this file/specific to this demo. */    xTaskCreate( vCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	xTaskCreate( vLCDTask, "LCD", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY - 1, 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 );	/* Start the scheduler. */	vTaskStartScheduler();    /* Will only get here if there was insufficient memory to create the idle    task. */	return 0;}

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( ;; );}

/*-----------------------------------------------------------*/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( ;; );}

/*! * /brief The task function for the "Check" task. */static void vErrorChecks( void *pvParameters ){static volatile unsigned portLONG ulDummyVariable = 3UL;unsigned portLONG ulMemCheckTaskRunningCount;xTaskHandle xCreatedTask;portBASE_TYPE bSuicidalTask = 0;	/* The parameters are not used.  Prevent compiler warnings. */	( void ) pvParameters;	/* Cycle for ever, delaying then checking all the other tasks are still	operating without error.	In addition to the standard tests the memory allocator is tested through	the dynamic creation and deletion of a task each cycle.  Each time the	task is created memory must be allocated for its stack.  When the task is	deleted this memory is returned to the heap.  If the task cannot be created	then it is likely that the memory allocation failed. */	for( ;; )	{		/* Do this only once. */		if( bSuicidalTask == 0 )		{			bSuicidalTask++;			/* This task has to be created last as it keeps account of the number of			tasks it expects to see running. However its implementation expects			to be called before vTaskStartScheduler(). We're in the case here where			vTaskStartScheduler() has already been called (thus the hidden IDLE task			has already been spawned). Since vCreateSuicidalTask() supposes that the			IDLE task isn't included in the response from uxTaskGetNumberOfTasks(),			let the MEM_CHECK task play that role. => this is why vCreateSuicidalTasks()			is not called as the last task. */			vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );		}		/* Reset xCreatedTask.  This is modified by the task about to be		created so we can tell if it is executing correctly or not. */		xCreatedTask = mainNO_TASK;		/* Dynamically create a task - passing ulMemCheckTaskRunningCount as a		parameter. */		ulMemCheckTaskRunningCount = mainCOUNT_INITIAL_VALUE;		if( xTaskCreate( vMemCheckTask,			( signed portCHAR * ) "MEM_CHECK",			configMINIMAL_STACK_SIZE,			( void * ) &ulMemCheckTaskRunningCount,			tskIDLE_PRIORITY, &xCreatedTask ) != pdPASS )		{			/* Could not create the task - we have probably run out of heap.			Don't go any further and flash the LED faster to provide visual			feedback of the error. */			prvIndicateError();		}		/* Delay until it is time to execute again. */		vTaskDelay( mainCHECK_PERIOD );		/* Delete the dynamically created task. */		if( xCreatedTask != mainNO_TASK )		{			vTaskDelete( xCreatedTask );		}		/* Perform a bit of 32bit maths to ensure the registers used by the		integer tasks get some exercise. The result here is not important -		see the demo application documentation for more info. */		ulDummyVariable *= 3;		/* Check all other tasks are still operating without error.		Check that vMemCheckTask did increment the counter. */		if( ( prvCheckOtherTasksAreStillRunning() != pdFALSE )		 || ( ulMemCheckTaskRunningCount == mainCOUNT_INITIAL_VALUE ) )		{			/* An error has occurred in one of the tasks.			Don't go any further and flash the LED faster to give visual			feedback of the error. */			prvIndicateError();		}		else		{			/* Toggle the LED if everything is okay. */			vParTestToggleLED( mainCHECK_TASK_LED );		}	}}

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( ;; );}

/*--------------------------------------------------------------------------- * 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 " );	/*  //  */	}}

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 three application specific demo tasks, as described in the		comments at the top of this	file. */		xTaskCreate( prvQueueReceiveTask, "Rx", configMINIMAL_STACK_SIZE, NULL, mainQUEUE_RECEIVE_TASK_PRIORITY, NULL );		xTaskCreate( prvQueueSendTask, "TX", configMINIMAL_STACK_SIZE, NULL, mainQUEUE_SEND_TASK_PRIORITY, NULL );		xTaskCreate( prvOLEDTask, "OLED", configMINIMAL_STACK_SIZE, NULL, mainOLED_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( 	"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( "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 a lot of 'standard demo' tasks. */		vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );		vCreateBlockTimeTasks();		vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );		vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );		vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );		vStartQueuePeekTasks();		vStartRecursiveMutexTasks();		vStartTimerDemoTask( mainTIMER_TEST_PERIOD );		/* Create the web server task. */		xTaskCreate( vuIP_Task, "uIP", mainuIP_STACK_SIZE, NULL, mainuIP_TASK_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 );		/* 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( ;; );}