在了解了基本的环境和框架之后，对FreeRTOS 的任务，消息队列，信号量，事件，软件定时器这些基础的功能部分也得有个认识。 这篇文章主要介绍了一下关于任务的API以及源码的简单分析。 

/*********************** Thread Management *****************************//*** @brief  Create a thread and add it to Active Threads and set it to state READY.* @param  thread_def    thread definition referenced with \ref osThread.* @param  argument      pointer that is passed to the thread function as start argument.* @retval thread ID for reference by other functions or NULL in case of error.* @note   MUST REMAIN UNCHANGED: \b osThreadCreate shall be consistent in every CMSIS-RTOS.*/osThreadId osThreadCreate (const osThreadDef_t *thread_def, void *argument){  TaskHandle_t handle;  #if( configSUPPORT_STATIC_ALLOCATION == 1 ) &&  ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )  if((thread_def->buffer != NULL) && (thread_def->controlblock != NULL)) {    handle = xTaskCreateStatic((TaskFunction_t)thread_def->pthread,(const portCHAR *)thread_def->name,              thread_def->stacksize, argument, makeFreeRtosPriority(thread_def->tpriority),              thread_def->buffer, thread_def->controlblock);  }  else {    if (xTaskCreate((TaskFunction_t)thread_def->pthread,(const portCHAR *)thread_def->name,              thread_def->stacksize, argument, makeFreeRtosPriority(thread_def->tpriority),              &handle) != pdPASS)  {      return NULL;    }   }#elif( configSUPPORT_STATIC_ALLOCATION == 1 )
    handle = xTaskCreateStatic((TaskFunction_t)thread_def->pthread,(const portCHAR *)thread_def->name,              thread_def->stacksize, argument, makeFreeRtosPriority(thread_def->tpriority),              thread_def->buffer, thread_def->controlblock);#else  if (xTaskCreate((TaskFunction_t)thread_def->pthread,(const portCHAR *)thread_def->name,                   thread_def->stacksize, argument, makeFreeRtosPriority(thread_def->tpriority),                   &handle) != pdPASS)  {    return NULL;  }     #endif    return handle;}

osStatus osThreadTerminate (osThreadId thread_id){#if (INCLUDE_vTaskDelete == 1)  vTaskDelete(thread_id);  return osOK;#else  return osErrorOS;#endif}

//osStatus osThreadSuspend (osThreadId thread_id){#if (INCLUDE_vTaskSuspend == 1)    vTaskSuspend(thread_id);    return osOK;#else  return osErrorResource;#endif}

osStatus osThreadSuspendAll (void){  vTaskSuspendAll();    return osOK;}

osStatus osThreadResume (osThreadId thread_id){#if (INCLUDE_vTaskSuspend == 1)    if(inHandlerMode())  {    if (xTaskResumeFromISR(thread_id) == pdTRUE)    {      portYIELD_FROM_ISR(pdTRUE);    }  }  else  {    vTaskResume(thread_id);  }  return osOK;#else  return osErrorResource;#endif}

osStatus osThreadResumeAll (void){  if (xTaskResumeAll() == pdTRUE)    return osOK;  else    return osErrorOS;  }

osPriority osThreadGetPriority (osThreadId thread_id){#if (INCLUDE_uxTaskPriorityGet == 1)  if (inHandlerMode())  {    return makeCmsisPriority(uxTaskPriorityGetFromISR(thread_id));    }  else  {      return makeCmsisPriority(uxTaskPriorityGet(thread_id));  }#else  return osPriorityError;#endif}

osStatus osThreadSetPriority (osThreadId thread_id, osPriority priority){#if (INCLUDE_vTaskPrioritySet == 1)  vTaskPrioritySet(thread_id, makeFreeRtosPriority(priority));  return osOK;#else  return osErrorOS;#endif}

/*********************** Generic Wait Functions *******************************//*** @brief   Wait for Timeout (Time Delay)* @param   millisec      time delay value* @retval  status code that indicates the execution status of the function.*/osStatus osDelay (uint32_t millisec){#if INCLUDE_vTaskDelay  TickType_t ticks = millisec / portTICK_PERIOD_MS;    vTaskDelay(ticks ? ticks : 1);          /* Minimum delay = 1 tick */    return osOK;#else  (void) millisec;    return osErrorResource;#endif}

/*** @brief  Delay a task until a specified time* @param   PreviousWakeTime   Pointer to a variable that holds the time at which the *          task was last unblocked. PreviousWakeTime must be initialised with the current time*          prior to its first use (PreviousWakeTime = osKernelSysTick() )* @param   millisec    time delay value* @retval  status code that indicates the execution status of the function.*/osStatus osDelayUntil (uint32_t *PreviousWakeTime, uint32_t millisec){#if INCLUDE_vTaskDelayUntil  TickType_t ticks = (millisec / portTICK_PERIOD_MS);  vTaskDelayUntil((TickType_t *) PreviousWakeTime, ticks ? ticks : 1);    return osOK;#else  (void) millisec;  (void) PreviousWakeTime;    return osErrorResource;#endif}

/* * Task control block.  A task control block (TCB) is allocated for each task, * and stores task state information, including a pointer to the task's context * (the task's run time environment, including register values) */typedef struct tskTaskControlBlock{  volatile StackType_t  *pxTopOfStack;  /*< Points to the location of the last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */
  #if ( portUSING_MPU_WRAPPERS == 1 )    xMPU_SETTINGS  xMPUSettings;    /*< The MPU settings are defined as part of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */  #endif
  ListItem_t      xStateListItem;  /*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */  ListItem_t      xEventListItem;    /*< Used to reference a task from an event list. */  UBaseType_t      uxPriority;      /*< The priority of the task.  0 is the lowest priority. */  StackType_t      *pxStack;      /*< Points to the start of the stack. */  char        pcTaskName[ configMAX_TASK_NAME_LEN ];/*< Descriptive name given to the task when created.  Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
  #if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )    StackType_t    *pxEndOfStack;    /*< Points to the highest valid address for the stack. */  #endif
  #if ( portCRITICAL_NESTING_IN_TCB == 1 )    UBaseType_t    uxCriticalNesting;  /*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */  #endif
  #if ( configUSE_TRACE_FACILITY == 1 )    UBaseType_t    uxTCBNumber;    /*< Stores a number that increments each time a TCB is created.  It allows debuggers to determine when a task has been deleted and then recreated. */    UBaseType_t    uxTaskNumber;    /*< Stores a number specifically for use by third party trace code. */  #endif
  #if ( configUSE_MUTEXES == 1 )    UBaseType_t    uxBasePriority;    /*< The priority last assigned to the task - used by the priority inheritance mechanism. */    UBaseType_t    uxMutexesHeld;  #endif
  #if ( configUSE_APPLICATION_TASK_TAG == 1 )    TaskHookFunction_t pxTaskTag;  #endif
  #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )    void      *pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];  #endif
  #if( configGENERATE_RUN_TIME_STATS == 1 )    uint32_t    ulRunTimeCounter;  /*< Stores the amount of time the task has spent in the Running state. */  #endif
  #if ( configUSE_NEWLIB_REENTRANT == 1 )    /* Allocate a Newlib reent structure that is specific to this task.    Note Newlib support has been included by popular demand, but is not    used by the FreeRTOS maintainers themselves.  FreeRTOS is not    responsible for resulting newlib operation.  User must be familiar with    newlib and must provide system-wide implementations of the necessary    stubs. Be warned that (at the time of writing) the current newlib design    implements a system-wide malloc() that must be provided with locks. */    struct  _reent xNewLib_reent;  #endif
  #if( configUSE_TASK_NOTIFICATIONS == 1 )    volatile uint32_t ulNotifiedValue;    volatile uint8_t ucNotifyState;  #endif
  /* See the comments above the definition of  tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */  #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 Macro has been consolidated for readability reasons. */    uint8_t  ucStaticallyAllocated;     /*< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */  #endif
  #if( INCLUDE_xTaskAbortDelay == 1 )    uint8_t ucDelayAborted;  #endif
} tskTCB;
/* The old tskTCB name is maintained above then typedefed to the new TCB_t namebelow to enable the use of older kernel aware debuggers. */typedef tskTCB TCB_t;

#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
  BaseType_t xTaskCreate(  TaskFunction_t pxTaskCode,              const char * const pcName,    /*lint !e971 Unqualified char types are allowed for strings and single characters only. */              const configSTACK_DEPTH_TYPE usStackDepth,              void * const pvParameters,              UBaseType_t uxPriority,              TaskHandle_t * const pxCreatedTask )  {  TCB_t *pxNewTCB;  BaseType_t xReturn;
    /* If the stack grows down then allocate the stack then the TCB so the stack    does not grow into the TCB.  Likewise if the stack grows up then allocate    the TCB then the stack.     根据自己的硬件平台堆栈增长方式来判断使用那一部分编译，    堆栈增长方式：    1、满减栈    2、满增栈    3、空减栈    4、空增栈    #define portSTACK_GROWTH      ( -1 )    表示满减栈    */    #if( portSTACK_GROWTH > 0 )    {      /* Allocate space for the TCB.  Where the memory comes from depends on      the implementation of the port malloc function and whether or not static      allocation is being used.      任务栈内存分配       */      pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );
      if( pxNewTCB != NULL )      {        /* Allocate space for the stack used by the task being created.        The base of the stack memory stored in the TCB so the task can        be deleted later if required.         任务控制块内存分配        */        pxNewTCB->pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
        if( pxNewTCB->pxStack == NULL )        {          /* Could not allocate the stack.  Delete the allocated TCB. */          vPortFree( pxNewTCB );          pxNewTCB = NULL;        }      }    }    #else     /* portSTACK_GROWTH */    /*    M3，M4中使用的下面这种        #define portSTACK_TYPE  uint32_t    typedef portSTACK_TYPE StackType_t;        每个内存是4个字节（StackType_t），所以创建堆栈是按照字来分配的    默认的是128 x 4 = 512字节；        */    {    StackType_t *pxStack;
      /* Allocate space for the stack used by the task being created. */      pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
      if( pxStack != NULL )      {        /*         Allocate space for the TCB.        根据TCB的大小还得分配空间         */        pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e961 MISRA exception as the casts are only redundant for some paths. */
        if( pxNewTCB != NULL )        {          /* Store the stack location in the TCB.          赋值栈地址           */          pxNewTCB->pxStack = pxStack;        }        else        {          /* The stack cannot be used as the TCB was not created.  Free          it again.           释放栈空间          */          vPortFree( pxStack );        }      }      else      {        pxNewTCB = NULL;      }    }    #endif /* portSTACK_GROWTH */
    if( pxNewTCB != NULL )    {      #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 Macro has been consolidated for readability reasons. */      {        /* Tasks can be created statically or dynamically, so note this        task was created dynamically in case it is later deleted. */        pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;      }      #endif /* configSUPPORT_STATIC_ALLOCATION */      /*      新建任务初始化      初始化任务控制块      初始化任务堆栈      */      prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );      /*      把任务添加到就绪列表中      */      prvAddNewTaskToReadyList( pxNewTCB );      xReturn = pdPASS;    }    else    {      xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;    }
    return xReturn;  }
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

/*-----------------------------------------------------------*/
portFORCE_INLINE static void vPortRaiseBASEPRI( void ){uint32_t ulNewBASEPRI;
  __asm volatile  (    "  mov %0, %1                        \n" \    "  msr basepri, %0                      \n" \    "  isb                            \n" \    "  dsb                            \n" \    :"=r" (ulNewBASEPRI) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"  );}

*-----------------------------------------------------------*/
portFORCE_INLINE static void vPortSetBASEPRI( uint32_t ulNewMaskValue ){  __asm volatile  (    "  msr basepri, %0  " :: "r" ( ulNewMaskValue ) : "memory"  );}

#if ( INCLUDE_vTaskDelete == 1 )
  void vTaskDelete( TaskHandle_t xTaskToDelete )  {  TCB_t *pxTCB;    /*    进入临界段    */    taskENTER_CRITICAL();    {      /* If null is passed in here then it is the calling task that is      being deleted.       获取任务控制块 -----参数传入的是任务句柄      判断是任务本身，还是其他任务      */      pxTCB = prvGetTCBFromHandle( xTaskToDelete );
      /*       Remove task from the ready list.       从就绪列表中移除      */      if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )      {        taskRESET_READY_PRIORITY( pxTCB->uxPriority );      }      else      {        mtCOVERAGE_TEST_MARKER();      }
      /*       Is the task waiting on an event also?       从事件列表中移除      */      if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )      {        ( void ) uxListRemove( &( pxTCB->xEventListItem ) );      }      else      {        mtCOVERAGE_TEST_MARKER();      }
      /* Increment the uxTaskNumber also so kernel aware debuggers can      detect that the task lists need re-generating.  This is done before      portPRE_TASK_DELETE_HOOK() as in the Windows port that macro will      not return. */      uxTaskNumber++;      /*      如果是删除当前任务      */      if( pxTCB == pxCurrentTCB )      {        /* A task is deleting itself.  This cannot complete within the        task itself, as a context switch to another task is required.        Place the task in the termination list.  The idle task will        check the termination list and free up any memory allocated by        the scheduler for the TCB and stack of the deleted task.        删除任务本身不能立即删除，在空闲任务中删除        就把任务添加到等待删除的任务列表中         */        vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xStateListItem ) );
        /* Increment the ucTasksDeleted variable so the idle task knows        there is a task that has been deleted and that it should therefore        check the xTasksWaitingTermination list.         给空间任务一个标记        */        ++uxDeletedTasksWaitingCleanUp;
        /* The pre-delete hook is primarily for the Windows simulator,        in which Windows specific clean up operations are performed,        after which it is not possible to yield away from this task -        hence xYieldPending is used to latch that a context switch is        required.        钩子函数----用户自己实现         */        portPRE_TASK_DELETE_HOOK( pxTCB, &xYieldPending );      }      else      {        --uxCurrentNumberOfTasks;        prvDeleteTCB( pxTCB );
        /* Reset the next expected unblock time in case it referred to        the task that has just been deleted.         复位任务锁定时间 ----时间片 操作系统会记录一个最新的时间，        根据最新的时间，进行调度，所以删除任务后，要更新锁定时间        */        prvResetNextTaskUnblockTime();      }            traceTASK_DELETE( pxTCB );    }    /*退出临界段*/    taskEXIT_CRITICAL();
    /* Force a reschedule if it is the currently running task that has just been deleted.     判断调度器是否开启    */    if( xSchedulerRunning != pdFALSE )    {      /*      如果是删除任务本身，马上进行任务调度（释放CPU的使用权）      */      if( pxTCB == pxCurrentTCB )      {        configASSERT( uxSchedulerSuspended == 0 );        portYIELD_WITHIN_API();      }      else      {        mtCOVERAGE_TEST_MARKER();      }    }  }
#endif /* INCLUDE_vTaskDelete */

#if ( INCLUDE_vTaskSuspend == 1 )
  void vTaskSuspend( TaskHandle_t xTaskToSuspend )  {  TCB_t *pxTCB;    /*    进入临界段    */    taskENTER_CRITICAL();    {      /* If null is passed in here then it is the running task that is      being suspended.       获取任务控制块      */      pxTCB = prvGetTCBFromHandle( xTaskToSuspend );
      traceTASK_SUSPEND( pxTCB );
      /* Remove task from the ready/delayed list and place in the      suspended list.       从就绪列表中删除      */      if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )      {        taskRESET_READY_PRIORITY( pxTCB->uxPriority );      }      else      {        mtCOVERAGE_TEST_MARKER();      }
      /* Is the task waiting on an event also?       从事件列表中移除      */      if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )      {        ( void ) uxListRemove( &( pxTCB->xEventListItem ) );      }      else      {        mtCOVERAGE_TEST_MARKER();      }      /*      把任务添加到挂起列表中      */      vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) );
      #if( configUSE_TASK_NOTIFICATIONS == 1 )      {        if( pxTCB->ucNotifyState == taskWAITING_NOTIFICATION )        {          /* The task was blocked to wait for a notification, but is          now suspended, so no notification was received. */          pxTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;        }      }      #endif    }    /*    退出临界段    */    taskEXIT_CRITICAL();    /*    判断调度器是否开始    看看是否有更高优先级的任务    */    if( xSchedulerRunning != pdFALSE )    {      /* Reset the next expected unblock time in case it referred to the      task that is now in the Suspended state. */      taskENTER_CRITICAL();      {        prvResetNextTaskUnblockTime();      }      taskEXIT_CRITICAL();    }    else    {      mtCOVERAGE_TEST_MARKER();    }
    if( pxTCB == pxCurrentTCB )    {      if( xSchedulerRunning != pdFALSE )      {        /* The current task has just been suspended.         直接进行任务调度，释放CPU        */        configASSERT( uxSchedulerSuspended == 0 );        portYIELD_WITHIN_API();      }      else      {        /* The scheduler is not running, but the task that was pointed        to by pxCurrentTCB has just been suspended and pxCurrentTCB        must be adjusted to point to a different task.         调度器没有开启，pxCurrentTCB必须指向另外一个不同的task        因为这个任务被挂起了        */        if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks )        {          /* No other tasks are ready, so set pxCurrentTCB back to          NULL so when the next task is created pxCurrentTCB will          be set to point to it no matter what its relative priority          is.           没有任务准备，把当前的任务控制块复制为NULL          */          pxCurrentTCB = NULL;        }        else        {          /*手动进行调度，在就绪列表中找到优先级最高的任务*/          vTaskSwitchContext();        }      }    }    else    {      mtCOVERAGE_TEST_MARKER();    }  }
#endif /* INCLUDE_vTaskSuspend */

#if ( INCLUDE_vTaskSuspend == 1 )
  void vTaskResume( TaskHandle_t xTaskToResume )  {  /*获取要恢复的任务控制块*/  TCB_t * const pxTCB = ( TCB_t * ) xTaskToResume;
    /* It does not make sense to resume the calling task.     检查*/    configASSERT( xTaskToResume );
    /* The parameter cannot be NULL as it is impossible to resume the    currently executing task.     恢复的话不能是NULL或当前的任务 */    if( ( pxTCB != NULL ) && ( pxTCB != pxCurrentTCB ) )    {      /*进入临界段*/      taskENTER_CRITICAL();      {        /*判断任务是否已经挂起*/        if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )        {          traceTASK_RESUME( pxTCB );
          /* The ready list can be accessed even if the scheduler is          suspended because this is inside a critical section.           从挂起列表中移除          */          ( void ) uxListRemove(  &( pxTCB->xStateListItem ) );          /*添加到就绪列表*/          prvAddTaskToReadyList( pxTCB );
          /* A higher priority task may have just been resumed.           判断要恢复的任务优先级是否大于当前任务的优先级，          如果大于，释放CPU使用权，开始内核调度          */          if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )          {            /* This yield may not cause the task just resumed to run,            but will leave the lists in the correct state for the            next yield. */            taskYIELD_IF_USING_PREEMPTION();          }          else          {            mtCOVERAGE_TEST_MARKER();          }        }        else        {          mtCOVERAGE_TEST_MARKER();        }      }      /*退出临界段*/      taskEXIT_CRITICAL();    }    else    {      mtCOVERAGE_TEST_MARKER();    }  }
#endif /* INCLUDE_vTaskSuspend */