FreeRTOS消息队列笔记（自用）

已于 2024-09-20 14:06:57 修改
阅读量197 收藏
点赞数 1
文章标签： 笔记
于 2024-09-18 15:49:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c2632315459/article/details/142328027
版权

目录

xQueueCreate解析

Queue_t结构体

prvInitialiseNewQueue函数

xQueueGenericReset函数

xQueueCreate函数

xQueueSend解析

vTaskPlaceOnEventList和prvAddCurrentTaskToDelayedList函数

xQueueSend函数

xQueueReceive解析

xQueueGenericReceive函数

主要对xQueueCreate和xQueueSend以及xQueueReceive的解析，其余API不一一解析。

xQueueCreate解析

Queue_t结构体

typedef struct QueueDefinition
{
	int8_t *pcHead;					/* 队列头 */
	int8_t *pcTail;					/*< 队列尾 */
	int8_t *pcWriteTo;				/* 队列写消息时的位置 */

	union	/* 两个互斥的变量，节省内存空间 */
	{
		int8_t *pcReadFrom;			/* 用作队列时，队列项读取的位置 */
		UBaseType_t uxRecursiveCallCount;/* 递归互斥量使用，记录调用递归数 */
	} u;

	List_t xTasksWaitingToSend;		/* 存放因队列满时发送消息给队列而阻塞的任务 */
	List_t xTasksWaitingToReceive;	/* 存放因队列空时获取队列中消息而阻塞的任务 */

	volatile UBaseType_t uxMessagesWaiting;/* 队列当前的项数 */
	UBaseType_t uxLength;			/*< 队列能拥有的项数的最大值 */
	UBaseType_t uxItemSize;			/*< 每个项的大小（占多少字节） */

	volatile int8_t cRxLock;		/* 存放队列锁定时一共有多少任务想获取队列消息 */
	volatile int8_t cTxLock;		/* 存放队列锁定时一共有多少任务想发送队列消息 */
} xQUEUE;
typedef xQUEUE Queue_t;

prvInitialiseNewQueue函数

初始化新的消息队列

static void prvInitialiseNewQueue( 
const UBaseType_t uxQueueLength, //队列消息长度
const UBaseType_t uxItemSize,    //队列消息项大小
uint8_t *pucQueueStorage,        //队列存放消息的首地址
const uint8_t ucQueueType, 
Queue_t *pxNewQueue              //消息队列首地址（ 消息队列 = 消息控制块 + 消息。所有这个地址就是消息控制块首地址 ）
)
{
    ( void ) ucQueueType;   //防止编译出未使用变量警告
    if( uxItemSize == ( UBaseType_t ) 0 )
	{
		/* 没有消息长度，但不能设置成NULL，因为NULL会被认为是互斥锁 */
		pxNewQueue->pcHead = ( int8_t * ) pxNewQueue;
	}
	else	//
	{
		/* 指向消息队列的消息内存首地址 */
		pxNewQueue->pcHead = ( int8_t * ) pucQueueStorage;
	}

    /* 初始化队列长度和项大小 */
    pxNewQueue->uxLength = uxQueueLength;
	pxNewQueue->uxItemSize = uxItemSize;
    /* 初始化队列其他成员变量 */
    ( void ) xQueueGenericReset( pxNewQueue, pdTRUE );
}

xQueueGenericReset函数

将队列重新恢复到初始状态

/* 重置队列 */
BaseType_t xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue )
{
    Queue_t * const pxQueue = ( Queue_t * ) xQueue;

    taskENTER_CRITICAL();
    {
        /* 指向消息队列的尾地址 */
        pxQueue->pcTail = pxQueue->pcHead + ( pxQueue->uxLength * pxQueue->uxItemSize );
        /* 当前消息队列消息数为0 */
		pxQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;
        /* 消息写入位置为，消息第一个项首地址 */
		pxQueue->pcWriteTo = pxQueue->pcHead;
        /* 消息读取位置为，消息最后一个项的地址 */
		pxQueue->u.pcReadFrom = pxQueue->pcHead + ( ( pxQueue->uxLength - ( UBaseType_t ) 1U ) * pxQueue->uxItemSize );
		/* 都没锁 */
        pxQueue->cRxLock = queueUNLOCKED;
		pxQueue->cTxLock = queueUNLOCKED;

        if( xNewQueue == pdFALSE )//不是新创建的队列
        {
            if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )//发送消息等待队列不为空
            {
                if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
                {
                    queueYIELD_IF_USING_PREEMPTION();//调用一次pend，切换任务
                }
            }
        }
        else       //新创建的队列
		{
			/* 初始化队列 */
			vListInitialise( &( pxQueue->xTasksWaitingToSend ) );
			vListInitialise( &( pxQueue->xTasksWaitingToReceive ) );
		}
    }
}

xQueueCreate函数

创建消息队列

#define xQueueCreate( uxQueueLength, uxItemSize ) \
xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( queueQUEUE_TYPE_BASE ) )

QueueHandle_t xQueueGenericCreate( 
const UBaseType_t uxQueueLength, //队列长度
const UBaseType_t uxItemSize,   //队列项大小
const uint8_t ucQueueType       
)
{
    Queue_t *pxNewQueue;
	size_t xQueueSizeInBytes;
	uint8_t *pucQueueStorage;


    if( uxItemSize == ( UBaseType_t ) 0 )
    {
        /* 队列项大小为0，队列的消息所占字节为0 */
        xQueueSizeInBytes = ( size_t ) 0;
    }
    else
    {
        /* 计算队列消息所需要的字节数 */
        xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ); 
    }
    /* 申请队列所需的内存，大小为队列控制块大小+队列的消息所占字节然后8字节对齐后的大小 */
    pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes );

    if( pxNewQueue != NULL )
    {
        /* pucQueueStorage指向存放消息的首地址 */
        pucQueueStorage = ( ( uint8_t * ) pxNewQueue ) + sizeof( Queue_t );
        /* 初始化消息队列 */
        prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );
    }
    return pxNewQueue;
}

xQueueSend解析

发送消息给消息队列

vTaskPlaceOnEventList和prvAddCurrentTaskToDelayedList函数

vTaskPlaceOnEventList将当前任务的实践列表项加入指定列表，并且将当前任务加入阻塞列表。

void vTaskPlaceOnEventList( List_t * const pxEventList, const TickType_t xTicksToWait )
{
    vListInsert( pxEventList, &( pxCurrentTCB->xEventListItem ) );
	prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
}
static void prvAddCurrentTaskToDelayedList
( TickType_t xTicksToWait,  //阻塞时间
 const BaseType_t xCanBlockIndefinitely 
)
{
    TickType_t xTimeToWake;
    const TickType_t xConstTickCount = xTickCount;
    /* 将当前任务的任务状态列表项从当前列表删除 */
    if( uxListRemove( &( pxCurrentTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
	{
		//更新uxTopReadyPriority变量（就绪列表的最高优先级）。
        portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );
	}

    /* 阻塞时间为无限大，且xCanBlockIndefinitely不等于pdFALSE（等于pdFALSE一般表示无限期） */
    if( ( xTicksToWait == portMAX_DELAY ) && ( xCanBlockIndefinitely != pdFALSE ) )
    {
        /* 当前任务加入挂起列表而不是阻塞列表 */
        vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xStateListItem ) );
    }
    else
    {
        /* 计算任务阻塞时长 */
        xTimeToWake = xConstTickCount + xTicksToWait;
        /* 更新xItemValue值，用于对任务在列表中的排序 */
        listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );
        /* 节拍溢出，任务加入pxOverflowDelayedTaskList阻塞列表 */
        if( xTimeToWake < xConstTickCount )
        {
            /* Wake time has overflowed.  Place this item in the overflow
            list. */
            vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );
        }
        else    //未溢出
        {
            /* 正常加入pxDelayedTaskList阻塞列表 */
            vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );
            /* 任务阻塞时间比xNextTaskUnblockTime（记录着下一个任务解除阻塞的时间）小，更新 */
            if( xTimeToWake < xNextTaskUnblockTime )
            {
                xNextTaskUnblockTime = xTimeToWake;
            }
        }
    }

}

xQueueSend函数

#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) \
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )


BaseType_t xQueueGenericSend
( 
    QueueHandle_t xQueue,               //队列句柄
    const void * const pvItemToQueue,   //发送的消息地址
    TickType_t xTicksToWait,            //阻塞时间
    const BaseType_t xCopyPosition      //发送模式
)
{
    BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;
    TimeOut_t xTimeOut;
    Queue_t * const pxQueue = ( Queue_t * ) xQueue;

    for( ;; )
    {
        taskENTER_CRITICAL();
        {
            //队列长度未满或者覆盖模式
            if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
            {
                /* 将消息放入队列 */
                xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
                
                #else /* configUSE_QUEUE_SETS==0 无队列集功能 */
				{
					/* 检查是否有队列正在因为等待队列消息而排队 */
					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
					{
                        /* 将因等待队列而阻塞的最高任务优先级的任务从xTasksWaitingToReceive中删除，加入到就绪列表中 */
						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
						{
							/* 删除成功且任务优先级比当前任务高，执行一次pend任务切换 */
							queueYIELD_IF_USING_PREEMPTION();
						}
					}
					else if( xYieldRequired != pdFALSE )
					{
						/* 特例，互斥量使用 */
						queueYIELD_IF_USING_PREEMPTION();
					}
				}
				#endif /* configUSE_QUEUE_SETS */
                taskEXIT_CRITICAL();
			    return pdPASS;
            }
            else    //队列已满
            {
                if( xTicksToWait == ( TickType_t ) 0 )
                {
                    /* 无指定阻塞时间直接退出 */
                    taskEXIT_CRITICAL();
                    return errQUEUE_FULL;
                }
                else if( xEntryTimeSet == pdFALSE )
                {
                    /* 获取当前系统节拍信息 */
                    vTaskSetTimeOutState( &xTimeOut );
                    xEntryTimeSet = pdTRUE;
                }   
            }
        }
        taskEXIT_CRITICAL();

        /* 暂停所有任务 */
        vTaskSuspendAll();
        /* 锁定队列 */
        prvLockQueue( pxQueue );

        /* 检查任务超时 */
        if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
        {
            if( prvIsQueueFull( pxQueue ) != pdFALSE )//队列还是满的
            {
                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );

                prvUnlockQueue( pxQueue );

                if( xTaskResumeAll() == pdFALSE )
				{
					portYIELD_WITHIN_API();
				}
            }else
            {
                prvUnlockQueue( pxQueue );
				( void ) xTaskResumeAll();
            }
        }
        else//已超时，返回发送失败
		{
			/* The timeout has expired. */
			prvUnlockQueue( pxQueue );
			( void ) xTaskResumeAll();

			traceQUEUE_SEND_FAILED( pxQueue );
			return errQUEUE_FULL;
		}
    }
}

xQueueReceive解析

获取消息的函数，会将读取的消息删除。

xQueueGenericReceive函数

#define xQueueReceive( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )

BaseType_t xQueueGenericReceive
( 
    QueueHandle_t xQueue,//消息队列句柄
    void * const pvBuffer, //存放读取消息队列的内存的指针
    TickType_t xTicksToWait, // 最大阻塞时间 
    const BaseType_t xJustPeeking //读取后是否保留消息
)
{
    BaseType_t xEntryTimeSet = pdFALSE;
    TimeOut_t xTimeOut;
    int8_t *pcOriginalReadPosition;
    Queue_t * const pxQueue = ( Queue_t * ) xQueue;
    
    for( ;; )
    {
        taskENTER_CRITICAL();
        {
            const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;

            if( uxMessagesWaiting > ( UBaseType_t ) 0 )//队列不为空
            {
                pcOriginalReadPosition = pxQueue->u.pcReadFrom;//指向消息队列中要读取数据的内存
                prvCopyDataFromQueue( pxQueue, pvBuffer );//获取消息到pvBuffer

                if( xJustPeeking == pdFALSE )//会删除读取的消息
                {
                    pxQueue->uxMessagesWaiting = uxMessagesWaiting - 1;//消息数量减一
                    /* 因等待写入阻塞的任务列表不为空 */
                    if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
                    {
                        /* 删除发送阻塞任务中的任务，如果优先级高于当前任务，运行一次切换函数pend */
                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
                        {
                            queueYIELD_IF_USING_PREEMPTION();
                        }
                    }
                }
                else //不删除
                {
                    /* 将读取位置重新恢复 */
                    pxQueue->u.pcReadFrom = pcOriginalReadPosition;
                    /* 读取阻塞队列不为空 */
                    if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
                    {
                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
                        {
                            /* The task waiting has a higher priority than this task. */
                            queueYIELD_IF_USING_PREEMPTION();
                        }
                    }
                }
                taskEXIT_CRITICAL();
                return pdPASS;
            }
            else    //消息队列为空
            {
                if( xTicksToWait == ( TickType_t ) 0 )//阻塞时间为0,返回err
				{
					taskEXIT_CRITICAL();
					return errQUEUE_EMPTY;
				}
                else if( xEntryTimeSet == pdFALSE )//第一次循环的时候才可能进入
                {
                    vTaskSetTimeOutState( &xTimeOut );//获取系统节拍信息
					xEntryTimeSet = pdTRUE;
                }
            }
        }
        taskEXIT_CRITICAL();
        vTaskSuspendAll();  //调度器挂起
		prvLockQueue( pxQueue );//锁定队列
        if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )//判断是否时间是否超时
        {
            if( prvIsQueueEmpty( pxQueue ) != pdFALSE )//队列是否为空
            {
                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
				prvUnlockQueue( pxQueue );
                if( xTaskResumeAll() == pdFALSE )//调度器重新启动
				{
					portYIELD_WITHIN_API();
				}
            }
        }
        else//超时
		{
			prvUnlockQueue( pxQueue );//解锁
			( void ) xTaskResumeAll();//开启调度器

			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )//消息队列还是为空，返回错误
			{
				return errQUEUE_EMPTY;
			}
		}
    }
}

洛神入菜园
关注
跟着野火学FreeRTOS：第二段（队列管理）
01-23
跟着野火学FreeRTOS：第二段（队列管理）
STM32+FreeRTOS消息队列源码
05-24
在STM32上使用FreeRTOS实现消息队列是高级的编程技巧，它涉及到的任务调度、内存管理以及任务间的通信。消息队列是一种同步机制，允许一个任务向另一个任务发送数据，而无需等待接收任务的回应，从而提高了系统效率...
FreeRtos--队列
weixin_45981936的博客
11-15 886
基于 FreeRTOS 的应用程序由一组独立的任务构成——每个任务都是具有独立权限的小程序。这些独立的任务之间很可能会通过相互通信以提供有用的系统功能。FreeRTOS 中所有的通信与同步机制都是基于队列实现的。 通常情况下，队列被作为 FIFO(先进先出)使用，即数据由队列尾写入，从队列首读出。当然，由队列首写入也是可能的。 往队列写入数据是通过字节拷贝把数据复制存储到队列中；从队列读出数据使得把队列中的数据拷贝删除。 ...
freeRTOS学习笔记-消息队列原理
qq_30032639的博客
07-21 178
函数xQueueGenericSend()实现：xQueueGenericSend()原理流程图：
FreeRTOS学习第10篇--队列使用示例
weixin_44317448的博客
03-14 1018
本文目标：FreeRTOS学习第10篇–队列使用示例按照本文的描述，可以进行简单的使用队列。本文实验条件：拥有C语言基础，装有编译和集成的开发环境，比如：Keil uVision5。
FreeRTOS学习四（队列）
qq_26226375的博客
03-31 3168
在应用中，常常会遇到一个任务或者中断服务需要和另一个任务进行数据交互，也成为消息传递。在没有操作系统的时候，消息传递一般使用全局变量的方式，但如果在使用操作系统的应用中用全局变量来传递消息，就会涉及到“资源管理”的问题。FreeRTOS对此提供了一个叫做“队列”的机制来完成任务与任务，任务与中断之间的消息传递。 队列是为了任务与任务、任务与中断之间的通信而准备的。可以在任务与任务，任务与中断之间传递消息。队列中可以存储有限的，大小固定的数据项目。任务与任务、任务与中断之间要...
STM32搭载FreeRTOS实现任务+消息队列+串口通信完整项目代码[实测]
11-17
STM32F103搭载FreeRTOS系统，工程中有2个任务，任务一1秒发送一次数字至任务队列，任务二接收来自任务一和串口中断的填充数据并打印。串口采用DMA+闲时中断方式，串口接收的数据转发到队列中。工程将USART重定义到...
STM32+FreeRTOS消息队列的实现
05-24
在本实例中，我们将重点探讨如何在STM32上利用FreeRTOS的消息队列进行串口通信的实现。 消息队列是FreeRTOS中的一个重要组件，它允许任务之间以异步方式交换结构化数据。在STM32的FreeRTOS项目中，消息队列通常用于...
基于STM32的FreeRTOS串口队列通信
11-30
队列是FreeRTOS的一种核心同步机制，用于在任务之间或者任务与中断之间传递消息或数据结构。队列提供了一种线程安全的方式，避免了数据竞争和同步问题，保证了数据的一致性。在这个项目中，队列将作为串口通信数据的...
FreeRTOS消息队列
最新发布
weixin_73839327的博客
06-10 935
队列是为了任务与任务、 任务与中断之间的通信而准备的， 可以在任务与任务、 任务与中断之间传递消息， 队列中可以存储有限的、 大小固定的数据项目。任务与任务、 任务与中断之间要交流的数据保存在队列中， 叫做队列项目。队列所能保存的最大数据项目数量叫做队列的长度， 创建队列的时候会指定数据项目的大小和队列的长度。由于队列用来传递消息的， 所以也称为消息队列。
freertos学习-队列分析
weixin_71513915的博客
01-18 404
队列创建需要两个参数，第一个是该队列的成员个数，第二个参数是各个成员的大小。该队列的大小是两个参数的乘机加上该队列的头部空间之和。2，有空间则写数据，无空间返回err或者休眠（放入队列的等待列表或者是阻塞延迟）、2，有数据读数据，无数据返回err或者休眠（放入队列的等待列表或者是阻塞延迟）、计数器会计数，等到计数到等待是时间后，就会把任务从等待列表转移到就绪列表里面。当两个任务读取一个队列的时候需要进行以下步骤。3，有数据复制数据或者唤醒发送队列任务。3，有空间写数据或者唤醒接受队列任务。
FreeRTOS消息队列详解第五讲（全网最全）——队列读取消息
留小乙的博客
10-24 8939
一、消息队列读取消息 有消息入队就有出队，出队就是从队列中获取队列项（消息），FreeRTOS中出队函数如下表所示： 1、函数xQueueReceive() 此函数用于在任务中从队列中读取一条（请求）消息，读取成功以后就会将队列中的这条数据删除，此函数的本质是一个宏，真正执行的函数是xQueueGenericReceive()。此函数在读取消息的时候是采用拷贝方式的，所以用户需要提供一个数组或缓冲区来保存读取到的数据，所读取的数据长度是创建队列的时候所设定的每个队列项目的长度，函数原型如下： BaseTy
（十六）FreeRTOS队列
肥嘟嘟的左卫门
12-03 631
本文介绍队列的基本知识，详细源码分析见《FreeRTOS高级篇5---FreeRTOS队列分析》 1.FreeRTOS队列 队列是主要的任务间通讯方式。可以在任务与任务间、中断和任务间传送信息。大多数情况下，队列用于具有线程保护的FIFO（先进先出）缓冲区：新数据放在队列的后面。当然，数据也可以放在队列的前面，在下一篇讲队列API函数时，会涉及到数据的存放位置。 图1-1：读写队列 图1-1所示的队列中，最多能保存5个项目，并且假设队列永远不会满。任务A使用API函...
FreeRtos学习--7、队列
m0_46073339的博客
03-18 1072
队列是任务到任务、任务到中断、中断到任务数据交流的一种机制（消息传递），FreeRTOS基于队列， 实现了多种功能，其中包括队列集、互斥、计数型信号量、二值信号量、 递归互斥信号量，因此很有必要深入了解 FreeRTOS 的队列。
FreeRtos进阶——消息队列的操作逻辑
纵行山河万里~
05-28 412
在我们进行读写数据时采用环形缓冲区类似循环指针，会有俩个指针，一个是读指针用于指示当前队列存在的最早消息，一个是写指针用于指示当前可以写的队列的位置。这俩种情况都需要进入俩个等待队列，一个是等待读队列，一个是等待写队列。当写操作完成后，会唤醒等待读队列的任务，提示当前列表有数据了。在不同的任务之间，如果我们需要互相之间通信，使用全局变量进行通信，是一种不安全的通信的方式。为保证线程的安全，在FreeRtos使用消息队列进行读写时，如果要实现互斥访问，我们都会采取关中断的操作。
FreeRTOS的学习（七）——3.队列出队源码分析
LEOD的博客
05-22 1452
队列在FreeRTOS中起到比较重要的作用，主要用于任务之间消息的传递，取代了裸机时代中的全局变量交互功能。队列的机制实现了任务与任务、任务与中断之间的消息传递。
FreeRTOS的学习（二）——队列的介绍和操作
m0_58832575的博客
09-09 4318
FreeRTOS的学习（二）——队列的介绍和操作
FreeRTOS 队列分析
11-28 483
FreeRTOS 提供了多种任务间的通讯方式，包括： 任务通知（版本v8.2及以上版本） 队列 二进制信号量 计数信号量 互斥量 递归互斥量
freertos消息队列的优点
10-17
FreeRTOS消息队列的优点有以下几个： 1. 简单易用：FreeRTOS消息队列提供了一组简单易用的API，使得用户可以方便地创建、发送和接收消息。 2. 灵活性高：FreeRTOS消息队列可以用于多种不同的应用场景，例如任务间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值