STM32 FreeRTOS学习——任务创建

最新推荐文章于 2023-05-10 19:21:57 发布
最新推荐文章于 2023-05-10 19:21:57 发布
阅读量427 收藏 6
点赞数
分类专栏： STM32 文章标签： stm32 学习 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48848862/article/details/129583664
版权
本文详细介绍了FreeRTOS中任务的概念，包括任务函数、任务栈的定义、任务控制块的结构以及任务创建过程。同时，提到了任务的延时函数vTaskDelay，任务列表和列表项的初始化、插入和删除操作。此外，还讨论了任务的堆栈初始化和上下文切换中的寄存器保存。
摘要由CSDN通过智能技术生成

任务创建

任务概念

什么是任务

任务函数没有返回值，并且参数是指针类型(很少使用,基本可以不管)

void entry_task(void *pvParameters)
{
    /* 任务主体，无限循环且不能返回值 */
    while(1)
    {
        /* 任务主题代码 */
    }
}

任务的实现过程

定义任务栈

下面的任务分别定义的任务栈大小为:128和64,展通空间大小为1284字节和644字节

//任务堆栈大小
#define TASK1_STK_SIZE 128
StackType_t Task1Stack[TASK1_STK_SIZE];

//任务堆栈大小
#define TASK2_STK_SIZE 64
StackType_t Task2Stack[TASK2_STK_SIZE];

定义任务函数

//任务1函数
void tsak1_task(void *pvParameters)
{
    while(1)
    {
        LED1 = 0;
        vTaskDelay(500);
        LED1 = 1;
        vTaskDelay(500);
    }
}

//任务2函数
void tsak2_task(void *pvParameters)
{
    while(1)
    {
        LED2 = 0;
        vTaskDelay(1000);
        LED2 = 1;
        vTaskDelay(1000);
    }
}

vTaskDelay()为FreeRTOS提供的延时函数,在FreeRTOSConfig.h文件中进行了时钟节拍的配置,如下

//RTOS系统节拍中断的频率。即一秒中断的次数，每次中断RTOS都会进行任务调度
#define configTICK_RATE_HZ      (( TickType_t )1000)

任务控制块

人物的参数可以通过任务控制块指定

typedef struct tskTaskControlBlock             
{
    // 这里栈顶指针必须位于TCB第一项是为了便于上下文切换操作，详见xPortPendSVHandler中任务切换的操作。
    volatile StackType_t    *pxTopOfStack;   /* 栈顶指针 */ 
    // MPU相关暂时不讨论
    #if ( portUSING_MPU_WRAPPERS == 1 )
        xMPU_SETTINGS    xMPUSettings;        
    #endif
    // 表示任务状态，不同的状态会挂接在不同的状态链表下
    ListItem_t            xStateListItem;    /* 任务节点 */
    // 事件链表项，会挂接到不同事件链表下
    ListItem_t            xEventListItem;        
    // 任务优先级，数值越大优先级越高
    UBaseType_t            uxPriority;            
    // 指向堆栈起始位置，这只是单纯的一个分配空间的地址，可以用来检测堆栈是否溢出
    StackType_t            *pxStack;         /* 任务栈气质地址 */  
    // 任务名称，字符串形式
    char                pcTaskName[ configMAX_TASK_NAME_LEN ];
    // 指向栈尾，可以用来检测堆栈是否溢出
    #if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )
        StackType_t        *pxEndOfStack;        
    #endif
    // 记录临界段的嵌套层数
    #if ( portCRITICAL_NESTING_IN_TCB == 1 )
        UBaseType_t        uxCriticalNesting;    
    #endif
    // 跟踪调试用的变量
    #if ( configUSE_TRACE_FACILITY == 1 )
        UBaseType_t        uxTCBNumber;        
        UBaseType_t        uxTaskNumber;        
    #endif
    // 任务优先级被临时提高时，保存任务原本的优先级
    #if ( configUSE_MUTEXES == 1 )
        UBaseType_t        uxBasePriority;        
        UBaseType_t        uxMutexesHeld;
    #endif
    // 任务的一个标签值，可以由用户自定义它的意义，例如可以传入一个函数指针可以用来做Hook    函数调用
    #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;    
    #endif
    // 支持NEWLIB的一个变量
    #if ( configUSE_NEWLIB_REENTRANT == 1 )
        struct    _reent xNewLib_reent;
    #endif
    // 任务通知功能需要用到的变量
    #if( configUSE_TASK_NOTIFICATIONS == 1 )
        // 任务通知的值 
        volatile uint32_t ulNotifiedValue;
        // 任务通知的状态
        volatile uint8_t ucNotifyState;
    #endif
    // 用来标记这个任务的栈是不是静态分配的
    #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) 
        uint8_t    ucStaticallyAllocated;         
    #endif
    // 延时是否被打断
    #if( INCLUDE_xTaskAbortDelay == 1 )
        uint8_t ucDelayAborted;
    #endif
    // 错误标识
    #if( configUSE_POSIX_ERRNO == 1 )
        int iTaskErrno;
    #endif
} tskTCB;
typedef tskTCB TCB_t;

列表和列表项

  1. 列表

    listFIRST_LIST_INTEGRITY_CHECK_VALUE和istSECOND_LIST_INTEGRITY_CHECK_VALUE用来检查列表的完整性,默认不开启;如果要开启需要将配置文件中的宏设置为1,开启之后分别会添加一个整型变量值1和2,初始化时会写入一个特殊的值

    typedef struct xLIST
{
    listFIRST_LIST_INTEGRITY_CHECK_VALUE 
    /* 列表内有效列表项个数 */
    configLIST_VOLATILE UBaseType_t uxNumberOfItems;
    /* 记录当前列表项索引号，用于遍历列表 */
    ListItem_t * configLIST_VOLATILE pxIndex;           
    /* 列表中最后一个列表项，表示列表结束 */
    MiniListItem_t xListEnd;
    listSECOND_LIST_INTEGRITY_CHECK_VALUE
} List_t;

  2. 列表项

    listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE和listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE类似于列表中的两个参数,需要在配置文件中使能才能开启对应的功能——检查列表项完整性

    struct xLIST_ITEM
{
    listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
    /* 列表项值 */
    configLIST_VOLATILE TickType_t xItemValue;          
    /* 指向下一个列表项值 */
    struct xLIST_ITEM * configLIST_VOLATILE pxNext;     
    /* 指向上一个列表项值 */
    struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
    /* 当前列表项的拥有者 */
    void * pvOwner;                                     
    /* 当前列表项归属的列表,指向就绪列表 */
    void * configLIST_VOLATILE pvContainer; 
    listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE            
};
typedef struct xLIST_ITEM ListItem_t;

  3. 迷你列表项

    基本和列表项相似,知识功能相对精简,没有对当前列表项拥有者的记录和当前列表项的归属的列表的记录

    struct xMINI_LIST_ITEM
{
    listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE  
    /* 列表项值 */
    configLIST_VOLATILE TickType_t xItemValue;
    /* 指向下一个列表项值 */
    struct xLIST_ITEM * configLIST_VOLATILE pxNext;
    /* 指向上一个列表项值 */
    struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
    listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE 
};
typedef struct xMINI_LIST_ITEM MiniListItem_t;

列表与列表项初始化

  1. 列表初始化

    void vListInitialise( List_t * const pxList )
{
    /* 此时列表中只有一个列表项xListEnd，索引地址指向尾节点 */
    pxList->pxIndex = ( ListItem_t * ) &(pxList->xListEnd );           
    /* xListEnd列表项值初始化为portMAX_DELAY（portmacro.h中定义的宏）*/
    pxList->xListEnd.xItemValue = portMAX_DELAY;
    /* 初始化xListEnd的pxNext变量，此时指向自身 */
    pxList->xListEnd.pxNext = ( ListItem_t * ) &(pxList->xListEnd );   
    /* 初始化xListEnd的pxPrevious变量，此时指向自身 */
    pxList->xListEnd.pxPrevious = ( ListItem_t * ) &(pxList->xListEnd );
    /* 当前有效的列表项个数为0，没有算xListEnd */
    pxList->uxNumberOfItems = ( UBaseType_t ) 0U;
    /* 列表完整性检查,需要配置文件中设置有效才能启动 */
    listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList );
    listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList );
}

    列表的初始化流程如下:
    在这里插入图片描述

  2. 列表项初始化

    列表项根据实际使用情况来初始化，所以其初始化函数很短。

    void vListInitialiseItem( ListItem_t * const pxItem )
{
    /* 列表项初始化为不归属任何任务列表所有 */
    pxItem->pvContainer = NULL;
    /* 列表项完整性检查,需要配置文件中设置有效才能启动 */
    listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
    listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
}

  3. 列表项插入

    将指定列表项插入到列表中,通过vListInsert()函数完成列表项插入

    void vListInsert( List_t * const pxList,        //列表项要插入的列表
              ListItem_t * const pxNewListItem) //要插入的列表项
{    
    ListItem_t *pxIterator;
    /* 获取要插入的列表项值 */
    const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
    /* 检测列表和列表项的完整性,检测是否值被改变了 */
    listTEST_LIST_INTEGRITY( pxList );
    listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );

    /* 获取列表项的位置,就是获取列表的最末尾;如获取到的列表项值为最大时，直接插入到尾部 */
    if( xValueOfInsertion == portMAX_DELAY )
    {
        pxIterator = pxList->xListEnd.pxPrevious;
    }
    else{
        /* 从尾节点开始遍历，与下个节点的Value值进行比较，当要插入Value值大于遍历列表项Value时，就获得插入位置（按升序方式插入） */
        for( pxIterator = ( ListItem_t * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext ) 
        {
            //空循环，什么也不做
        }
    }
    /* 更新后面节点信息 （前后指针进行赋值） */
    pxNewListItem->pxNext = pxIterator->pxNext;
    pxNewListItem->pxNext->pxPrevious = pxNewListItem;
    /* 更新前面节点信息（前后指针进行赋值） */
    pxNewListItem->pxPrevious = pxIterator;
    pxIterator->pxNext = pxNewListItem;
    /* 把列表项归属于当前的列表 */
    pxNewListItem->pvContainer = ( void * ) pxList;
    /* 有效列表项数量进行累加 */
    ( pxList->uxNumberOfItems )++;
}

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  4. 列表项的末尾插入

    void vListInsertEnd( List_t * const pxList,          //列表项要插入的列表
                  ListItem_t * const pxNewListItem ) //要插入的列表项
 {
     /* 获取当前列表索引值    */
     ListItem_t * const pxIndex = pxList->pxIndex;
     /* 检测列表和列表项的完整性,检测是否值被改变了 */
     listTEST_LIST_INTEGRITY( pxList );
     listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
     /* 插入到索引值之前,先进行尾部更新 */
     pxNewListItem->pxNext = pxIndex;
     pxNewListItem->pxPrevious = pxIndex->pxPrevious;
     /* 再进行头部更新 */
     pxIndex->pxPrevious->pxNext = pxNewListItem;
     pxIndex->pxPrevious = pxNewListItem;
     /* 列表项归属于列表 */
     pxNewListItem->pvContainer = ( void * ) pxList;
     /* 更新列表项数目 */
     ( pxList->uxNumberOfItems )++;
 }

    在这里插入图片描述
    在这里插入图片描述

  5. 列表项删除

    从列表中删除指定的列表项，通过uxListRemove()函数来完成

     UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove )
 {
     /* 获取列表项所在的列表地址 */
     List_t * const pxList = ( List_t * ) pxItemToRemove->pvContainer;
     /* 将要删除的列表项的前后两个列表项进行连接 */
     pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;
     pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;
     /* Only used during decision coverage testing. */
     mtCOVERAGE_TEST_DELAY();
     /* 索引是否需要更新 */
     if( pxList->pxIndex == pxItemToRemove )
     {
         pxList->pxIndex = pxItemToRemove->pxPrevious;
     }
     else
     {
         mtCOVERAGE_TEST_MARKER();
     }
     /* 被删除列表项的成员变量pvContainer清零 */
     pxItemToRemove->pvContainer = NULL;
     /* 有效列表项数量减一 */
     ( pxList->uxNumberOfItems )--;
     /* 返回当前列表的有效列表项数量 */
     return pxList->uxNumberOfItems;
 }

  6. 列表的遍历

    List_t中的成员变量pxIndex是用来遍历列表的，FreeRTOS使用如下函数（宏）来完成列表的遍历，每调用一次这个函数，列表的pxIndex变量就会指向下一个列表项，并返回这个列表项的pvOwner变量值

    /* pxTCB用来保存pxIndex所指向的列表项的pvOwner, pxList表示要遍历的列表 */
#define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )                 \
{                                                                    \
    /* 首先获取当前列表 */
    List_t * const pxConstList = ( pxList );                         \
    /* 列表的pxIndex变量指向下一个列表项 */
    ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;     \
    /* 如果pxIndex指向了列表的xListEnd成员变量，表示到了列表末尾 */
    if( ( void * ) ( pxConstList )->pxIndex == ( void * ) &( ( pxConstList )->xListEnd ) )                                      \
    {   \
        /* 此时就跳过xListEnd,pxIndex再次指向列表头的列表项，这样就完成了一次列表遍历 */
        ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext; \
    }   \
    /* 获取当前pxIndex指向的所有者（其实就是任务控制块）*/
    ( pxTCB ) = ( pxConstList )->pxIndex->pvOwner;                    \
}

任务创建函数

任务创建由函数xTaskCreate()完成

BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
                        /* 仅能使用字符或字符串 */
                        const char * const pcName, 
                        const configSTACK_DEPTH_TYPE usStackDepth,
                        void * const pvParameters,
                        UBaseType_t uxPriority,
                        TaskHandle_t * const pxCreatedTask )

具体使用范例

//任务优先级
#define START_TASK_PRIO 1
//任务堆栈大小
#define START_STK_SIZE 128
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);

/* 任务创建 */
xTaskCreate((TaskFunction_t )start_task,            //任务函数
            (const char *   )"start_task",          //任务名称
            (uint16_t       )START_STK_SIZE,        //任务堆栈大小
            (void *         )NULL,                  //传递给任务函数的参数
            (UBaseType_t    )START_TASK_PRIO,       //任务优先级
            (TaskHandle_t * )&StartTask_Handler);   //任务句柄
vTaskStartScheduler();                              //开始任务调度

任务初始化函数分析

函数prvInitialiseNewTask()用于完成对任务的初始化

static void prvInitialiseNewTask(TaskFunction_t pxTaskCode,
                                const char * const pcName,
                                const uint32_t ulStackDepth,
                                void * const pvParameters,
                                UBaseType_t uxPriority,
                                TaskHandle_t * const pxCreatedTask,
                                TCB_t *pxNewTCB,
                                const MemoryRegion_t * const xRegions)

任务堆栈初始化函数分析

任务初始化函数中会通过pxPortInitialiseStack()对任务堆栈初始化

StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters )
{
    pxTopOfStack--;
    *pxTopOfStack = portINITIAL_XPSR; /* xPSR */
    pxTopOfStack--;
    *pxTopOfStack = ( ( StackType_t ) pxCode ) & portSTART_ADDRESS_MASK; 
    pxTopOfStack--;
    *pxTopOfStack = ( StackType_t ) prvTaskExitError; /* LR */    
    /* Save code space by skipping register initialisation. */
    pxTopOfStack -= 5; /* R12, R3, R2 and R1. */            
    *pxTopOfStack = ( StackType_t ) pvParameters; /* R0 */              
    /* A save method is being used that requires each task to maintain its
    own exec return value. */
    pxTopOfStack--;
    *pxTopOfStack = portINITIAL_EXEC_RETURN;                                
    pxTopOfStack -= 8; /* R11, R10, R9, R8, R7, R6, R5 and R4. */          
    return pxTopOfStack;
}

堆栈是用来在进行上下文切换的时候保存现场的，一般在新创建好一个堆栈以后会对其先进行初始化处理，即对Cortex-M内核的某些寄存器赋初值。这些初值就保存在任务堆栈中，保存的顺序按照：XPSR、R15(PC)、R14(LR)、R12、R3 ~ RO、R11 ~ R14。

创建任务到完成就绪列表

列表数组pxReadyTasksLists[]就是任务就绪列表，数组大小为configMAX_PRIORITIES，也就是说一个优先级一个列表，这样相同优先级的任务就使用一个列表。将一个新创建的任务添加到就绪列表中通过函数prvAddNewTaskToReadyList()来完成

static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )
{
    taskENTER_CRITICAL();
    {
        uxCurrentNumberOfTasks++;
        if( pxCurrentTCB == NULL )//正在运行任务块为NULL，表示没有任务运行
        {
            /* There are no other tasks, or all the other tasks are in
            the suspended state - make this the current task. */
            pxCurrentTCB = pxNewTCB;//将新任务的任务控制块赋值给当前运行任务块

            if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )
            {
                /* This is the first task to be created so do the preliminary
                initialisation required.  We will not recover if this call
                fails, but we will report the failure. */
                prvInitialiseTaskLists();             
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        else
        {
            /* If the scheduler is not already running, make this task the
            current task if it is the highest priority task to be created
            so far. */
            if( xSchedulerRunning == pdFALSE )
            {//新任务优先级比正在运行优先级高
                if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )
                {
                    pxCurrentTCB = pxNewTCB;    
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }

        uxTaskNumber++;//任务控制块编号 + 1

        #if ( configUSE_TRACE_FACILITY == 1 )
        {
            /* Add a counter into the TCB for tracing only. */
            pxNewTCB->uxTCBNumber = uxTaskNumber;
        }
        #endif /* configUSE_TRACE_FACILITY */
        prvAddTaskToReadyList( pxNewTCB );          

        portSETUP_TCB( pxNewTCB );
    }
    taskEXIT_CRITICAL();

    if( xSchedulerRunning != pdFALSE )
    {
        /* If the created task is of a higher priority than the current task
        then it should run now. */
        //新任务优先级比正在运行优先级高，任务切换
        if( pxCurrentTCB->uxPriority < pxNewTCB->uxPriority )
        {
            taskYIELD_IF_USING_PREEMPTION();    
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
}
山风伴明月
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32 【FreeRTOS HAL库】创建任务
吻等离子的博客
05-06 677
线程定义结构包含线程的启动信息。char *name;//任务名//函数指针指向任务函数//枚举类型的任务优先级//传递参数//堆栈大小;0是默认的堆栈大小所以通过osThreadDef相当于当定义了一个结构体变量os_thread_def_Display。
【2】STM32·FreeRTOS·任务创建和删除
最新发布
Cute758的博客
05-08 1289
动态创建任务：任务的任务控制块以及任务的栈空间所需的内存，均由 FreeRTOS 从 FreeRTOS 管理的堆中分配。静态创建任务：任务的任务控制块以及任务的栈空间所需的内存，需用户分配提供。：更新下一个任务的阻塞超时时间，以防被删除的任务就是下一个阻塞超时的任务。将设计四个任务：start_task、task1、task2、task3。将设计四个任务：start_task、task1、task2、task3。
stm32 FreeRTOS中如何创建任务
crjmail的博客
04-20 1604
#include "config.h" #include "global.h" #include "stdio.h" #include "PC.h" #include "FreeRTOS.h" #include "task.h" #include "list.h" void vLED1Task(void *pvParameters) { while(1) {
FreeRTOS（基于STM32）——任务创建
vizio.blog.csdn.net
10-28 1581
FreeRTOS笔记，任务的创建。
FreeRTOS任务创建和删除实验(动态方法)
06-12
"FreeRTOS学习笔记——FreeRTOS任务创建和删除实验(动态方法)"博客所用代码
FreeRTOS移植实验——STM32F103通用模板
03-22
在这个“FreeRTOS移植实验——STM32F103通用模板”中，我们将探讨如何将FreeRTOS移植到基于STM32F103的正点原子精英板上，以及如何利用这个模板进行后续的项目开发。 首先，FreeRTOS是一个轻量级、开源的实时操作...
STM32F750 FreeRTOS实现任务创建和删除(静态方法)【支持STM32F7系列单片机_FreeRTOS系统】.zip
02-07
本项目主要介绍如何在STM32F750上实现FreeRTOS的任务创建和删除功能，以构建高效稳定的多任务环境。 在FreeRTOS中，任务是执行特定任务的独立控制流，它们可以并发执行，由RTOS调度器根据优先级分配CPU时间。STM32...
stm32f103c8 FreeRTOS-KEY 任务切换 例程
07-13
在本例程中，我们将探讨如何在STM32F103C8上实现FreeRTOS操作系统的关键功能——任务切换。 FreeRTOS是一个实时操作系统（RTOS），适用于嵌入式系统，特别是资源有限的小型微控制器。它的主要特点包括轻量级、可...
STM32嵌入式系统开发实战指南 FreeRTOS与LwIP联合移植
01-02
本书的读者群体主要是STM32的初学者和有一定经验的开发者，他们可以通过这本书学习到如何将FreeRTOS和LwIP有效地整合到STM32项目中。对于初学者，这本书将提供一个逐步学习和实践的过程；对于有经验的开发者，书中的...
gcc编译stm32f103+freeROTS代码
08-17
在Windows环境下，开发基于STM32F103的FreeRTOS应用通常需要借助GCC编译器的变种——armgcc，这是一个专门用于ARM架构的交叉编译工具链。 首先，我们需要理解GCC编译器的基本概念。GCC（GNU Compiler Collection）...
STM32F407实现FreeRTOS任务通知模拟消息邮箱【支持STM32F40X系列单片机】
11-28
在"STM32F407实现FreeRTOS任务通知模拟消息邮箱【支持STM32F40X系列单片机】"项目中，开发者通过FreeRTOS的高级特性——任务通知（Task Notifications），模拟实现了消息邮箱（Message Queues）的功能。任务通知是一...
STM32H750 FreeRTOS实现优先级翻转【支持STM32H7系列单片机_FreeRTOS系统】.zip
02-15
在本项目中，"STM32H750 FreeRTOS实现优先级翻转"是一个针对STM32H7系列单片机的实践教程，主要目标是解决FreeRTOS中的一个常见问题——优先级翻转。优先级翻转是指在一个实时操作系统中，由于低优先级任务持有资源...
快速入门——STM32学习步骤.rar
02-23
在《快速入门——STM32学习步骤.pdf》这份资料中，可能涵盖了以上所述的各个部分，包括理论介绍、实例解析、代码示例和常见问题解答。通过系统学习这份教程，初学者可以逐步掌握STM32开发的基本技能，为后续的深入...
STM32MP157 FreeRTOS实现优先级翻转【支持STM32MP1系列单片机_FreeRTOS系统】.zip
02-27
在这个项目中，我们将重点探讨如何在STM32MP157上实现FreeRTOS，并处理一个常见的问题——优先级翻转。优先级翻转是指在一个实时系统中，由于高优先级任务等待低优先级任务释放资源，导致高优先级任务被阻塞，降低了...
stm32——freeRTOS任务的创建与删除
2302_76515999的博客
05-10 436
可以看到新增一个freertos.c文件，入口函数在这个文件中，修改&使用也在这个函数中进行。动态创建任务的堆栈由系统分配，而静态创建任务的堆栈由用户自己传递。可以理解为进程/线程，创建一个任务，就会在内存开辟一个空间。：指向任务函数的指针，任务必须实现为永不返回（即连续循环）；只需将待删除的任务句柄传入该函数，即可将该任务删除。：任务的名字，主要是用来调试，默认情况下最大长度是。任务创建成功，返回pdPASS。，则代表删除任务自身（当前正在运行的任务）。：用于返回已创建任务的句柄可以被引用。
STM32F103FreeRTOS任务创建（动态方法）
snn122的博客
08-02 600
我们在学习STM32、和51单片机的时候看到的是一个while函数一直在死循环执行着我们的函数，不可以两个while或者多个while同时跑，如果定义两个while的话会发现只有一个while函数在跑另一个不会执行，FreeRTOS的多任务创建就可以几个while同时跑。首先是任务的状态：状态分为四个状态，运行态、就绪态、阻塞态、挂起态，运行态就是任务处于运行的状态，就绪态是处于就绪的状态就是在等待运行的状态，阻塞态就是当前任务正在等待某个外部时间的完成，比如延时函数的使用就是使任务进入了阻塞态。...
2.stm32freeRTOS---创建一个任务
m0_56058618的博客
05-04 780
文章目录前言一、创建一个任务需要注意哪些？1、任务创建函数xTaskCreate2、代码分析二、动态/静态分配1· 动态分配2· 静态分配：三、删除任务四、一个函数创建两个任务总结 前言 上一次是初步接触实时系统，这次开始认真学习 一、创建一个任务需要注意哪些？ 1、任务创建函数xTaskCreate BaseType_t xTaskCreate( TaskFunction_t pxTaskCode, //任务名 const char * con
ALIENTEK STM32F103 FreeRTOS任务恢复过程详解
FreeRTOS是一种轻量级的实时操作系统，特别适合嵌入式系统，如STM32F103开发板。该教程旨在帮助开发者理解和操作FreeRTOS在实际项目中的关键功能，包括任务管理的各个方面。 首先，章节8.1要求读者具备一定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值