FreeRTOS任务创建和删除(动态)内部实现过程

已于 2024-04-01 10:46:00 修改
阅读量628 收藏 10
点赞数 20
文章标签： 学习 stm32 mcu
于 2024-03-29 16:22:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44219883/article/details/137113351
版权

FreeRTOS任务创建和删除(动态)内部实现过程

5ff56398-744b-4366-8c7e-80f88877231b
往深处去看代码花了好久才理解的差不多，特此记录总结下，
下面将详细探究下FreeRTOS中任务创建和删除(动态)内部实现的过程，参考正点原子B站视频：第11讲 动态任务创建和删除详细过程（函数解析）_哔哩哔哩_bilibili
在这里插入图片描述

具体来分析代码，首先来看这个函数：
在这里插入图片描述
这个函数也就是动态创建任务的函数，入口参数具体为下图这些值：

在这里插入图片描述
函数名称: xTaskCreate，返回类型: BaseType_t，通常是一个整数类型，用于表示函数执行的成功与否。在FreeRTOS中，成功创建任务通常返回pdPASS（值为1），失败则返回pdFAIL（值为0）。
从keil里面进入这个函数里面：在这里插入图片描述

TCB结构体详解

首先可以上面这些，那么来一句一句去看下这个代码作用。首先TCB_t * pxNewTCB创建了一个指向任务控制块（Task Control Block，TCB）的指针。TCB是FreeRTOS用来管理任务的结构体。我们一步一步往里面找个结构体的定义：代码如下：

typedef struct tskTaskControlBlock       /* The old naming convention is used to prevent breaking kernel aware debuggers. */
{
    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 )
    configRUN_TIME_COUNTER_TYPE ulRunTimeCounter; /*< Stores the amount of time the task has spent in the Running state. */
#endif

#if ( ( configUSE_NEWLIB_REENTRANT == 1 ) || ( configUSE_C_RUNTIME_TLS_SUPPORT == 1 ) )
    configTLS_BLOCK_TYPE xTLSBlock; /*< Memory block used as Thread Local Storage (TLS) Block for the task. */
#endif

#if ( configUSE_TASK_NOTIFICATIONS == 1 )
    volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
#endif

/* See the comments in FreeRTOS.h with the definition of
 * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */
#if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 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

#if ( configUSE_POSIX_ERRNO == 1 )
    int iTaskErrno;
#endif
} tskTCB;

volatile StackType_t * pxTopOfStack;指向任务堆栈顶部的指针。这是最后一个被放置在任务堆栈上的元素的位置。在任务切换时，这个位置用于保存或恢复任务的上下文。
xMPU_SETTINGS xMPUSettings;（条件编译）如果启用了内存保护单元（MPU）包装器（portUSING_MPU_WRAPPERS == 1），这个成员用于存储MPU的配置设置。这有助于实现任务级的内存保护。
ListItem_t xStateListItem;用于将任务链接到不同的任务列表中，这些列表表示任务的状态（就绪、阻塞、挂起等）。
ListItem_t xEventListItem;当任务因为等待某个事件（如信号量、消息队列等）而被阻塞时，这个成员用于将任务链接到相应的事件列表中。
UBaseType_t uxPriority;任务的优先级。在FreeRTOS中，数字越大表示优先级越高。
StackType_t * pxStack;指向任务堆栈开始的指针。堆栈是任务执行时用于存储局部变量、函数参数等的内存区域。
char pcTaskName[configMAX_TASK_NAME_LEN];任务的名称，仅用于调试目的。这是一个字符数组，长度由configMAX_TASK_NAME_LEN宏定义。
正点原子也对其进行了总结，具体如下图：
在这里插入图片描述
定义了任务创建函数返回值类型。
在这里插入图片描述

BaseType_t xTaskCreate()

接下来分析这一部分代码：

        #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 )
            {
                memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) );

                /* 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 * ) pvPortMallocStack( ( ( ( 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 */
        {
            StackType_t * pxStack;

            /* Allocate space for the stack used by the task being created. */
            pxStack = pvPortMallocStack( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation is the stack. */

            if( pxStack != NULL )
            {
                /* Allocate space for the TCB. */
                pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e9087 !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack, and the first member of TCB_t is always a pointer to the task's stack. */

                if( pxNewTCB != NULL )
                {
                    memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) );

                    /* 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. */
                    vPortFreeStack( pxStack );
                }
            }
            else
            {
                pxNewTCB = NULL;
            }
        }
        #endif /* portSTACK_GROWTH */

它处理任务控制块（TCB）和任务堆栈的分配。代码的行为根据portSTACK_GROWTH的定义而变化，这个宏定义指示堆栈是向上增长（正值）还是向下增长（负值）。
若是向上增长：

 pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );

上面这句代码sizeof(TCB_t):这部分计算TCB_t结构体的大小（以字节为单位）。TCB_t是FreeRTOS中定义的一个结构体类型，它包含了任务运行所需的所有状态信息，比如任务堆栈的指针、任务优先级、任务状态等。使用sizeof运算符可以确保为TCB分配足够的内存来存储这个结构体的所有成员。
pvPortMalloc(sizeof(TCB_t)):pvPortMalloc是一个内存分配函数，它根据FreeRTOS的移植（port）层定义。这个函数的行为类似于标准C库中的malloc函数，但它可能会包含一些特定于RTOS或硬件平台的优化或特性。该函数接受一个参数，即需要分配的内存大小（字节为单位），并返回一个void类型的指针，指向分配的内存。如果分配失败，它将返回NULL。在这里，pvPortMalloc被用来请求分配足够的内存以存储一个TCB_t结构体。
(TCB_t *)pvPortMalloc(sizeof(TCB_t)):由于pvPortMalloc返回一个void类型的指针，而在C语言中，void指针可以指向任何类型的数据，但使用时通常需要转换为具体类型的指针。这里将void类型的返回值转换为TCB_t*类型，这样就可以将这个指针赋值给pxNewTCB变量，后者是一个指向TCB_t类型的指针。这种类型转换是必要的，因为它告诉编译器这块内存将被用作TCB_t类型的对象。这样，当通过pxNewTCB访问TCB的成员时，编译器就能正确地解引用指针并按照TCB_t结构体的布局来访问内存。

   if( pxNewTCB != NULL )
            {
                memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) );

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

这行代码的作用是将新分配的任务控制块（Task Control Block, TCB）内存区域中的所有字节设置为0。memset函数是一个在C语言中广泛使用的标准库函数，用于将一块内存中的所有字节都设置为特定的值。在这个特定的场景中，memset被用来初始化或清零pxNewTCB指向的内存区域。这部分是将pxNewTCB指针转换为void类型。pxNewTCB是一个指向TCB_t类型的指针，而memset函数接受一个void类型的指针作为其第一个参数，这意味着它可以接受任何类型的指针。void*类型的指针是一个通用指针类型。这行代码的作用是为新创建的任务分配堆栈空间。在FreeRTOS和许多其他操作系统中，每个任务都需要有自己的堆栈（stack），这是因为堆栈用于存储函数调用时的局部变量、返回地址以及CPU寄存器等状态信息，是任务执行过程中不可或缺的部分。具体来说，这行代码执行了以下几个步骤：

  1. 计算所需堆栈空间的大小：

    • ((size_t) usStackDepth) * sizeof(StackType_t)这部分计算了所需堆栈空间的总字节数。usStackDepth表示堆栈的深度，即堆栈可以容纳的元素数量（通常是指可以存储的最大CPU寄存器或变量的数量）。sizeof(StackType_t)是堆栈中每个元素的大小（字节）。因此，整个表达式计算出整个堆栈所需的字节数。

  2. 调用pvPortMallocStack分配堆栈空间：

    • pvPortMallocStack(((size_t) usStackDepth) * sizeof(StackType_t))这部分调用了pvPortMallocStack函数，尝试分配计算出的字节数。pvPortMallocStack是一个专为堆栈分配设计的内存分配函数，可能会有针对特定架构或需求的优化。如果成功，它将返回指向分配的堆栈空间的起始地址的指针；如果失败，它将返回NULL。

  3. 将堆栈空间的起始地址存储在TCB中：

    • (StackType_t *)这部分是一个类型转换，将pvPortMallocStack函数返回的指针转换为StackType_t *类型。StackType_t通常是针对特定平台定义的一个类型，以确保堆栈的对齐和大小适合于该平台的CPU架构。
    • pxNewTCB->pxStack =这部分将分配的堆栈空间的起始地址存储在任务控制块（TCB）的pxStack成员变量中。这样，操作系统就能够在任务切换时保存和恢复任务的堆栈状态。
 if( pxNewTCB->pxStack == NULL )
 {
   /* Could not allocate the stack.  Delete the allocated TCB. */
   vPortFree( pxNewTCB );
   pxNewTCB = NULL;
 }

  1. 条件判断：

    • if( pxNewTCB->pxStack == NULL ) 这一行是一个条件判断，检查新任务的任务控制块（TCB）中的堆栈指针（pxStack）是否为 NULL。在这里，pxNewTCB 是一个指向新任务的 TCB 的指针。pxStack 是 TCB 结构体中的一个成员，指向任务的堆栈空间的起始地址。如果 pxStack 为 NULL，这意味着之前尝试为新任务分配堆栈空间失败了（可能是因为系统内存不足）。

  2. 释放已分配的 TCB：

    • vPortFree( pxNewTCB ); 如果堆栈空间分配失败，这行代码将执行。vPortFree 是一个内存释放函数，用于释放之前通过某种内存分配函数（如 pvPortMalloc）分配的内存。这里，它被用来释放之前为新任务分配的 TCB 的内存。这是必要的，因为如果我们不能为任务分配必要的堆栈空间，那么保留这个部分初始化的 TCB 是没有意义的，也可能导致内存泄漏。

  3. 将 TCB 指针设为 NULL：

    • pxNewTCB = NULL; 这行代码将 pxNewTCB 指针设为 NULL，确保之后的代码不会意外地使用到这个已经被释放的内存地址。设置为 NULL 是一个好习惯，可以帮助防止野指针错误。野指针是指向未知内存地址的指针，尝试访问野指针可能导致不可预测的行为，包括程序崩溃。
      在这里插入图片描述
      上面这幅图来自正点原子的思维导图，我们前面的程序主要干了2件事情，申请堆栈内存和申请任务控制块内存，以及将申请的堆栈内存地址赋值给控制块的堆栈成员。加下来就是调用prvInitialiseNewTask这个函数去初始化任务控制块中的成员。

prvInitialiseNewTask函数

static void prvInitialiseNewTask( TaskFunction_t pxTaskCode,
                                  const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                  const uint32_t ulStackDepth,
                                  void * const pvParameters,
                                  UBaseType_t uxPriority,
                                  TaskHandle_t * const pxCreatedTask,
                                  TCB_t * pxNewTCB,
                                  const MemoryRegion_t * const xRegions )

首先上面是该函数的入口参数，
函数 prvInitialiseNewTask 是 FreeRTOS 中用于初始化新任务的静态函数。这个函数不直接由用户代码调用，而是由 FreeRTOS 的任务创建API（如xTaskCreate或xTaskCreateStatic）内部调用。它负责设置新任务的各种属性和准备任务的执行环境。下面是对该函数参数的解释：
参数解释

  • TaskFunction_t pxTaskCode：

    • 这是一个指向任务函数的指针。任务函数是当任务启动时执行的函数，其类型TaskFunction_t通常定义为返回void且接受一个void *参数的函数指针。

  • const char * const pcName：

    • 这是指向任务名称的指针。任务名称是一个字符串，用于标识任务，主要用于调试目的。

  • const uint32_t ulStackDepth：

    • 这表示任务栈的深度，即任务栈可以容纳的最大元素数量。栈深度的单位通常是字或者栈元素的数量，具体取决于平台。

  • void * const pvParameters：

    • 这是传递给任务函数的参数。它是一个void *类型，可以指向任何类型的数据，提供了一种灵活的方式将数据从任务创建者传递给任务函数。

  • UBaseType_t uxPriority：

    • 这是任务的优先级。在FreeRTOS中，较高的数值表示较高的优先级。任务优先级决定了任务在何时被调度执行。

  • TaskHandle_t * const pxCreatedTask：

    • 这是一个指向任务句柄的指针。任务句柄用于在任务创建后引用该任务。如果创建成功，这个指针会被设置为指向任务控制块（TCB）的指针。

  • TCB_t * pxNewTCB：

    • 这是指向新任务的任务控制块（TCB）的指针。TCB是一个结构体，包含了管理任务所需的所有信息，如任务栈的指针、任务状态、优先级等。

  • const MemoryRegion_t * const xRegions：

    • 这是指向内存区域定义数组的指针。这个参数允许为任务指定特定的内存区域，这些区域可以用于任务的变量或数据存储。这是一种高级功能，通常用于需要精细控制内存使用的应用。

在 FreeRTOS 中，StackType_t * pxTopOfStack; 和 UBaseType_t x; 这两行代码通常出现在任务的初始化或创建过程中。它们各自的作用如下：
1：StackType_t * pxTopOfStack;

  • 作用：这是一个指向栈顶的指针。在任务创建时，FreeRTOS 为每个任务分配一个独立的栈空间，用于存储局部变量、函数参数、返回地址等信息。pxTopOfStack 指向这个栈的顶部位置，即最后一个被写入的位置。在不同的架构中，栈的增长方向可能不同（向上增长或向下增长），因此“栈顶”的概念也相应地有所变化。在任务切换时，FreeRTOS 会保存当前任务的pxTopOfStack值，以便之后能够恢复到正确的位置继续执行。

  • 初始化：在任务创建过程中，pxTopOfStack 会被初始化为指向分配给该任务的栈空间的某个位置。具体的初始化位置取决于栈的增长方向以及CPU架构的要求。
    在这里插入图片描述
    由于不使用MPU，所以上图代码这部分可以跳过。

    #if ( tskSET_NEW_STACKS_TO_KNOWN_VALUE == 1 )
    {
        /* Fill the stack with a known value to assist debugging. */
        ( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) );
    }

这段代码是在一个条件编译块中，用于在任务的堆栈空间被分配后，用一个已知的值填充整个堆栈。这是一种在开发过程中常用的调试技巧，它有助于开发者在调试时识别堆栈的使用情况，尤其是用于检测堆栈溢出或未初始化的堆栈访问。下面是这段代码的详细解释
堆栈初始化

{
    /* Fill the stack with a known value to assist debugging. */
    ( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) );
}

  • 注释：首先，代码中的注释说明了这个代码块的目的——“用一个已知的值填充堆栈以辅助调试”。

  • memset函数调用：memset 函数用于将一段内存区域全部填充为指定的值。这里，它被用来填充新任务的堆栈空间。

    • pxNewTCB->pxStack 是一个指向新任务堆栈空间起始地址的指针。
    • ( int ) tskSTACK_FILL_BYTE 指定了用于填充堆栈的值。tskSTACK_FILL_BYTE 是一个预定义的宏，代表一个特定的字节值。通过将堆栈填充为这个值，开发者可以在调试时更容易地识别堆栈的使用边界和溢出情况。
    • ( size_t ) ulStackDepth * sizeof( StackType_t ) 计算了整个堆栈空间的大小（以字节为单位）。ulStackDepth 是堆栈的深度（即可以容纳的元素数量），sizeof(StackType_t) 是堆栈中每个元素的大小。这个表达式的结果是需要填充的总字节数。

  • 类型转换：代码中使用了类型转换，确保传递给 memset 的参数类型正确。特别是，将 tskSTACK_FILL_BYTE 转换为 (int)，确保它以正确的类型传递给 memset。
    接下来看这一部分代码：

    #if ( portSTACK_GROWTH < 0 )
    {
        pxTopOfStack = &( pxNewTCB->pxStack[ ulStackDepth - ( uint32_t ) 1 ] );
        pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 !e9033 !e9078 MISRA exception.  Avoiding casts between pointers and integers is not practical.  Size differences accounted for using portPOINTER_SIZE_TYPE type.  Checked by assert(). */

        /* Check the alignment of the calculated top of stack is correct. */
        configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );

        #if ( configRECORD_STACK_HIGH_ADDRESS == 1 )
        {
            /* Also record the stack's high address, which may assist
             * debugging. */
            pxNewTCB->pxEndOfStack = pxTopOfStack;
        }
        #endif /* configRECORD_STACK_HIGH_ADDRESS */
    }
    #else /* portSTACK_GROWTH */
    {
        pxTopOfStack = pxNewTCB->pxStack;

        /* Check the alignment of the stack buffer is correct. */
        configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxNewTCB->pxStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );

        /* The other extreme of the stack space is required if stack checking is
         * performed. */
        pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );
    }
    #endif /* portSTACK_GROWTH */

这里先要了解俩种增长方式究竟是啥：
了解了之后就知道为啥这样计算地址了。pxTopOfStack = &( pxNewTCB->pxStack[ ulStackDepth - ( uint32_t ) 1 ] );
这个对应向下增加，所以栈顶地址应该位于堆栈最后一个元素所在的位置，所以用ulStackDepth - 1得到被设置为指向pxStack数组的最后一个元素的地址，这是因为在向下增长的栈中，栈顶是在栈数组的末端。向上增长的栈，栈顶指针在第一个元素的位置。

if( pcName != NULL )//这部分代码主要作用是任务名称保存到TCB结构体成员pctaskname上去。
    {
        for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
        {
            pxNewTCB->pcTaskName[ x ] = pcName[ x ];

            /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than
             * configMAX_TASK_NAME_LEN characters just in case the memory after the
             * string is not accessible (extremely unlikely). */
            if( pcName[ x ] == ( char ) 0x00 )
            {
                break;
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }

        /* Ensure the name string is terminated in the case that the string length
         * was greater or equal to configMAX_TASK_NAME_LEN. */
        pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';
    }

configASSERT( uxPriority < configMAX_PRIORITIES );/*这段代码来
自于FreeRTOS的任务创建或优先级设置函数中，它的主要作用是确保给定的任务优先级uxPriority在有效范围内。*/

    if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
    {
        uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }

    pxNewTCB->uxPriority = uxPriority;
    #if ( configUSE_MUTEXES == 1 )
    {
        pxNewTCB->uxBasePriority = uxPriority;
    }
    #endif /* configUSE_MUTEXES */

    vListInitialiseItem( &( pxNewTCB->xStateListItem ) );
    vListInitialiseItem( &( pxNewTCB->xEventListItem ) );
    /*这两行代码分别初始化任务的状态列表项xStateListItem和事件列表项xEventListItem。
    在FreeRTOS中，列表项（ListItem_t）是用于将多个对象（如任务）链接在一起形成列表的结构。
    这里的初始化操作通常包括设置列表项的各种成员到一个合理的初始状态，例如将其链接指针（
    用于指向列表中的下一个和上一个元素）设置为指向自己，表示该列表项尚未链接到任何列表中。*/

    /* Set the pxNewTCB as a link back from the ListItem_t.  This is so we can get
     * back to  the containing TCB from a generic item in a list. */
    listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );
    /*这两行代码为xStateListItem和xEventListItem设置所有者，即指向包含这些列表项的TCB的指针。这使得
    当我们有一个指向列表项的指针时，可以轻松地找到它所属的TCB。在FreeRTOS的列表处理函数中，
    这种反向查找机制经常被用来从列表中的项访问到完整的任务控制块。*/

    /* Event lists are always in priority order. */
    listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority );
     /*这行代码为xEventListItem设置了一个值，该值基于任务的优先级计算得出。这里的计算方式是configMAX_PRIORITIES - uxPriority，意味着优先级较高的任务会得到一个较小的值。
     在FreeRTOS中，事件列表（如延时列表、就绪列表）往往根据这个值来排序，
     以确保优先级较高的任务能够先于优先级较低的任务被选中执行。
     这种设计允许FreeRTOS的调度器以优先级为基准快速选择下一个要运行的任务。 */
    listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB );

#if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
        {
            #if ( portSTACK_GROWTH < 0 )
            {
                pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvParameters );
            }
            #else /* portSTACK_GROWTH */
            {
                pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxEndOfStack, pxTaskCode, pvParameters );
            }
            #endif /* portSTACK_GROWTH */
        }
        #else /* portHAS_STACK_OVERFLOW_CHECKING */
        {
            pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );
        }
        #endif /* portHAS_STACK_OVERFLOW_CHECKING */

我们主要看这一句代码：

pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvParameters );

该函数具体内容为以下部分：
在这里插入图片描述在这里插入图片描述
参照正点原子中视频具体要往堆栈存的值就是这些。pxNewTCB->pxTopOfStack 更新后的位置就如上图所示，具体这个函数要做的事情参考正点原子课件的思维导图可以得到：
在这里插入图片描述
这个函数里面要做的事情就是上面这些。

prvAddNewTaskToReadyList( pxNewTCB );

接下来来理解这个函数：
在这里插入图片描述

正点原子总结的要做的事情如上图所示：
具体去看代码暂时还没理解很清楚。等到日后理解了填下坑。
在这里插入图片描述

Bathwind-w
关注
  • 20
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FreeRTOS—TCB_t结构体及重要变量说明
zjy_1314的博客
06-21 1825
1、TCB_T TCB_t的全称为Task Control Block，也就是任务控制块。 typedef struct tskTaskControlBlock { // 这里栈顶指针必须位于TCB第一项是为了便于上下文切换操作，详见xPortPendSVHandler中任务切换的操作。 volatile StackType_t *pxTopOfStack; // MPU相关暂时不讨论 #
freeRTOS静态任务创建示例
m0_47462420的博客
02-14 809
随着功能安全愈发被重视，RTOS逐渐禁用动态内存，以牺牲RAM资源为代价，获得更高的稳定性。FreeRTOS V9.00及更高版本支持通过静态内存创建如任务、软件定时器、信号量等内核对象，其主要思想是不再从堆中分配内存，而是由应用软件注册静态缓冲区来创建对象。本文主要分析静态任务的创建及相关代码。使用静态内存分配创建任务主要由以下几个优点：①任务的任务控制块（TCB）和栈（STACK)可以放在指定的内存位置，内核将该控制权下方给应用软件；
FreeRTOS内核——任务与任务切换
qq_53671582的博客
04-17 2801
2. 任务 相关函数 1. xTaskCreateStatic() 2. prvInitialiseNewTask() 3. prvInitialiseTaskLists() 4. vTaskStartScheduler() 5. xPortStartScheduler() 6. prvStartFirstTask() 2.1 创建任务 2.1.1 定义任务栈 在裸机系统中，系统在运行时的全局变量、子函数调用时的局部变量、中断发生时函数的返回地址，都统统放在栈中，栈是单片机RAM中一段连续的内存空间。 但是
FreeRTOS学习记录（四）：任务、任务切换(难点)
知寒
04-23 2736
FreeRTOS学习记录（四）：任务、任务切换(难点)
FreeRTOS之TCB
zhanglianzhu_91的博客
05-07 1515
FreeRTOSMini实现了最小任务调度。现在分开介绍进程调度重要部分。进程调度的基础首先是定义任务调度的数据结构，来保存任务堆栈结构和任务状态所在状态列表，然后就是任务的优先级唯一号等。 最小Mini内核参照“FreeRTOSMini”篇，包含源码下载地址。 TCB重要信息有： 1.栈顶指针（pxTopOfStack并且告诉编译器不要优化，随时会变化），和芯片位数一致的整形指针指向任务栈顶。任务让出CPU时候要把寄存器R0-R15、程序计数器、程序状态寄存器等CPU执行上下文压到任务栈。任务被执行时候要
FreeRTOS-ARM架构、TCB结构体，调度机制
qq_52837539的博客
03-18 4204
对于ARM架构来说，主要有3部分构成：CPU，RAM，FLASH。 CPU内部主要是运算单元和寄存器单元，可以读写RAM，修改内存，也可以读取FLASH里的汇编代码。 RAM为内部存储空间，有栈的数据结构，对于地址有内存存储，可被CPU改写。 FLASH为存储代码的空间，可被CPU读取。 对于每个任务在内存总都有相应的TCB结构体包含栈顶，两个链表（雾），优先级，栈的起始 Q：在任务切换时，所有寄存器都要保留吗？ A：都要保留，但是对于硬件中断来说，只需要保存用到的寄存器即可；对于子函数来说，不需要保存子函
手把手教你FreeRTOS源码详解（二）——任务管理
weixin_46461874的博客
12-22 3218
vTaskDelay函数的本质是调用prvAddCurrentTaskToDelayedList，将任务添加至对应的延时、阻塞链表，同样，首先将任务从就绪列表中移除，移除后并所移除的就绪列表中是否还有其余就绪的任务，若剩余就绪任务数为0，则清除该列表的就绪标志位。如果阻塞时间不为最大时，首先计算出唤醒任务的时间，xConstTickCount为执行任务prvAddCurrentTaskToDelayedList的时间，xTicksToWait为延时时间，xTimeToWake为唤醒时间。
FreeRTOS任务创建和删除实验(静态方法)
06-12
在"FreeRTOS实验4-2 FreeRTOS任务创建和删除实验(静态方法)"中，我们可以期待看到以下关键知识点： 1. **静态任务创建**：首先，你需要了解如何在代码中预定义任务的堆栈空间。这通常涉及到声明一个全局数组，其...
STM32MP157 FreeRTOS实现任务创建和删除(动态方法)【支持STM32MP1系列单片机_FreeRTOS系统】
02-27
在这个项目中，我们将探讨如何在STM32MP157上实现FreeRTOS的任务创建和删除，这是一项核心的实时操作系统技能。FreeRTOS的任务创建允许开发人员定义独立的执行单元，每个单元称为一个任务，它们可以并发运行，由...
STM32H750 FreeRTOS实现任务创建和删除(静态方法)【支持STM32H7系列单片机_FreeRTOS系统】.zip
02-15
本教程将详细介绍如何在STM32H750上使用FreeRTOS实现任务的创建和删除，并且支持STM32H7系列单片机的调测和移植。 一、FreeRTOS基础 FreeRTOS是一个源码开放的实时操作系统内核，它提供了任务调度、信号量、互斥锁...
FreeRTOS任务管理_FreeRTOS任务管理_freertos_freertos任务_任务管理_野火freertos_
10-04
2. **任务创建（Task Creation）**：程序在启动时或者运行过程中可以创建新的任务。创建任务需要指定任务函数、任务优先级、任务堆栈大小以及可选参数。 3. **优先级（Priority）**：每个任务都有一个优先级，决定...
TCB数据结构
09-20
ucos 操作系统 TCB 任务控制块 数据结构
NXP i.MX RT1052实现FreeRTOS列表项的插入和删除【支持RT105X系列控制器_FreeRTOS实战】.zip
05-19
在提供的压缩包中，开发者可以找到一个示例项目，演示了如何在NXP i.MX RT1052上实现FreeRTOS任务列表的插入和删除。项目代码经过编译和测试，适用于RT105X系列控制器，这为开发者提供了一个实践平台，帮助他们更好...
FreeRTOS解析：TCB_t结构体及重要变量说明（Task-1）
Nrush的博客
10-27 8191
FreeRTOS解析：Task - 1.变量及TCB_t结构体说明 受博客限制，如果您想获得更好的阅读体验，请前往https://github.com/Nrusher/FreeRTOS-Book或者https://gitee.com/nrush/FreeRTOS-Book下载PDF版本阅读，如果您觉得本文不错也可前往star，以示对作者的鼓励。如发现问题欢迎交流。PDF阅读效果展示见：FreeR...
FreeRTOS任务创建过程详解
最新发布
m0_73931287的博客
02-25 1359
FreeRTOS中关于任务创建的详细过程的了解
FreeRTOS-实现任务调度器
热门推荐
k666499436的博客
10-04 1万+
本文正式开启对FreeRTOS内核的研究，首当其冲的就是就是任务调度器的实现，任务调度器作为FreeRTOS的核心，因为FreeRTOS的本质就是任务的轮流运行，为了循序渐进的学习，避免一口吃成一个大胖子，本文只实现两个任务的切换，先不管任务的优先级，本文的目的就是将任务切换的全过程分析的透透彻彻，在此之前要深入理解FreeRTOS链表操作，还有ARM架构的知识，我已经帮你们总结好了。《FreeRTOS-链表的源码解析》《FreeRTOS-ARM架构与程序的本质》《FreeRTOS-ARM架构深入理解》
FreeRTOS --（8）任务管理之创建任务
StephenZhou
06-30 2509
在《FreeRTOS --（7）任务管理之入门篇》文章基本分析了任务相关的轮廓后，我们知道使用什么接口来创建一个任务、怎么去开启调度器、以及根据宏配置，选择调度器的行为；接下来我们深入到 FreeRTOS 任务创建的源码来看看一个任务是怎么被创建的（某大神说过，Read The F**king Source Code ，能用代码解决的，尽量不 BB）； 1、描述任务的结构 在 FreeRTOS 中，使用TCB_t 来描述一个任务： /* * Task control block. A t..
FreeRTOS第一个任务的创建和调度详解(SVC异常)
主要分享硬件、嵌入式软件部分知识
12-07 2147
在上一篇文章中，我详细分析了FreeRTOS中上下文切换：基于Cortex-M的RTOS上下文切换详解及FreeRTOS实例但是第一个任务没有上下文，它是怎么运行的呢？如果我们没有创建任务的话，系统也有一个空闲任务用来调度，这里不对这个进行分析。首先，我们知道指向当前运行任务的TCB，所以我们先看看哪里设置了，流程如下的大概逻辑如下： 也就是说如果为空，则直接将新创建的任务赋值给，如果不为空且还没有开始任务调度，则判断当前创建任务的优先级是否比中任务的优先级高，若是则更改。接着就是任务调度了，来看看上电后
五、FreeRTOS之FreeRTOS的任务创建和删除
王同学
11-29 1335
任务的创建和删除本质就是调用FreeRTOS的API函数。
FreeRTOS_Reference_Manual_V10.0.0_中文.pdf
07-15
6. `xTaskCreate()` 和 `xTaskCreateStatic()`：它们分别用于动态和静态创建新任务，`xTaskCreateStatic()` 可以减少内存分配的开销。 7. `xTaskCreateRestricted()`：创建受限任务，这种任务有更严格的资源访问...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值