void taskENTER_CRITICAL( void );void taskEXIT_CRITICAL( void );

/*临界段的函数应用. */void vDemoFunction( void ){    /* 进入临界区。在本例中，这个函数本身是从一个临界区中调用的，因此进入这个临界区将导致嵌套深度为2。*/    taskENTER_CRITICAL();
    /* 执行此处临界区所保护的操作。*/
    /* 退出临界区。在本例中，这个函数本身是从临界区调用的，因此对taskEXIT_CRITICAL()的调用将使嵌套计数减少1，但不会导致启用中断。*/    taskEXIT_CRITICAL();}
/* 从临界区中调用vDemoFunction()的任务。*/void vTask1( void * pvParameters ){    for( ;; )    {        /* 在这里执行一些功能。*/
        /* 调用taskENTER_CRITICAL()创建临界区。*/        taskENTER_CRITICAL();
        /* 执行需要临界区的代码。*/
        /* 对taskENTER_CRITICAL()的调用可以嵌套，因此调用包含自己对taskENTER_CRITICAL()和taskEXIT_CRITICAL()调用的函数是安全的。*/        vDemoFunction();
        /* 事件需要进入临界区的操作已经完成，需要退出临界区。在调用taskEXIT_CRITICAL()之后，嵌套深度将为零，因此中断将被重新启用。*/        taskEXIT_CRITICAL();    }}

/* 从ISR调用的函数。*/void vDemoFunction( void ){UBaseType_t uxSavedInterruptStatus;
    /* 进入临界区。在这个例子中，这个函数本身是从一个临界区中调用的，所以进入这个临界区将导致嵌套深度为2。将taskENTER_CRITICAL_FROM_ISR()返回的值保存到本地堆栈变量中，以便将其传递给taskEXIT_CRITICAL_FROM_ISR()。*/    uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR();
    /* 执行临界区保护的操作。*/
    /* 退出临界区。在这个例子中，这个函数本身是从临界区调用的，所以中断在uxSavedInterruptStatus中存储值之前就已经被禁用了，因此将uxSavedInterruptStatus传递给taskEXIT_CRITICAL_FROM_ISR()不会导致中断被重新启用。*/    taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );}
/* 从中断服务例程中调用vDemoFunction()的任务。*/void vDemoISR( void ){UBaseType_t uxSavedInterruptStatus;
    /* 调用taskENTER_CRITICAL_FROM_ISR()创建一个临界区，将返回值保存到本地堆栈变量中。*/    uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR();
    /* 执行需要临界区的代码。*/
    /* 对taskENTER_CRITICAL_FROM_ISR()的调用可以嵌套，因此可以安全地调用
函数，该函数包含对taskENTER_CRITICAL_FROM_ISR()和
taskEXIT_CRITICAL_FROM_ISR()。*/    vDemoFunction();
    /* 事件需要进入临界区的操作已经完成，需要退出临界区。假设中断在进入这个ISR时被启用，保存在uxSavedInterruptStatus中的值将导致中断被重新启用。*/    taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );}

void vAFunction( void ){     // Tasks can be created before or after starting the RTOS     scheduler     xTaskCreate( vTaskCode,                  "NAME",                  STACK_SIZE,                  NULL,                  tskIDLE_PRIORITY,                  NULL );
     // Start the real time scheduler.     vTaskStartScheduler();
     // Will not get here unless there is insufficient RAM. }

void vTaskCode( void * pvParameters ){     for( ;; )     {         // Task code goes here.
         // At some point we want to end the real time kernel processing          // so call ...         vTaskEndScheduler ();     } }
 void vAFunction( void ){     // Create at least one task before starting the RTOS kernel.     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
     // Start the real time kernel with preemption.     vTaskStartScheduler();
     // Will only get here when the vTaskCode () task has called      // vTaskEndScheduler ().  When we get here we are back to single task      // execution. }

/* A function that suspends then resumes the scheduler. */void vDemoFunction( void ){    /* This function suspends the scheduler.  When it is called from vTask1 the     scheduler is already suspended, so this call creates a nesting depth of 2. */    vTaskSuspendAll();            /* Perform an action here. */            /* As calls to vTaskSuspendAll() are nested, resuming the scheduler here will     not cause the scheduler to re-enter the active state. */    xTaskResumeAll();}
void vTask1( void * pvParameters ){    for( ;; )    {        /* Perform some actions here. */                    /* At some point the task wants to perform an operation during which it does         not want to get swapped out, or it wants to access data which is also         accessed from another task (but not from an interrupt).  It cannot use        taskENTER_CRITICAL()/taskEXIT_CRITICAL() as the length of the operation may        cause interrupts to be missed. */            
        /* Prevent the scheduler from performing a context switch. */        vTaskSuspendAll();            
        /* Perform the operation here.  There is no need to use critical sections as         the task has all the processing time other than that utilized by interrupt         service routines.*/                                           /* Calls to vTaskSuspendAll() can be nested so it is safe to call a (non API)         function which also contains calls to vTaskSuspendAll().  API functions         should not be called while the scheduler is suspended. */        vDemoFunction();
                    /* The operation is complete.  Set the scheduler back into the Active         state. */        if( xTaskResumeAll() == pdTRUE )        {            /* A context switch occurred within xTaskResumeAll(). */        }        else        {            /* A context switch did not occur within xTaskResumeAll(). */        }    }}

void vTask1( void * pvParameters ) {     for( ;; )     {         /* Task code goes here. */
         /* ... */
         /* At some point the task wants to perform a long operation         during which it does not want to get swapped out.  It cannot         use taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length         of the operation may cause interrupts to be missed -         including the ticks.
         Prevent the RTOS kernel swapping out the task. */         vTaskSuspendAll();
         /* Perform the operation here.  There is no need to use critical         sections as we have all the microcontroller processing time.         During this time interrupts will still operate and the real         time RTOS kernel tick count will be maintained. */
         /* ... */
         /* The operation is complete.  Restart the RTOS kernel.  We want to force         a context switch - but there is no point if resuming the scheduler         caused a context switch already. */         if( !xTaskResumeAll () )         {              taskYIELD ();         }     } }

/* First define the portSUPPRESS_TICKS_AND_SLEEP().  The parameter is the time,in ticks, until the kernel next needs to execute. */#define portSUPPRESS_TICKS_AND_SLEEP( xIdleTime ) vApplicationSleep( xIdleTime )
/* Define the function that is called by portSUPPRESS_TICKS_AND_SLEEP(). */void vApplicationSleep( TickType_t xExpectedIdleTime ){unsigned long ulLowPowerTimeBeforeSleep, ulLowPowerTimeAfterSleep;
    /* Read the current time from a time source that will remain operational    while the microcontroller is in a low power state. */    ulLowPowerTimeBeforeSleep = ulGetExternalTime();
    /* Stop the timer that is generating the tick interrupt. */    prvStopTickInterruptTimer();
    /* Configure an interrupt to bring the microcontroller out of its low power    state at the time the kernel next needs to execute.  The interrupt must be    generated from a source that is remains operational when the microcontroller    is in a low power state. */    vSetWakeTimeInterrupt( xExpectedIdleTime );
    /* Enter the low power state. */    prvSleep();
    /* Determine how long the microcontroller was actually in a low power state    for, which will be less than xExpectedIdleTime if the microcontroller was    brought out of low power mode by an interrupt other than that configured by    the vSetWakeTimeInterrupt() call.  Note that the scheduler is suspended    before portSUPPRESS_TICKS_AND_SLEEP() is called, and resumed when    portSUPPRESS_TICKS_AND_SLEEP() returns.  Therefore no other tasks will    execute until this function completes. */    ulLowPowerTimeAfterSleep = ulGetExternalTime();
    /* Correct the kernels tick count to account for the time the microcontroller    spent in its low power state. */    vTaskStepTick( ulLowPowerTimeAfterSleep - ulLowPowerTimeBeforeSleep );
    /* Restart the timer that is generating the tick interrupt. */    prvStartTickInterruptTimer();}

void vExampleFunction( void ){    unsigned long ulTimeBefore, ulTimeAfter;
    /* Read the current time before arbitrary processing takes place. */    ulTimeBefore = ulGetExternalTime();
    /* Stop the timer that is generating the tick interrupt. */    prvStopTickInterruptTimer();     /* Perform some arbitrary processing. */    arbitrary_processing();        /* Read the current time for computing elapsed time since ticks     were disabled. */    ulTimeAfter = ulGetExternalTime();
    if ( xTaskCatchUpTicks( ulTimeAfter - ulTimeBefore ) == pdTRUE )     {        /* Moving the tick count forward resulted in a context switch. */    }        /* Restart the timer that is generating the tick interrupt. */    prvStartTickInterruptTimer();
}