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

/* * Starts all the other tasks, then starts the scheduler.  */int main( void ){	/* Configure the processor. */	prvSetupHardware();	/* Start the task that handles the TCP/IP 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 );	/* Start the check task - which is defined in this file. */	    xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* Now all the tasks have been started - start the scheduler.	NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode.	The processor MUST be in supervisor mode when vTaskStartScheduler is 	called.  The demo applications included in the FreeRTOS.org download switch	to supervisor mode prior to main being called.  If you are not using one of	these demo application projects then ensure Supervisor mode is used here. */	vTaskStartScheduler();	/* Should never reach here! */	return 0;}

/* * Create the demo tasks then start the scheduler. */int main_full( void ){xTimerHandle 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();	/* 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( ;; );}

/* * Starts all the other tasks, then starts the scheduler.  */int main( void ){	/* Setup the hardware for use with the Olimex demo board. */	prvSetupHardware();	/* Start the demo/test application tasks. */	vStartIntegerMathTasks( tskIDLE_PRIORITY );	vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );	vStartLEDFlashTasks( mainLED_TASK_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartMathTasks( tskIDLE_PRIORITY );	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartDynamicPriorityTasks();		vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	/* Start the check task - which is defined in this file. */	xTaskCreate( vErrorChecks, ( signed char * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* Now all the tasks have been started - start the scheduler.	NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode.	The processor MUST be in supervisor mode when vTaskStartScheduler is 	called.  The demo applications included in the FreeRTOS.org download switch	to supervisor mode prior to main being called.  If you are not using one of	these demo application projects then ensure Supervisor mode is used here. */	vTaskStartScheduler();	/* Should never reach here! */	return 0;}

void main(void){	prvSetupHardware();    /* Start the HTTP server task. */	xTaskCreate( vHTTPTask, "WizNet", configMINIMAL_STACK_SIZE, NULL, mainHTTP_TASK_PRIORITY, NULL );	/* Start the demo/test application tasks.  See the demo application 	section of the FreeRTOS.org WEB site for more information. */	vStartIntegerMathTasks( tskIDLE_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );  	vStartDynamicPriorityTasks();	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );    vStartComTestTasks( mainCOM_TEST_PRIORITY, serCOM2, ser57600 );	/* Start the task that checks the other demo tasks for errors. */    xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* The suicide tasks must be created last as they monitor the number of	tasks in the system to ensure there are no more or fewer than expected	compared to the number that were executing when the task started. */   	vCreateSuicidalTasks( mainSUICIDE_TASKS_PRIORITY );        	/* Finally start the scheduler. */    vTaskStartScheduler();	/* Should not get here! */	for( ;; );}

int main( void ){	prvSetupHardware();	/* 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 uIP 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. */	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );    vCreateBlockTimeTasks();    vStartLEDFlashTasks( mainFLASH_PRIORITY );    vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );    vStartQueuePeekTasks();    vStartDynamicPriorityTasks();	/* Start the tasks defined within this file/specific to this demo. */	xTaskCreate( vLCDTask, "LCD", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY - 1, NULL );	/* Start the scheduler. */	vTaskStartScheduler();    /* Will only get here if there was insufficient memory to create the idle    task. */	return 0;}

/* * Starts all the other tasks, then starts the scheduler. */int main( void ){	/* Setup the hardware for use with the Xilinx evaluation board. */	prvSetupHardware();	/* Start the demo/test application tasks. */	vStartIntegerMathTasks( tskIDLE_PRIORITY );	vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );	vStartLEDFlashTasks( mainLED_TASK_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartDynamicPriorityTasks();	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vStart7SegTasks( main7SEG_TASK_PRIORITY );	vStartRegTestTasks();	/* Start the check task - which is defined in this file. */	xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* Now all the tasks have been started - start the scheduler. */	vTaskStartScheduler();	/* Should never reach here! */	for( ;; );}

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

/* * Application entry point: * Starts all the other tasks, then starts the scheduler. */int main( void ){    /* Setup the hardware for use with the Keil demo board. */    prvSetupHardware();    /* Start the demo/test application tasks. */    vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );    vStartLEDFlashTasks( mainLED_TASK_PRIORITY );    vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );    vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );    vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );    vStartDynamicPriorityTasks();    /* Start the check task - which is defined in this file.  This is the task    that periodically checks to see that all the other tasks are executing    without error. */    xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );    /* Now all the tasks have been started - start the scheduler.    NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode.    The processor MUST be in supervisor mode when vTaskStartScheduler is    called.  The demo applications included in the FreeRTOS.org download switch    to supervisor mode prior to main being called.  If you are not using one of    these demo application projects then ensure Supervisor mode is used here. */    vTaskStartScheduler();    /* Should never reach here!  If you do then there was not enough heap    available for the idle task to be created. */    for( ;; );}

/* * Starts all the other tasks, then starts the scheduler. */int main( void ){	/* Setup any hardware that has not already been configured by the low	level init routines. */	prvSetupHardware();	/* Start the task that handles the TCP/IP and WEB server functionality. */    xTaskCreate( vuIP_Task, "uIP", mainUIP_TASK_STACK_SIZE, NULL, mainUIP_PRIORITY, NULL );		/* Also start the USB demo which is just for the SAM7. */    vStartUSBTask( mainUSB_PRIORITY );		/* Start the standard demo tasks. */	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );    vCreateBlockTimeTasks();    vStartLEDFlashTasks( mainFLASH_PRIORITY );    vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );    vStartQueuePeekTasks();       vStartDynamicPriorityTasks();	/* Start the scheduler.	NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode.	The processor MUST be in supervisor mode when vTaskStartScheduler is	called.  The demo applications included in the FreeRTOS.org download switch	to supervisor mode prior to main being called.  If you are not using one of	these demo application projects then ensure Supervisor mode is used here. */	vTaskStartScheduler();	/* We should never get here as control is now taken by the scheduler. */  	return 0;}

/* Create all the demo application tasks, then start the scheduler. */int main( void ){	/* Perform any hardware setup necessary. */  	prvSetupHardware();	vParTestInitialise();	/* Create the queue used to communicate with the LCD print task. */	xLCDQueue = xQueueCreate( mainLCD_QUEUE_LENGTH, sizeof( LCDMessage ) );		  	/* Create the standard demo application tasks.  See the WEB documentation	for more information on these tasks. */	vCreateBlockTimeTasks();	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );	vStartDynamicPriorityTasks();	vStartLEDFlashTasks( mainLED_TASK_PRIORITY );	vStartIntegerMathTasks( tskIDLE_PRIORITY );		/* Create the tasks defined within this file. */	xTaskCreate( vPrintTask, ( signed char * ) "LCD", configMINIMAL_STACK_SIZE, NULL, mainLCD_TASK_PRIORITY, NULL );	xTaskCreate( vCheckTask, ( signed char * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );		vTaskStartScheduler();		/* Execution will only reach here if there was insufficient heap to	start the scheduler. */	return 0;}

/* * Starts all the other tasks, then starts the scheduler. */void main( void ){	/* Setup any hardware that has not already been configured by the low	level init routines. */	prvSetupHardware();	/* Initialise the LED outputs for use by the demo application tasks. */	vParTestInitialise();	/* Start all the standard demo application tasks. */	vStartIntegerMathTasks( tskIDLE_PRIORITY );	vStartLEDFlashTasks( mainLED_TASK_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vStartDynamicPriorityTasks();	vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );	/* Start the check task - which is defined in this file. */	xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* Start the scheduler.	NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode.	The processor MUST be in supervisor mode when vTaskStartScheduler is	called.  The demo applications included in the FreeRTOS.org download switch	to supervisor mode prior to main being called.  If you are not using one of	these demo application projects then ensure Supervisor mode is used here. */	vTaskStartScheduler();	/* We should never get here as control is now taken by the scheduler. */	return;}

/* * Application entry point: * Starts all the other tasks, then starts the scheduler.  */int main( void ){	/* Setup the hardware for use with the Olimex demo board. */	prvSetupHardware();	/* Start the standard flash tasks so the WEB server is not the only thing 	running. */	vStartLEDFlashTasks( mainLED_TASK_PRIORITY );	vStartSemaphoreTasks( tskIDLE_PRIORITY );	vStartDynamicPriorityTasks();	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vStartIntegerMathTasks( tskIDLE_PRIORITY );	/* Start the WEB server task and the error check task. */	xTaskCreate( vHTTPServerTask, ( signed char * ) "HTTP", configMINIMAL_STACK_SIZE, NULL, mainHTTP_TASK_PRIORITY, NULL );	xTaskCreate( prvErrorChecks, ( signed char * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainERROR_CHECK_PRIORITY, NULL );		/* Now all the tasks have been started - start the scheduler.	NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode.	The processor MUST be in supervisor mode when vTaskStartScheduler is 	called.  The demo applications included in the FreeRTOS.org download switch	to supervisor mode prior to main being called.  If you are not using one of	these demo application projects then ensure Supervisor mode is used. */	vTaskStartScheduler();	/* Should never reach here! */	return 0;}

/* ------------------------ Implementation -------------------------------- */intmain( int argc, char *argv[] ){    asm volatile    ( "move.w  #0x2000, %sr/n/t" );    xSTDComPort = xSerialPortInitMinimal( 38400, 8 );    /* Start the demo/test application tasks. */    vStartIntegerMathTasks( tskIDLE_PRIORITY );    vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );    vStartMathTasks( tskIDLE_PRIORITY );    vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );    vStartDynamicPriorityTasks(  );    vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );    /* Start the check task - which is defined in this file. */    xTaskCreate( vErrorChecks, "Check", 512, NULL,                 mainCHECK_TASK_PRIORITY, NULL );    /* Now all the tasks have been started - start the scheduler. */    vTaskStartScheduler(  );    /* Should never get here! */    return 0;}

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 ){	/* Creates all the tasks and timers, then starts the scheduler. */	/* First create the 'standard demo' tasks.  These are used to demonstrate	API functions being used and also to test the kernel port.  More information	is provided on the FreeRTOS.org WEB site. */	vStartDynamicPriorityTasks();	vStartPolledQueueTasks( tskIDLE_PRIORITY );	/* Additional tasks can be added by un-commenting the line below on devices	with sufficient RAM for a larger heap (see configTOTAL_HEAP_SIZE in	FreeRTOSConfig.h). */	/*vCreateBlockTimeTasks();*/	/* Create the RegTest tasks as described at the top of this file. */	xTaskCreate( prvRegTest1Entry,			/* The function that implements the task. */				 "Reg1",					/* Text name for the task - to assist debugging only, not used by the kernel. */				 configMINIMAL_STACK_SIZE, 	/* The size of the stack allocated to the task (in words, not bytes). */				 mainREG_TEST_1_PARAMETER,  /* The parameter passed into the task. */				 tskIDLE_PRIORITY, 			/* The priority at which the task will execute. */				 NULL );					/* Used to pass the handle of the created task out to the function caller - not used in this case. */	xTaskCreate( prvRegTest2Entry, "Reg2", configMINIMAL_STACK_SIZE, mainREG_TEST_2_PARAMETER, 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. */							  );	/* Create the software timer that just increments a variable for demo	purposes. */	xDemoTimer = xTimerCreate( "DemoTimer",						/* A text name, purely to help debugging. */								( mainDEMO_TIMER_PERIOD_MS ),	/* The timer period, in this case it is always calculated relative to the check timer period (see the definition of mainDEMO_TIMER_PERIOD_MS). */								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. */								prvDemoTimerCallback			/* The callback function that inspects the status of all the other tasks. */							  );	/* Start both the check timer and the demo timer.  The timers won't actually	start until the scheduler is started. */	xTimerStart( xCheckTimer, mainDONT_BLOCK );	xTimerStart( xDemoTimer, mainDONT_BLOCK );	/* Finally start the scheduler 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( ;; );}

/* * Starts all the other tasks, then starts the scheduler. */void main( void ){	#ifdef DEBUG		debug();	#endif		/* Setup any hardware that has not already been configured by the low	level init routines. */	prvSetupHardware();	/* Create the queue used to send data to the LCD task. */	xLCDQueue = xQueueCreate( mainLCD_QUEUE_LEN, sizeof( xLCDMessage ) );		/* Start all the standard demo application tasks. */	vStartIntegerMathTasks( tskIDLE_PRIORITY );	vStartLEDFlashTasks( mainLED_TASK_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	vStartDynamicPriorityTasks();	vStartMathTasks( tskIDLE_PRIORITY );	vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );	vStartGenericQueueTasks( mainGENERIC_QUEUE_PRIORITY );	vStartQueuePeekTasks();		/* Start the tasks which are defined in this file. */	xTaskCreate( vErrorChecks, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	xTaskCreate( prvLCDTask, "LCD", configMINIMAL_STACK_SIZE, ( void * ) &xLCDQueue, mainLCD_TASK_PRIORITY, NULL );	xTaskCreate( prvLCDMessageTask, "MSG", configMINIMAL_STACK_SIZE, ( void * ) &xLCDQueue, mainMSG_TASK_PRIORITY, NULL );	/* Start either the uIP TCP/IP stack or the lwIP TCP/IP stack. */	#ifdef STACK_UIP		/* Finally, create the WEB server task. */		xTaskCreate( vuIP_Task, "uIP", configMINIMAL_STACK_SIZE * 3, NULL, mainCHECK_TASK_PRIORITY - 1, NULL );	#endif	#ifdef STACK_LWIP			/* Create the lwIP task.  This uses the lwIP RTOS abstraction layer.*/	  	vlwIPInit();		sys_set_state(	( signed portCHAR * ) "httpd", lwipBASIC_SERVER_STACK_SIZE );	  	sys_thread_new( vBasicWEBServer, ( void * ) NULL, basicwebWEBSERVER_PRIORITY );		sys_set_default_state();	#endif	/* Start the scheduler.	NOTE : Tasks run in system mode and the scheduler runs in Supervisor mode.	The processor MUST be in supervisor mode when vTaskStartScheduler is	called.  The demo applications included in the FreeRTOS.org download switch	to supervisor mode prior to main being called.  If you are not using one of	these demo application projects then ensure Supervisor mode is used here. */	vTaskStartScheduler();	/* We should never get here as control is now taken by the scheduler. */	for( ;; );}

void main_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" );	}}

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

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. */    vStartDynamicPriorityTasks();    vCreateBlockTimeTasks();    vStartCountingSemaphoreTasks();    vStartGenericQueueTasks( tskIDLE_PRIORITY );    vStartRecursiveMutexTasks();    vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );    vStartTimerDemoTask( mainTIMER_TEST_PERIOD );    vStartEventGroupTasks();    vStartTaskNotifyTask();    vStartInterruptSemaphoreTasks();    /* Note - the set of standard demo tasks contains two versions of    vStartMathTasks.c.  One is defined in flop.c, and uses double precision    floating point numbers and variables.  The other is defined in sp_flop.c,    and uses single precision floating point numbers and variables.  The    MicroBlaze floating point unit only handles single precision floating.    Therefore, to test the floating point hardware, sp_flop.c should be included    in this project. */    vStartMathTasks( mainFLOP_TASK_PRIORITY );    /* 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 the standard CLI commands. */    vRegisterSampleCLICommands();    /* 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 );    /* 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( ;; );}

void main( void ){	/* Configure the peripherals used by this demo application.  This includes	configuring the joystick input select button to generate interrupts. */	prvSetupHardware();	/* Create the queue used by tasks and interrupts to send strings to the LCD	task. */	xLCDQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( xQueueMessage ) );	/* If the queue could not be created then don't create any tasks that might	attempt to use the queue. */	if( xLCDQueue != NULL )	{		/* Create the standard demo tasks. */		vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );		vStartDynamicPriorityTasks();		vStartGenericQueueTasks( mainGENERIC_QUEUE_TEST_PRIORITY );		vStartCountingSemaphoreTasks();				/* Note that creating the timer test/demo tasks will fill the timer		command queue.  This is intentional, and forms part of the test the tasks		perform.  It does mean however that, after this function is called, no		more timer commands can be sent until after the scheduler has been		started (at which point the timer daemon will drained the timer command		queue, freeing up space for more commands to be received). */		vStartTimerDemoTask( mainTIMER_TEST_PERIOD );				/* Create the LCD, button poll and register test tasks, as described at		the top	of this	file. */		xTaskCreate( prvLCDTask, ( signed char * ) "LCD", configMINIMAL_STACK_SIZE * 2, mainTASK_PARAMETER_CHECK_VALUE, mainLCD_TASK_PRIORITY, NULL );		xTaskCreate( prvButtonPollTask, ( signed char * ) "BPoll", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );		xTaskCreate( vRegTest1Task, ( signed char * ) "Reg1", configMINIMAL_STACK_SIZE, NULL, 0, NULL );		xTaskCreate( vRegTest2Task, ( signed char * ) "Reg2", configMINIMAL_STACK_SIZE, NULL, 0, NULL );		/* Create the 'check' timer - the timer that periodically calls the		check function as described at the top of this file.  Note that, for		the reasons stated in the comments above the call to 		vStartTimerDemoTask(), that the check timer is not actually started 		until after the scheduler has been started. */		xCheckTimer = xTimerCreate( ( const signed char * ) "Check timer", mainCHECK_TIMER_PERIOD, pdTRUE, ( void * ) 0, vCheckTimerCallback ); 		/* Start the scheduler. */		vTaskStartScheduler();	}	/* If all is well then this line will never be reached.  If it is reached	then it is likely that there was insufficient (FreeRTOS) heap memory space	to create the idle task.  This may have been trapped by the malloc() failed	hook function, if one is configured. */		for( ;; );}

int main(){#if 1	signal(SIGRTMIN+1, &handler);	raise(SIGRTMIN+1);#endif	// Start the standard demo tasks.	vStartLEDFlashTasks(mainFLASH_PRIORITY | portPRIVILEGE_BIT);#if 0	vStartBlockingQueueTasks(mainBLOCK_Q_PRIORITY);	vCreateBlockTimeTasks();	vStartGenericQueueTasks(mainGEN_QUEUE_TASK_PRIORITY);	vStartQueuePeekTasks();	vStartDynamicPriorityTasks();#endif#if 0	vStartWebserverTask();#endif#if 0	char *name = "testfile";	int len = strlen(name);	DIR *dirp = opendir("/sdcard");	struct dirent *dp;	while ((dp = readdir(dirp)) != NULL)		if (dp->d_namlen == len && !strcmp(dp->d_name, name)) {			(void)closedir(dirp);			printf("found/n");		}	(void)closedir(dirp);	printf("not_found/n");#endif#ifdef CORE_HAS_MPU	xTaskCreate(xBadTask, (signed char *)"BadTask", configMINIMAL_STACK_SIZE, (void *)NULL, tskIDLE_PRIORITY | portPRIVILEGE_BIT, NULL);#endif	xTaskCreate(simpleSerialTask, (signed char *)"Ser", configMINIMAL_STACK_SIZE, (void *)NULL, tskIDLE_PRIORITY | portPRIVILEGE_BIT, NULL);	printf("Starting scheduler./n");	fflush(stdout);	// Start the scheduler.	vTaskStartScheduler();	// Will only get here if there was insufficient memory to create the idle task.	// Wait for WDT to reset.	PowerManagement_PowerDown();}

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

short main( void ){	/* Creates all the tasks and timers, then starts the scheduler. */	/* First create the 'standard demo' tasks.  These are used to demonstrate	API functions being used and also to test the kernel port.  More information	is provided on the FreeRTOS.org WEB site. */	vStartDynamicPriorityTasks();	vStartPolledQueueTasks( tskIDLE_PRIORITY );	vCreateBlockTimeTasks();	/* Create the RegTest tasks as described at the top of this file. */	xTaskCreate( vRegTest1, "Reg1", configMINIMAL_STACK_SIZE, NULL, 0, NULL );	xTaskCreate( vRegTest2, "Reg2", configMINIMAL_STACK_SIZE, NULL, 0, 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. */							  );								/* Create the software timer that just increments a variable for demo	purposes. */	xDemoTimer = xTimerCreate( ( const signed char * ) "DemoTimer",/* A text name, purely to help debugging. */								( mainDEMO_TIMER_PERIOD_MS ),		/* The timer period, in this case it is always calculated relative to the check timer period (see the definition of mainDEMO_TIMER_PERIOD_MS). */								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. */								prvDemoTimerCallback				/* The callback function that inspects the status of all the other tasks. */							  );		/* Start both the check timer and the demo timer.  The timers won't actually	start until the scheduler is started. */	xTimerStart( xCheckTimer, mainDONT_BLOCK );	xTimerStart( xDemoTimer, mainDONT_BLOCK );		/* Finally start the scheduler running. */	vTaskStartScheduler();	/* If this line is reached then vTaskStartScheduler() returned because there	was insufficient heap memory remaining for the idle task to be created. */	for( ;; );}

/*  * 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();		/* 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 );	xTaskCreate( vButtonTask, "Button", configMINIMAL_STACK_SIZE, NULL, mainBUTTON_TASK_PRIORITY, NULL );		/* All the tasks have been created - start the scheduler. */	vTaskStartScheduler();		/* Should not reach here! */	for( ;; );}

int main( void ){	/* Setup the peripheral bus to be the same as the PLL output. */	VPBDIV = mainBUS_CLK_FULL;	/* Create the queue used to pass message to vPrintTask. */	xPrintQueue = xQueueCreate( mainQUEUE_SIZE, sizeof( char * ) );	/* Create the semaphore used to wake vButtonHandlerTask(). */	vSemaphoreCreateBinary( xButtonSemaphore );	xSemaphoreTake( xButtonSemaphore, 0 );	/* Start the standard demo tasks. */	vStartIntegerMathTasks( tskIDLE_PRIORITY );	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );	vStartDynamicPriorityTasks();	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );	#if configUSE_PREEMPTION == 1	{		/* The timing of console output when not using the preemptive		scheduler causes the block time tests to detect a timing problem. */		vCreateBlockTimeTasks();	}	#endif    vStartRecursiveMutexTasks();	/* Start the tasks defined within this file. */	xTaskCreate( vLEDTask, "LED", configMINIMAL_STACK_SIZE, NULL, mainLED_TASK_PRIORITY, NULL );    xTaskCreate( vCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );    xTaskCreate( vPrintTask, "Print", configMINIMAL_STACK_SIZE, NULL, mainPRINT_TASK_PRIORITY, NULL );    xTaskCreate( vButtonHandlerTask, "Button", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );	/* Start the scheduler. */	vTaskStartScheduler();	/* The scheduler should now be running, so we will only ever reach here if we	ran out of heap space. */	return 0;}