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

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 buzzerInit(DeckInfo *info){  piezoInit();  neffect = sizeof(effects)/sizeof(effects[0])-1;  nmelody = sizeof(melodies)/sizeof(melodies[0])-1;  timer = xTimerCreate( "buzztimer", M2T(10),                                     pdTRUE, NULL, buzzTimer );  xTimerStart(timer, 100);}

// Initializes timer to specified period in msvoid timer_initialize(int ms){    TimerHandle_t myTimer1;    myTimer1 = xTimerCreate("test",                           (ms/portTICK_PERIOD_MS),                           pdTRUE,                            (void *)0,                           timerCallback);    if (xTimerStart(myTimer1,10) == pdFAIL)        error('a');}

FreeRTOSTimer::FreeRTOSTimer(tmrTIMER_CALLBACK pFunction, TIME_MS t, TimerType type){	// xTimerCreate() copies the pointer for the name, so the tName variable	// cannot simply be on the stack, it should be global or static	static signed char tName[] = "Tmr";	mTimerHandle = xTimerCreate(tName, OS_MS(t),								type == TimerOneShot ? pdFALSE : pdTRUE,								0,								pFunction);}

/// Create a timer./// /param[in]     timer_def     timer object referenced with /ref osTimer./// /param[in]     type          osTimerOnce for one-shot or osTimerPeriodic for periodic behavior./// /param[in]     argument      argument to the timer call back function./// /return timer ID for reference by other functions or NULL in case of error./// /note MUST REMAIN UNCHANGED: /b osTimerCreate shall be consistent in every CMSIS-RTOS.osTimerId osTimerCreate (const osTimerDef_t *timer_def, os_timer_type type, void *argument){    timer_def->custom->argument = argument;    return xTimerCreate((const portCHAR *)"",                        1,  //Set later when timer is started                        (type == osTimerPeriodic) ? pdTRUE : pdFALSE,                        (void *)timer_def,                        _osTimerCallbackFreeRTOS                        );}

void vTask4(void *pvParameters) {	// Remove compiler warnings.	(void) pvParameters;		xTimer1 = xTimerCreate( "Timer 1",( 4000 ), pdTRUE,( void * ) 41, vTimerCallback1);	xTimerStart(xTimer1,0);		vTaskDelay(2000);	xTimer2 = xTimerCreate( "Timer 2",( 4000 ), pdTRUE,( void * ) 42, vTimerCallback2);	xTimerStart(xTimer2,0);		vTaskDelay(1000);	xTimer3 = xTimerCreate( "Timer 3",( 2000 ), pdTRUE,( void * ) 43, vTimerCallback3);	xTimerStart(xTimer3,0);		while (1) {		vTaskSuspend(NULL);	}	vTaskDelete(NULL);}

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 APP_Initialize ( void ){    //stopEverything();    /* Place the App state machine in its initial state. */    appData.state = APP_STATE_INIT;        /* TODO: Initialize your application's state machine and other     * parameters.     */    //Create the queue    appData.local_q = xQueueCreate(10, sizeof(unsigned int));    //Ensure queue was created. If not, do not continue and turn on LED    if(appData.local_q == 0)    {        stopEverything();    }    appData.sensor1_q = xQueueCreate(100, sizeof(unsigned char));    if(appData.sensor1_q == 0)    {        stopEverything();    }    //stopEverything();    //Create the timer    appData.local_timer = xTimerCreate( "50msTimer",                50 / portTICK_PERIOD_MS,                pdTRUE,                0,                vTimerCallback );        //Ensure timer was created. If not, do not continue and turn on LED    if(appData.local_timer == 0)    {        stopEverything();    }    BaseType_t started = xTimerStart(appData.local_timer, 0);        //Ensure the timer started successfully. If not, do not continue and turn    // on LED    if(started == pdFAIL)    {        stopEverything();    }           //Setup AD Driver    SYS_INT_SourceEnable(INT_SOURCE_ADC_1);    DRV_ADC_Initialize();    DRV_ADC_Open();    DRV_ADC_ChannelScanInputsAdd(ADC_INPUT_SCAN_AN0 | ADC_INPUT_SCAN_AN1|ADC_INPUT_SCAN_AN2);    PLIB_ADC_MuxAInputScanEnable(ADC_ID_1);    DRV_ADC_Start();        /* Initialization is done, allow the state machine to continue */    appData.state = APP_STATE_OUTPUT;}

/**@brief Function for the Timer initialization. * * @details Initializes the timer module. This creates and starts application timers. */static void timers_init(void){    // Initialize timer module.    APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, false);    // Create timers.    m_battery_timer        = xTimerCreate("BATT", BATTERY_LEVEL_MEAS_INTERVAL     , pdTRUE, NULL, battery_level_meas_timeout_handler     );    m_heart_rate_timer     = xTimerCreate("HRT" , HEART_RATE_MEAS_INTERVAL        , pdTRUE, NULL, heart_rate_meas_timeout_handler        );    m_rr_interval_timer    = xTimerCreate("RRT" , RR_INTERVAL_INTERVAL            , pdTRUE, NULL, rr_interval_timeout_handler            );    m_sensor_contact_timer = xTimerCreate("SCT" , SENSOR_CONTACT_DETECTED_INTERVAL, pdTRUE, NULL, sensor_contact_detected_timeout_handler);    /* Error checking */    if( (NULL == m_battery_timer)     || (NULL == m_heart_rate_timer)     || (NULL == m_rr_interval_timer)     || (NULL == m_sensor_contact_timer) )    {        APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);    }}

void ICACHE_FLASH_ATTR createTimer(char * ssid, char * pwd){	sprintf(ssid_name, "%s/0", ssid);	sprintf(password,"%s/0",pwd);     xTimerHandle wifiTimer=xTimerCreate("r",200,pdFALSE, (void *)1,vTimerSCallback);       if( xTimerStart( wifiTimer,0) == pdPASS )  {          printf("timer STATION babe!!!!! /n");       }}

void timer_initiaize_20(int ms){        TimerHandle_t myTimer2;    myTimer2 = xTimerCreate("test2",                           (ms/portTICK_PERIOD_MS),                           pdTRUE,                            (void *)0,                           timerCallback_20);    if (xTimerStart(myTimer2,10) == pdFAIL)        error('a');    } 

/**  * @brief  Main program  * @param  None  * @retval None  */int main() {    TimerHandle_t idTim1;    idTim1=xTimerCreate("Timer1", 1000/portTICK_RATE_MS, pdTRUE, 0, led1_callback);    xTimerStart(idTim1, 0);    xTaskCreate(led2_thread, "Thread1", 1024, (void*) NULL, tskIDLE_PRIORITY + 1UL, NULL);    vTaskStartScheduler();        for(;;);}

void queueMonitorInit() {  ASSERT(!initialized);  timer = xTimerCreate( "queueMonitorTimer", TIMER_PERIOD,    pdTRUE, NULL, timerHandler );  xTimerStart(timer, 100);  data[0].fileName = "Na";  data[0].queueName = "Na";  initialized = true;}

static void prvInitialise_uIP( void ){uip_ipaddr_t xIPAddr;xTimerHandle xARPTimer, xPeriodicTimer;	uip_init();	uip_ipaddr( &xIPAddr, configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 );	uip_sethostaddr( &xIPAddr );	uip_ipaddr( &xIPAddr, configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3 );	uip_setnetmask( &xIPAddr );	prvSetMACAddress();	httpd_init();	/* Create the queue used to sent TCP/IP events to the uIP stack. */	xEMACEventQueue = xQueueCreate( uipEVENT_QUEUE_LENGTH, sizeof( unsigned long ) );	/* Create and start the uIP timers. */	xARPTimer = xTimerCreate( 	( signed char * ) "ARPTimer", /* Just a name that is helpful for debugging, not used by the kernel. */								( 10000UL / portTICK_RATE_MS ), /* Timer period. */								pdTRUE, /* Autor-reload. */								( void * ) uipARP_TIMER,								prvUIPTimerCallback							);	xPeriodicTimer = xTimerCreate( 	( signed char * ) "PeriodicTimer",									( 500UL / portTICK_RATE_MS ),									pdTRUE, /* Autor-reload. */									( void * ) uipPERIODIC_TIMER,									prvUIPTimerCallback								);	/* Sanity check that the timers were indeed created. */	configASSERT( xARPTimer );	configASSERT( xPeriodicTimer );	configASSERT( xEMACEventQueue );	/* These commands will block indefinitely until they succeed, so there is	no point in checking their return values. */	xTimerStart( xARPTimer, portMAX_DELAY );	xTimerStart( xPeriodicTimer, portMAX_DELAY );}

void ad_rf_init(void){        if (dg_configRF_RECALIBRATION_TIMER_TIMEOUT > 0) {                /* Initialize timer */                recalib_timer = xTimerCreate("RFRecalibTimer",                        dg_configRF_RECALIBRATION_TIMER_TIMEOUT,                        pdFALSE,                        NULL,                        recalib_timer_cb);                OS_ASSERT(recalib_timer != NULL);        }}

static void setup_debug_tools(){        /* Only enable this code if we are doing debug work */#if ! (ASL_DEBUG)        return;#endif        const size_t timer_ticks = msToTicks(CHAR_CHECK_PERIOD_MS);        const signed char* timer_name = (signed char*) "Dropped Char Check Timer";        xTimerHandle timer_handle = xTimerCreate(timer_name, timer_ticks,                                                 true, NULL, dropped_char_timer_cb);        xTimerStart(timer_handle, timer_ticks);}

/*** @brief  Create a timer.* @param  timer_def     timer object referenced with /ref osTimer.* @param  type          osTimerOnce for one-shot or osTimerPeriodic for periodic behavior.* @param  argument      argument to the timer call back function.* @retval  timer ID for reference by other functions or NULL in case of error.* @note   MUST REMAIN UNCHANGED: /b osTimerCreate shall be consistent in every CMSIS-RTOS.*/osTimerId osTimerCreate (const osTimerDef_t *timer_def, os_timer_type type, void *argument){#if (configUSE_TIMERS == 1)  return xTimerCreate((const char *)"",                      1, // period should be filled when starting the Timer using osTimerStart                      (type == osTimerPeriodic) ? pdTRUE : pdFALSE,                      (void *) argument,                      (TaskFunction_t)timer_def->ptimer);#else 	return NULL;#endif}

void SEND_Initialize ( void ){    sendData.state = SEND_STATE_INIT;    sendData.sendCount = 0x55;    sendData.testCount = 0;    sendData.enqueueCount = 0;    sendData.prevType = 'a';    sendData.prevCount = 'a';        strcpy(sendData.storedMessage, "~e8765432.");        sendData.sendStoredMessage = 0;        //Create a queue capable of holding 1000 characters    sendData.transmitQ_SA = xQueueCreate( 1000, sizeof(char) );    if( sendData.transmitQ_SA == 0 ) {        dbgOutputVal(SEND_QUEUE_FAIL);        stopAll();    }        // Create a queue capable of holding 250 messages    sendData.sendQ_LR = xQueueCreate(250, MSG_LENGTH+1);    if (sendData.sendQ_LR == 0) {        dbgOutputVal(SEND_QUEUE_FAIL);        stopAll();    }        //Create a timer    sendData.sendTimer_SA = xTimerCreate(                       "SendTimer100ms", //Just a text name                     ( 1000 / portTICK_PERIOD_MS ), //period is 100ms                     pdTRUE, //auto-reload when expires                     (void *) 24, //a unique id                     sendTimerCallback ); //pointer to callback function            //if SENSOR_DEBUG_NOACK is defined, then don't start the timer    #ifndef SENSOR_DEBUG_NOACK        //Start the timer        if( sendData.sendTimer_SA == NULL ) {            dbgOutputVal(SEND_TIMERINIT_FAIL);            stopAll();        }        else if( xTimerStart( sendData.sendTimer_SA, 0 ) != pdPASS ) {            dbgOutputVal(SEND_TIMERINIT_FAIL);            stopAll();        }    #endif         }

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(void){	int timerID = 1;	int timerID1 = 2;	/*A Timer used to count how long there is no signal come in*/	xTimerNoSignal = xTimerCreate("TurnOffTime", 10000 / portTICK_RATE_MS, pdFALSE,  (void *) timerID, vTimerSystemIdle);	xTimerSampleRate = xTimerCreate("SensorSampleRate", 4 / portTICK_RATE_MS, pdTRUE,  (void *) timerID1, vTimerSample);	/*a queue for tansfer the senddate to USART task*/	xQueueUARTSend = xQueueCreate(15, sizeof(serial_str_msg));   	xQueueUARTRecvie = xQueueCreate(15, sizeof(serial_ch_msg));   	xQueueShell2PWM = xQueueCreate(3, sizeof(pwm_ch_msg));   	xQueuePitchdirection = xQueueCreate(3, sizeof(pitch_direction_msg));   	xQueueRolldirection = xQueueCreate(3, sizeof(roll_direction_msg));	/* initialize hardware... */	prvSetupHardware();	init_I2C1();	xTimerStart(xTimerNoSignal, 0);	/* Start the tasks defined within this file/specific to this demo. */	xTaskCreate(vPWMctrlTask, ( signed portCHAR * ) "pwmctrl", configMINIMAL_STACK_SIZE, NULL,tskIDLE_PRIORITY, NULL );	xTaskCreate(vUsartSendTask, ( signed portCHAR * ) "USART", configMINIMAL_STACK_SIZE, NULL,tskIDLE_PRIORITY, NULL);	xTaskCreate(shell, ( signed portCHAR * ) "shell", configMINIMAL_STACK_SIZE, NULL,tskIDLE_PRIORITY + 5, NULL);	xTaskCreate(vBalanceTask, ( signed portCHAR * ) "Balance", configMINIMAL_STACK_SIZE, NULL,tskIDLE_PRIORITY, NULL);	xTaskCreate(vPitchctrlTask, ( signed portCHAR * ) "Pitchctrl", configMINIMAL_STACK_SIZE, NULL,tskIDLE_PRIORITY, NULL );	xTaskCreate(vRollctrlTask, ( signed portCHAR * ) "Rollctrl", configMINIMAL_STACK_SIZE, NULL,tskIDLE_PRIORITY, NULL );	/* Start the scheduler. */	vTaskStartScheduler();	/* Will only get here if there was not enough heap space to create the idle task. */	return 0;  }

/** * @brief	The main task for the CAN2 channel * @param	pvParameters: * @retval	None */void can2Task(void *pvParameters){	/* Mutex semaphore to manage when it's ok to send and receive new data */	xSemaphore = xSemaphoreCreateMutex();	/* Mutex semaphore for accessing the settings for this channel */	xSettingsSemaphore = xSemaphoreCreateMutex();	/* Create software timers */	prvBuffer1ClearTimer = xTimerCreate("Buf1ClearCan2", 10, pdFALSE, 0, prvBuffer1ClearTimerCallback);	prvBuffer2ClearTimer = xTimerCreate("Buf2ClearCan2", 10, pdFALSE, 0, prvBuffer2ClearTimerCallback);	/* Initialize hardware */	prvHardwareInit();	/* Wait to make sure the SPI FLASH is initialized */	while (SPI_FLASH_Initialized() == false)	{		vTaskDelay(100 / portTICK_PERIOD_MS);	}	/* Try to read the settings from SPI FLASH */	prvReadSettingsFromSpiFlash();	can2Clear();	/* The parameter in vTaskDelayUntil is the absolute time	 * in ticks at which you want to be woken calculated as	 * an increment from the time you were last woken. */	TickType_t xNextWakeTime;	/* Initialize xNextWakeTime - this only needs to be done once. */	xNextWakeTime = xTaskGetTickCount();	prvDoneInitializing = true;	while (1)	{		vTaskDelayUntil(&xNextWakeTime, 1000 / portTICK_PERIOD_MS);	}}

void ICACHE_FLASH_ATTR createTimerWifi(void){	if(!restartActive){	    restartActive=1;             xTimerHandle wifiTimer2=xTimerCreate("s",200,pdFALSE, (void *)1,vTimerSACallback);           if( xTimerStart( wifiTimer2,0) == pdPASS )  {              printf("timer SOft AP babe!!!!! /n");             }	}}

static void prvInitialise_uIP( void ){    TimerHandle_t xARPTimer, xPeriodicTimer;    uip_ipaddr_t xIPAddr;    const unsigned long ul_uIPEventQueueLength = 10UL;    /* Initialise the uIP stack. */    uip_init();    uip_ipaddr( &xIPAddr, configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 );    uip_sethostaddr( &xIPAddr );    uip_ipaddr( &xIPAddr, configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3 );    uip_setnetmask( &xIPAddr );    prvSetMACAddress();    httpd_init();    /* Create the queue used to sent TCP/IP events to the uIP stack. */    xEMACEventQueue = xQueueCreate( ul_uIPEventQueueLength, sizeof( unsigned long ) );    /* Create and start the uIP timers. */    xARPTimer = xTimerCreate( 	"ARPTimer", /* Just a name that is helpful for debugging, not used by the kernel. */                                ( 10000UL / portTICK_PERIOD_MS ), /* Timer period. */                                pdTRUE, /* Autor-reload. */                                ( void * ) uipARP_TIMER,                                prvUIPTimerCallback                            );    xPeriodicTimer = xTimerCreate( 	"PeriodicTimer",                                    ( 50 / portTICK_PERIOD_MS ),                                    pdTRUE, /* Autor-reload. */                                    ( void * ) uipPERIODIC_TIMER,                                    prvUIPTimerCallback                                 );    configASSERT( xARPTimer );    configASSERT( xPeriodicTimer );    xTimerStart( xARPTimer, portMAX_DELAY );    xTimerStart( xPeriodicTimer, portMAX_DELAY );}

void startTimerForADC(adcStruct *adcData) {	if (sizeof(long) != sizeof(adcStruct *)) {		VT_HANDLE_FATAL_ERROR(0);	}	xTimerHandle adcTimerHandle = xTimerCreate((const signed char *)"ADC Timer",adcWRITE_RATE_BASE,pdTRUE,(void *) adcData,adcTimerCallback);	if (adcTimerHandle == NULL) {		VT_HANDLE_FATAL_ERROR(0);	} else {		if (xTimerStart(adcTimerHandle,0) != pdPASS) {			VT_HANDLE_FATAL_ERROR(0);		}	}}

void startTimerForLCD(vtLCDStruct *vtLCDdata) {	if (sizeof(long) != sizeof(vtLCDStruct *)) {		VT_HANDLE_FATAL_ERROR(0);	}	xTimerHandle LCDTimerHandle = xTimerCreate((const signed char *)"LCD Timer",lcdWRITE_RATE_BASE,pdTRUE,(void *) vtLCDdata,LCDTimerCallback);	if (LCDTimerHandle == NULL) {		VT_HANDLE_FATAL_ERROR(0);	} else {		if (xTimerStart(LCDTimerHandle,0) != pdPASS) {			VT_HANDLE_FATAL_ERROR(0);		}	}}

/*-------------------------------------------| Name:rttmr_create| Description:| Parameters:| Return Type:| Comments:| See:---------------------------------------------*/int rttmr_create(tmr_t* tmr,rttmr_attr_t* rttmr_attr){   if(!tmr || !rttmr_attr)      return -1;#ifdef __KERNEL_UCORE_FREERTOS   //OS_CreateTimer(tmr,rttmr_attr->func,rttmr_attr->tm_msec);   xTimerCreate( "timer",                (portTickType)(rttmr_attr->tm_msec/portTICK_RATE_MS),                pdFALSE,                tmr,                (tmrTIMER_CALLBACK) rttmr_attr->func );#endif   return 0;}