void vPrintString( const char *pcString )
{
     /* Write the string to stdout, using a critical section as a crude method of
     mutual exclusion. */
     taskENTER_CRITICAL();
     {
         printf( "%s", pcString );
         fflush( stdout );
     }
     taskEXIT_CRITICAL();
}

void vAnInterruptServiceRoutine( void )	//中断安全版本
{
    /* Declare a variable in which the return value from
    taskENTER_CRITICAL_FROM_ISR() will be saved. */
    UBaseType_t uxSavedInterruptStatus;
    /* This part of the ISR can be interrupted by any higher priority
    interrupt. */
    /* Use taskENTER_CRITICAL_FROM_ISR() to protect a region of this ISR.
    Save the value returned from taskENTER_CRITICAL_FROM_ISR() so it can
    be passed into the matching call to taskEXIT_CRITICAL_FROM_ISR(). */
    uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR();
    /* This part of the ISR is between the call to
    taskENTER_CRITICAL_FROM_ISR() and taskEXIT_CRITICAL_FROM_ISR(), so can
    only be interrupted by interrupts that have a priority above that set
    by the configMAX_SYSCALL_INTERRUPT_PRIORITY constant. */
    /* Exit the critical section again by calling taskEXIT_CRITICAL_FROM_ISR(),
    passing in the value returned by the matching call to
    taskENTER_CRITICAL_FROM_ISR(). */
    taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );
    /* This part of the ISR can be interrupted by any higher priority
    interrupt. */
}

void vPrintString( const char *pcString )
{
/* Write the string to stdout, suspending the scheduler as a method of
mutual exclusion. */
    vTaskSuspendScheduler();
    {
        printf( "%s", pcString );
        fflush( stdout );
    }
        xTaskResumeScheduler();
}

static void prvNewPrintString( const char *pcString )
{
    /* The mutex is created before the scheduler is started, so already exists
    by the time this task executes.
    Attempt to take the mutex, blocking indefinitely to wait for the mutex
    if it is not available straight away. The call to xSemaphoreTake() will
    only return when the mutex has been successfully obtained, so there is
    no need to check the function return value. If any other delay period
    was used then the code must check that xSemaphoreTake() returns pdTRUE
    before accessing the shared resource (which in this case is standard
    out). As noted earlier in this book, indefinite time outs are not
    recommended for production code. */
    xSemaphoreTake( xMutex, portMAX_DELAY );
    {
        /* The following line will only execute once the mutex has been
        successfully obtained. Standard out can be accessed freely now as
        only one task can have the mutex at any one time. */
        printf( "%s", pcString );
        fflush( stdout );
        /* The mutex MUST be given back! */
    }
    xSemaphoreGive( xMutex );
}

/* Recursive mutexes are variables of type SemaphoreHandle_t. */
SemaphoreHandle_t xRecursiveMutex;
/* The implementation of a task that creates and uses a recursive mutex. */
void vTaskFunction( void *pvParameters )
{
    const TickType_t xMaxBlock20ms = pdMS_TO_TICKS( 20 );
    /* Before a recursive mutex is used it must be explicitly created. */
    xRecursiveMutex = xSemaphoreCreateRecursiveMutex();
    /* Check the semaphore was created successfully. configASSERT() is
    described in section 11.2. */
    configASSERT( xRecursiveMutex );
    /* As per most tasks, this task is implemented as an infinite loop. */
    for( ;; )
    {
        /* ... */
        /* Take the recursive mutex. */
        if( xSemaphoreTakeRecursive( xRecursiveMutex, xMaxBlock20ms ) == pdPASS )
        {
            /* The recursive mutex was successfully obtained. The task can now
            access the resource the mutex is protecting. At this point the
            recursive call count (which is the number of nested calls to
            xSemaphoreTakeRecursive()) is 1, as the recursive mutex has
            only been taken once. */
            /* While it already holds the recursive mutex, the task takes the
            mutex again. In a real application, this is only likely to occur
            inside a sub-function called by this task, as there is no
            practical reason to knowingly take the same mutex more than
            once. The calling task is already the mutex holder, so the
            second call to xSemaphoreTakeRecursive() does nothing more than
            increment the recursive call count to 2. */
            xSemaphoreTakeRecursive( xRecursiveMutex, xMaxBlock20ms );
            /* ... */
            /* The task returns the mutex after it has finished accessing the
            resource the mutex is protecting. At this point the recursive
            call count is 2, so the first call to xSemaphoreGiveRecursive()
            does not return the mutex. Instead, it simply decrements the
            recursive call count back to 1. */
            xSemaphoreGiveRecursive( xRecursiveMutex );
            /* The next call to xSemaphoreGiveRecursive() decrements the
            recursive call count to 0, so this time the recursive mutex is
            returned. */
            xSemaphoreGiveRecursive( xRecursiveMutex );
            /* Now one call to xSemaphoreGiveRecursive() has been executed for 
            every proceeding call to xSemaphoreTakeRecursive(), so the task
            is no longer the mutex holder. */
        }
    }
}

/* The implementation of a task that uses a mutex in a tight loop. The task
creates a text string in a local buffer, then writes the string to a display.
Access to the display is protected by a mutex. */
void vATask( void *pvParameter )
    {
    extern SemaphoreHandle_t xMutex;
    char cTextBuffer[ 128 ];
    for( ;; )
    {
        /* Generate the text string – this is a fast operation. */
        vGenerateTextInALocalBuffer( cTextBuffer );				//快操作
        /* Obtain the mutex that is protecting access to the display. */
        xSemaphoreTake( xMutex, portMAX_DELAY );
        /* Write the generated text to the display–this is a slow operation. */
        vCopyTextToFrameBuffer( cTextBuffer );					//慢操作
        /* The text has been written to the display, so return the mutex. */
        xSemaphoreGive( xMutex );
    }
}

void vFunction( void *pvParameter )
{
    extern SemaphoreHandle_t xMutex;
    char cTextBuffer[ 128 ];
    TickType_t xTimeAtWhichMutexWasTaken;
    for( ;; )
    {
        /* Generate the text string – this is a fast operation. */
        vGenerateTextInALocalBuffer( cTextBuffer );
        /* Obtain the mutex that is protecting access to the display. */
        xSemaphoreTake( xMutex, portMAX_DELAY );
        /* Record the time at which the mutex was taken. */
        xTimeAtWhichMutexWasTaken = xTaskGetTickCount();
        /* Write the generated text to the display–this is a slow operation. */
        vCopyTextToFrameBuffer( cTextBuffer );
        /* The text has been written to the display, so return the mutex. */
        xSemaphoreGive( xMutex );
        /* If taskYIELD() was called on each iteration then this task would
        only ever remain in the Running state for a short period of time,
        and processing time would be wasted by rapidly switching between
        tasks. Therefore, only call taskYIELD() if the tick count changed
        while the mutex was held. */
        if( xTaskGetTickCount() != xTimeAtWhichMutexWasTaken )		//如果结束时和获取互斥量时不位于同一时间片
        {
            taskYIELD();
        }
    }
}

static uint32_t ulExampleInterruptHandler( void )
{
BaseType_t xHigherPriorityTaskWoken;
/* The xHigherPriorityTaskWoken parameter must be initialized to
pdFALSE as it will get set to pdTRUE inside the interrupt safe
API function if a context switch is required. */
xHigherPriorityTaskWoken = pdFALSE;
/* 'Give' the semaphore to unblock the task, passing in the address of
xHigherPriorityTaskWoken as the interrupt safe API function's
pxHigherPriorityTaskWoken parameter. */
xSemaphoreGiveFromISR( xBinarySemaphore, &xHigherPriorityTaskWoken );	//二进制信号量
/* Pass the xHigherPriorityTaskWoken value into portYIELD_FROM_ISR().
If xHigherPriorityTaskWoken was set to pdTRUE inside
xSemaphoreGiveFromISR() then calling portYIELD_FROM_ISR() will request
a context switch. If xHigherPriorityTaskWoken is still pdFALSE then
calling portYIELD_FROM_ISR() will have no effect. Unlike most FreeRTOS
ports, the Windows port requires the ISR to return a value - the return
statement is inside the Windows version of portYIELD_FROM_ISR(). */
portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

SemaphoreHandle_t xSemaphoreCreateBinary( void );

BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait
);

BaseType_t xSemaphoreGiveFromISR( SemaphoreHandle_t xSemaphore,
BaseType_t *pxHigherPriorityTaskWoken );

SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount,
UBaseType_t uxInitialCount );

BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t
xFunctionToPend,
void *pvParameter1,
uint32_t ulParameter2,
BaseType_t *pxHigherPriorityTaskWoken );	//在中断中向进程守护任务发送一个函数执行指令

void vPendableFunction( void *pvParameter1, uint32_t ulParameter2 );	//函数原型 既可以使用指针类型的参数 也可以使用非指针类型参数

TimerHandle_t xTimerCreate( const char * const pcTimerName,	//定时器名, 仅用于调试
const TickType_t xTimerPeriodInTicks,	//定时器时间(tick数)
const BaseType_t xAutoReload,	//是否自动重载 pdTRUE/pdFALSE
void * const pvTimerID,			//定时器ID, 可用于自定义操作, 其他api函数本身不会使用
TimerCallbackFunction_t pxCallbackFunction );	//回调函数指针

BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait );

void vTimerSetTimerID( const TimerHandle_t xTimer, void *pvNewID );

void *pvTimerGetTimerID( const TimerHandle_t xTimer );

BaseType_t xTimerChangePeriod( TimerHandle_t xTimer,
TickType_t xNewPeriod,
TickType_t xTicksToWait );

BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait );

void StartDefaultTask(void *argument)
{
  /* Infinite loop */
  for(;;)
  {
      
  }
}

BaseType_t xTaskCreate( TaskFunction_t pvTaskCode,
const char * const pcName,
configSTACK_DEPTH_TYPE usStackDepth,
void * pvParameters,
UBaseType_t uxPriority,
TaskHandle_t * pxCreatedTask );

int main( void )
{
    /*
    * Variables declared here may no longer exist after starting the FreeRTOS
    * scheduler. Do not attempt to access variables declared on the stack used
    * by main() from tasks.
    */
    /*
    * Create one of the two tasks. Note that a real application should check
    * the return value of the xTaskCreate() call to ensure the task was
    * created successfully.
    */
    xTaskCreate( vTask1, /* Pointer to the function that implements the task.*/
    "Task 1",/* Text name for the task. */
    1000, /* Stack depth in words. */
    NULL, /* This example does not use the task parameter. */
    1, /* This task will run at priority 1. */
    NULL ); /* This example does not use the task handle. */
    /* Create the other task in exactly the same way and at the same priority.*/
    xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );
    /* Start the scheduler so the tasks start executing. */
    vTaskStartScheduler();
    /*
    * If all is well main() will not reach here because the scheduler will now
    * be running the created tasks. If main() does reach here then there was
    * not enough heap memory to create either the idle or timer tasks
    * (described later in this book). Chapter 3 provides more information on
    * heap memory management.
    */
    for( ;; );
}

void vTask1( void * pvParameters )
{
    const char *pcTaskName = "Task 1 is running\r\n";
    volatile unsigned long ul; /* volatile to ensure ul is not optimized away. */
    /*
    * If this task code is executing then the scheduler must already have
    * been started. Create the other task before entering the infinite loop.
    */
    xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );
    for( ;; )
    {
        /* Print out the name of this task. */
        vPrintLine( pcTaskName );
        /* Delay for a period. */
        for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )
        {
            /*
            * This loop is just a very crude delay implementation. There is
            * nothing to do in here. Later examples will replace this crude
            * loop with a proper delay/sleep function.
            */
        }
    }
}

void vTaskFunction( void * pvParameters )
{
    char *pcTaskName;
    volatile unsigned long ul; /* volatile to ensure ul is not optimized away. */
    /*
    * The string to print out is passed in via the parameter. Cast this to a
    * character pointer.
    */
    pcTaskName = ( char * ) pvParameters;
    /* As per most tasks, this task is implemented in an infinite loop. */
    for( ;; )
    {
        /* Print out the name of this task. */
        vPrintLine( pcTaskName );
        /* Delay for a period. */
        for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )
        {
        /*
        * This loop is just a very crude delay implementation. There is
        * nothing to do in here. Later exercises will replace this crude
        * loop with a proper delay/sleep function.
        */
        }
    }
}

/*
* Define the strings that will be passed in as the task parameters. These are
* defined const and not on the stack used by main() to ensure they remain
* valid when the tasks are executing.
*/
static const char * pcTextForTask1 = "Task 1 is running";
static const char * pcTextForTask2 = "Task 2 is running";
int main( void )
{
    /*
    * Variables declared here may no longer exist after starting the FreeRTOS
    * scheduler. Do not attempt to access variables declared on the stack used
    * by main() from tasks.
    */
    /* Create one of the two tasks. */
    xTaskCreate( vTaskFunction, /* Pointer to the function that implements the task. */
    "Task 1", /* Text name for the task. This is to facilitate debugging only. */
    1000, /* Stack depth - small  microcontrollers will use much less stack than this.*/
    ( void * ) pcTextForTask1, /* Pass the text to be printed into the task using the task parameter.*/
    1, /* This task will run at priority 1.*/
    NULL ); /* The task handle is not used in this example. */
    /*
    * Create the other task in exactly the same way. Note this time that
    * multiple tasks are being created from the SAME task implementation
    * (vTaskFunction). Only the value passed in the parameter is different.
    * Two instances of the same task definition are being created.
    */
    xTaskCreate( vTaskFunction,
    "Task 2",
    1000,
    ( void * ) pcTextForTask2,
    1,
    NULL );
    /* Start the scheduler so the tasks start executing. */
    vTaskStartScheduler();
    /*
    * If all is well main() will not reach here because the scheduler will
    * now be running the created tasks. If main() does reach here then there
    * was not enough heap memory to create either the idle or timer tasks
    * (described later in this book). Chapter 3 provides more information on
    * heap memory management.
    */
    for( ;; )
    {
    }
}

void vTaskFunction( void * pvParameters )
{
    char * pcTaskName;
    const TickType_t xDelay250ms = pdMS_TO_TICKS( 250 );
    /*
    * The string to print out is passed in via the parameter. Cast this to a
    * character pointer.
    */
    pcTaskName = ( char * ) pvParameters;
    /* As per most tasks, this task is implemented in an infinite loop. */
    for( ;; )
    {
        /* Print out the name of this task. */
        vPrintLine( pcTaskName );
        /*
        * Delay for a period. This time a call to vTaskDelay() is used which
        * places the task into the Blocked state until the delay period has
        * expired. The parameter takes a time specified in 'ticks', and the
        * pdMS_TO_TICKS() macro is used (where the xDelay250ms constant is
        * declared) to convert 250 milliseconds into an equivalent time in
        * ticks.
        */
        vTaskDelay( xDelay250ms );
    }
}

void vTaskFunction( void * pvParameters )
{
    char * pcTaskName;
    TickType_t xLastWakeTime;
    /*
    * The string to print out is passed in via the parameter. Cast this to a
    * character pointer.
    */
    pcTaskName = ( char * ) pvParameters;
    /*
    * The xLastWakeTime variable needs to be initialized with the current tick
    * count. Note that this is the only time the variable is written to
    * explicitly. After this xLastWakeTime is automatically updated within
    * vTaskDelayUntil().
    */
    xLastWakeTime = xTaskGetTickCount();
    /* As per most tasks, this task is implemented in an infinite loop. */
    for( ;; )
    {
        /* Print out the name of this task. */
        vPrintLine( pcTaskName );
        /*
        * This task should execute every 250 milliseconds exactly. As per
        * the vTaskDelay() function, time is measured in ticks, and the
        * pdMS_TO_TICKS() macro is used to convert milliseconds into ticks.
        * xLastWakeTime is automatically updated within vTaskDelayUntil(), so
        * is not explicitly updated by the task.
        */
        vTaskDelayUntil( &xLastWakeTime, pdMS_TO_TICKS( 250 ) );
    }
}

void vTaskPrioritySet( TaskHandle_t xTask,
UBaseType_t uxNewPriority );

UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask );

void vApplicationIdleHook( void );