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

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();	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 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 on the FreeRTOS heap	http://www.freertos.org/a00111.html. */	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. */	vStartDynamicPriorityTasks();	vCreateBlockTimeTasks();	vStartCountingSemaphoreTasks();	vStartGenericQueueTasks( tskIDLE_PRIORITY );	vStartRecursiveMutexTasks();	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartMathTasks( mainFLOP_TASK_PRIORITY );	/* Create the register check tasks, as described at the top of this	file */	xTaskCreate( vRegTest1Task, "Reg1", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL );	xTaskCreate( vRegTest2Task, "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( "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 );	}	/* 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 ){	/* Start all the standard demo/test tasks.  They have no particular	functionality, but do demonstrate how to use the FreeRTOS API and test the	kernel port. */	vStartDynamicPriorityTasks();	vCreateBlockTimeTasks();	vStartCountingSemaphoreTasks();	vStartGenericQueueTasks( tskIDLE_PRIORITY );	vStartRecursiveMutexTasks();	vStartEventGroupTasks();	vStartTaskNotifyTask();	/* Create the register check tasks, as described at the top of this	file */	xTaskCreate( prvRegTestTaskEntry1, 			/* Task entry point. */				 "Reg1", 						/* Text name for the task - not used by the kernel. */				 configMINIMAL_STACK_SIZE, 		/* Stack to allocate to the task - in words not bytes! */				 mainREG_TEST_TASK_1_PARAMETER, /* The parameter passed into the task. */				 tskIDLE_PRIORITY, 				/* The task's priority. */				 NULL );						/* Task handle is not needed, so NULL is passed. */	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 );	/* Register an example set of CLI commands, then start the task that manages	the CLI using a UART for input and output. */	vRegisterSampleCLICommands();	vUARTCommandConsoleStart( mainCOMMAND_CONSOLE_STACK_SIZE, mainCOMMAND_CONSOLE_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.  See the memory management section on the	FreeRTOS web site for more details on the FreeRTOS heap	http://www.freertos.org/a00111.html. */	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( 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( ;; );}

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

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

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

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

void main_full( void ){xTimerHandle xTimer = NULL;/* The register test tasks are asm functions that don't use a stack.  Thestack allocated just has to be large enough to hold the task context, andfor the additional required for the stack overflow checking to work (ifconfigured). */const size_t xRegTestStackSize = 25U;	/* Create the standard demo tasks */	vCreateBlockTimeTasks();	vStartDynamicPriorityTasks();	vStartCountingSemaphoreTasks();	vStartRecursiveMutexTasks();	vStartQueueOverwriteTask( tskIDLE_PRIORITY );	vStartQueueSetTasks();	vStartGenericQueueTasks( tskIDLE_PRIORITY );	vStartQueuePeekTasks();		/* Start the task that manages the command console for FreeRTOS+CLI. */	vUARTCommandConsoleStart( ( configMINIMAL_STACK_SIZE * 3 ), tskIDLE_PRIORITY );		/* Create the register test tasks as described at the top of this file.	These are naked functions that don't use any stack.  A stack still has	to be allocated to hold the task context. */	xTaskCreate( 	vRegTest1Task,			/* Function that implements the task. */					( signed char * ) "Reg1", /* Text name of the task. */					xRegTestStackSize,		/* Stack allocated to the task. */					NULL, 					/* The task parameter is not used. */					tskIDLE_PRIORITY, 		/* The priority to assign to the task. */					NULL );					/* Don't receive a handle back, it is not needed. */	xTaskCreate( 	vRegTest2Task,			/* Function that implements the task. */					( signed char * ) "Reg2", /* Text name of the task. */					xRegTestStackSize,		/* Stack allocated to the task. */					NULL, 					/* The task parameter is not used. */					tskIDLE_PRIORITY, 		/* The priority to assign to the task. */					NULL );					/* Don't receive a handle back, it is not needed. */	/* Create the software timer that performs the 'check' functionality,	as described at the top of this file. */	xTimer = 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 the software timer was created successfully, start it.  It won't	actually start running until the scheduler starts.  A block time of	zero is used in this call, although any value could be used as the block	time will be ignored because the scheduler has not started yet. */	configASSERT( xTimer );	if( xTimer != NULL )	{		xTimerStart( xTimer, mainDONT_BLOCK );	}	/* Start the kernel.  From here on, only tasks and interrupts will run. */	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, or the FreeRTOS tutorial books for more details. */	for( ;; );}

static void prvOptionallyCreateComprehensveTestApplication( void ){	#if ( mainCREATE_SIMPLE_LED_FLASHER_DEMO_ONLY == 0 )	{	TimerHandle_t 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, ( void * ) NULL, tskIDLE_PRIORITY, NULL );		xTaskCreate( vRegTest2Task, "Reg2", configMINIMAL_STACK_SIZE, ( void * ) 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, ( void * ) 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 */}

void main_full( void ){xTimerHandle 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, ( const signed char * ) "Reg1...", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );	xTaskCreate( vRegTestTask2, ( const signed char * ) "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( ( 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( 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( ( const signed char * ) "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( ;; );	}

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, "Rx", configMINIMAL_STACK_SIZE, NULL, mainQUEUE_RECEIVE_TASK_PRIORITY, NULL );		xTaskCreate( prvQueueSendTask, "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( 	"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 the software timer that performs the 'digit counting'		functionality, as described at the top of this file. */		xDigitCounterTimer = xTimerCreate( "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_full( void ){	/* Usage instructions on http://www.FreeRTOS.org/Atmel_SAM4E_RTOS_Demo.html */	/* Initialise the LCD and output a bitmap.  The IP address will also be	displayed on the LCD when it has been obtained. */	vInitialiseLCD();	/* If the file system is only going to be accessed from one task then	F_FS_THREAD_AWARE can be set to 0 and the set of example files are created	before the RTOS scheduler is started.  If the file system is going to be	access from more than one task then F_FS_THREAD_AWARE must be set to 1 and	the	set of sample files are created from the idle task hook function	vApplicationIdleHook(). */	#if( F_FS_THREAD_AWARE == 0 )	{		/* Initialise the drive and file system, then create a few example		files.  The files can be viewed and accessed via the CLI.  View the		documentation page for this demo (link at the top of this file) for more		information. */		vCreateAndVerifySampleFiles();	}	#endif	/* Register example generic, file system related and UDP related CLI	commands respectively.  Type 'help' into the command console to view a list	of registered commands. */	vRegisterSampleCLICommands();	vRegisterFileSystemCLICommands();	vRegisterUDPCLICommands();	/* Initialise the network interface.  Tasks that use the network are	created in the network event hook when the network is connected and ready	for use.  The address values passed in here are used if ipconfigUSE_DHCP is	set to 0, or if ipconfigUSE_DHCP is set to 1 but a DHCP server cannot be	contacted.  The IP address actually used is displayed on the LCD (after DHCP	has completed if DHCP is used). */	FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );	/* Create all the other standard demo tasks. */		vCreateBlockTimeTasks();	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );	vStartQueuePeekTasks();	vStartCountingSemaphoreTasks();	vStartDynamicPriorityTasks();	vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_TASK_PRIORITY );	vStartQueueSetTasks();	vStartRecursiveMutexTasks();	vStartEventGroupTasks();	vStartTaskNotifyTask();	vStartInterruptSemaphoreTasks();	vStartTimerDemoTask( mainTIMER_TEST_PERIOD );	vStartInterruptQueueTasks();	/* Create the register check tasks, as described at the top of this	file */	xTaskCreate( prvRegTest1Task, "Reg1", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL );	xTaskCreate( prvRegTest2Task, "Reg2", configMINIMAL_STACK_SIZE, ( void * ) NULL, tskIDLE_PRIORITY, NULL );	/* Start the scheduler itself. */	vTaskStartScheduler();	/* If all is well, the scheduler will now be running, and the following line	will never be reached.  If the following line does execute, then there was	insufficient FreeRTOS heap memory available for the idle and/or timer tasks	to be created.  See the memory management section on the FreeRTOS web site	for more details. */	for( ;; );}

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_full( void ){TimerHandle_t xTimer = NULL;	/* Usage instructions on http://www.FreeRTOS.org/Atmel_SAM4E_RTOS_Demo.html */	/* Initialise the LCD and output a bitmap.  The IP address will also be	displayed on the LCD when it has been obtained. */	vInitialiseLCD();	/* If the file system is only going to be accessed from one task then	F_FS_THREAD_AWARE can be set to 0 and the set of example files are created	before the RTOS scheduler is started.  If the file system is going to be	access from more than one task then F_FS_THREAD_AWARE must be set to 1 and	the	set of sample files are created from the idle task hook function	vApplicationIdleHook(). */	#if( F_FS_THREAD_AWARE == 0 )	{		/* Initialise the drive and file system, then create a few example		files.  The files can be viewed and accessed via the CLI.  View the		documentation page for this demo (link at the top of this file) for more		information. */		vCreateAndVerifySampleFiles();	}	#endif	/* Register example generic, file system related and UDP related CLI	commands respectively.  Type 'help' into the command console to view a list	of registered commands. */	vRegisterSampleCLICommands();	vRegisterFileSystemCLICommands();	vRegisterUDPCLICommands();	/* Initialise the network interface.  Tasks that use the network are	created in the network event hook when the network is connected and ready	for use.  The address values passed in here are used if ipconfigUSE_DHCP is	set to 0, or if ipconfigUSE_DHCP is set to 1 but a DHCP server cannot be	contacted.  The IP address actually used is displayed on the LCD (after DHCP	has completed if DHCP is used). */	FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );	/* Create all the other standard demo tasks. */	vStartLEDFlashTimers( mainNUM_FLASH_TIMER_LEDS );	vCreateBlockTimeTasks();	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );	vStartQueuePeekTasks();	vStartCountingSemaphoreTasks();	vStartDynamicPriorityTasks();	vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_TASK_PRIORITY );	vStartQueueSetTasks();	vStartRecursiveMutexTasks();	vStartEventGroupTasks();	/* Create the software timer that performs the 'check' functionality, as	described at the top of this file. */	xTimer = xTimerCreate( 	"CheckTimer",					/* A text name, purely to help debugging. */							( mainCHECK_TIMER_PERIOD_MS ),	/* The timer period, in this case 3000ms (3s). */							pdTRUE,							/* This is an auto-reload timer, so xAutoReload is set to pdTRUE. */							( void * ) 0,					/* The ID is not used, so can be set to anything. */							prvCheckTimerCallback );		/* The callback function that inspects the status of all the other tasks. */	if( xTimer != NULL )	{		xTimerStart( xTimer, mainDONT_BLOCK );	}	/* Start the scheduler itself. */	vTaskStartScheduler();	/* If all is well, the scheduler will now be running, and the following line	will never be reached.  If the following line does execute, then there was	insufficient FreeRTOS heap memory available for the idle and/or timer tasks	to be created.  See the memory management section on the FreeRTOS web site	for more details. */	for( ;; );}

/* * Create the demo tasks then start the scheduler. */int main_full( void ){TimerHandle_t xTimer = NULL;	/* Create all the other standard demo tasks. */	vStartLEDFlashTimers( mainNUM_FLASH_TIMER_LEDS );	vCreateBlockTimeTasks();	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );	vStartQueuePeekTasks();	vStartInterruptQueueTasks();	vStartISRTriggeredTask();	vStartCountingSemaphoreTasks();	vStartDynamicPriorityTasks();	vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_TASK_PRIORITY );	vStartQueueSetTasks();	vStartRecursiveMutexTasks();	vStartEventGroupTasks();	vStartMathTasks( mainFLOP_TASK_PRIORITY );	/* Create the tasks defined within this file. */	xTaskCreate( prvRegTestTask1,			/* The function that implements the task. */				"Reg1",						/* Text name for the task to assist debugger - not used by FreeRTOS itself. */				configMINIMAL_STACK_SIZE,	/* The stack size to allocate for the task - specified in words not bytes. */				NULL,						/* The parameter to pass into the task - not used in this case so set to NULL. */				tskIDLE_PRIORITY,			/* The priority to assign to the task. */				NULL );						/* Used to obtain a handle to the task being created - not used in this case so set to NULL. */	xTaskCreate( prvRegTestTask2, "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 );	}	/* 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.  http://www.freertos.org/a00111.html */	for( ;; );}