μC/OS-III---I笔记7---消息队列
消息队列
任务之间仅仅靠信号量进行“沟通”是不够的，信号量可以标志事件的发生，却无法传递更多的数据，在需要任务间的数据信息传递时就绪要用到消息队列，传统我们一般在前后太系统中都是通过全局变量来传递，但是在复杂的操作系统里这样的用法是很不方便管理的且堆内存的开销也是很大的对于一个轻量级的实时操作系统来说是很不合理的用法，因此在实时操作系统USOC内采用了消息队列。
消息队列的数据结构;
消息队列在系统初始化时先初始化了消息池：
OS_MsgPoolInit(p_err);其中调用OS_MsgPoolCreate将一个数组串成一个单链表方便消息队列的“舀”和“倒”。对应的舀和到就是单向链表的一些操作。
和其他信号量类似，OS_Q定义完成后就调用OSQCreate()创建消息队列。
1，创建消息队列：
************************************************************************************************************************
* CREATE A MESSAGE QUEUE
*
* Description: This function is called by your application to create a message queue. Message queues MUST be created
* before they can be used.
*
* Arguments : p_q is a pointer to the message queue
*
* p_name is a pointer to an ASCII string that will be used to name the message queue
*
* max_qty indicates the maximum size of the message queue (must be non-zero). Note that it's also not
* possible to have a size higher than the maximum number of OS_MSGs available.
*
* p_err is a pointer to a variable that will contain an error code returned by this function.
*
* OS_ERR_NONE the call was successful
* OS_ERR_CREATE_ISR can't create from an ISR
* OS_ERR_ILLEGAL_CREATE_RUN_TIME if you are trying to create the Queue after you called
* OSSafetyCriticalStart().
* OS_ERR_NAME if 'p_name' is a NULL pointer
* OS_ERR_OBJ_CREATED if the message queue has already been created
* OS_ERR_OBJ_PTR_NULL if you passed a NULL pointer for 'p_q'
* OS_ERR_Q_SIZE if the size you specified is 0
*
* Returns : none
************************************************************************************************************************
*/
void OSQCreate (OS_Q *p_q,
CPU_CHAR *p_name,
OS_MSG_QTY max_qty,
OS_ERR *p_err)
{
CPU_SR_ALLOC();
#ifdef OS_SAFETY_CRITICAL
if (p_err == (OS_ERR *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return;
}
#endif
#ifdef OS_SAFETY_CRITICAL_IEC61508
if (OSSafetyCriticalStartFlag == DEF_TRUE) {
*p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME;
return;
}
#endif
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* Not allowed to be called from an ISR */
*p_err = OS_ERR_CREATE_ISR;
return;
}
#endif
#if OS_CFG_ARG_CHK_EN > 0u
if (p_q == (OS_Q *)0) { /* Validate arguments */
*p_err = OS_ERR_OBJ_PTR_NULL;
return;
}
if (max_qty == (OS_MSG_QTY)0) { /* Cannot specify a zero size queue */
*p_err = OS_ERR_Q_SIZE;
return;
}
#endif
OS\_CRITICAL\_ENTER();
p\_q->Type = OS\_OBJ\_TYPE\_Q; /\* Mark the data structure as a message queue \*/
p\_q->NamePtr = p\_name;
OS\_MsgQInit(&p\_q->MsgQ, /\* Initialize the queue \*/
max\_qty);
OS\_PendListInit(&p\_q->PendList); /\* Initialize the waiting list \*/#if OS_CFG_DBG_EN > 0u
OS_QDbgListAdd(p_q);
#endif
OSQQty++; /* One more queue created */
OS\_CRITICAL\_EXIT\_NO\_SCHED(); *p_err = OS_ERR_NONE;
}
OSQCreate ()
创建完消息队列后，队列里的消息数为零，内存全在内存池里。
2，请求消息，此函数是一个指针函数因此在消息可用是即返回消息首地址同时传入的消息长度变量指针将消息长度传回请求任务。
请求的过程就是从消息队列按照消息队列的模式（LIFO或者FIFO）进行单链表的操作，同时完成后还要将内存放回内存池。
函数注释：
************************************************************************************************************************
* PEND ON A QUEUE FOR A MESSAGE
*
* Description: This function waits for a message to be sent to a queue
*
* Arguments : p_q is a pointer to the message queue
*
* timeout is an optional timeout period (in clock ticks). If non-zero, your task will wait for a
* message to arrive at the queue up to the amount of time specified by this argument. If you
* specify 0, however, your task will wait forever at the specified queue or, until a message
* arrives.
*
* opt determines whether the user wants to block if the queue is empty or not:
*
* OS_OPT_PEND_BLOCKING
* OS_OPT_PEND_NON_BLOCKING
*
* p_msg_size is a pointer to a variable that will receive the size of the message
*
* p_ts is a pointer to a variable that will receive the timestamp of when the message was
* received, pend aborted or the message queue deleted, If you pass a NULL pointer (i.e.
* (CPU_TS *)0) then you will not get the timestamp. In other words, passing a NULL pointer
* is valid and indicates that you don't need the timestamp.
*
* p_err is a pointer to a variable that will contain an error code returned by this function.
*
* OS_ERR_NONE The call was successful and your task received a message.
* OS_ERR_OBJ_PTR_NULL if you pass a NULL pointer for 'p_q'
* OS_ERR_OBJ_TYPE if the message queue was not created
* OS_ERR_PEND_ABORT the pend was aborted
* OS_ERR_PEND_ISR if you called this function from an ISR
* OS_ERR_PEND_WOULD_BLOCK If you specified non-blocking but the queue was not empty
* OS_ERR_SCHED_LOCKED the scheduler is locked
* OS_ERR_TIMEOUT A message was not received within the specified timeout
* would lead to a suspension.
*
* Returns : != (void *)0 is a pointer to the message received
* == (void *)0 if you received a NULL pointer message or,
* if no message was received or,
* if 'p_q' is a NULL pointer or,
* if you didn't pass a pointer to a queue.
************************************************************************************************************************
*/
void *OSQPend (OS_Q *p_q,
OS_TICK timeout,
OS_OPT opt,
OS_MSG_SIZE *p_msg_size,
CPU_TS *p_ts,
OS_ERR *p_err)
{
OS_PEND_DATA pend_data;
void *p_void;
CPU_SR_ALLOC();
#ifdef OS_SAFETY_CRITICAL
if (p_err == (OS_ERR *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((void *)0);
}
#endif
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* Not allowed to call from an ISR */
*p_err = OS_ERR_PEND_ISR;
return ((void *)0);
}
#endif
#if OS_CFG_ARG_CHK_EN > 0u
if (p_q == (OS_Q *)0) { /* Validate arguments */
*p_err = OS_ERR_OBJ_PTR_NULL;
return ((void *)0);
}
if (p_msg_size == (OS_MSG_SIZE *)0) {
*p_err = OS_ERR_PTR_INVALID;
return ((void *)0);
}
switch (opt) {
case OS_OPT_PEND_BLOCKING:
case OS_OPT_PEND_NON_BLOCKING:
break;
default:
\*p\_err = OS\_ERR\_OPT\_INVALID;
return ((void \*)0);
} #endif
#if OS_CFG_OBJ_TYPE_CHK_EN > 0u
if (p_q->Type != OS_OBJ_TYPE_Q) { /* Make sure message queue was created */
*p_err = OS_ERR_OBJ_TYPE;
return ((void *)0);
}
#endif
if (p\_ts != (CPU\_TS \*)0) {
\*p\_ts = (CPU\_TS )0; /\* Initialize the returned timestamp \*/
}
CPU\_CRITICAL\_ENTER();
//获取消息的地址
p\_void = OS\_MsgQGet(&p\_q->MsgQ, /\* Any message waiting in the message queue? \*/
p\_msg\_size,
p\_ts,
p\_err);
if (\*p\_err == OS\_ERR\_NONE) {
CPU\_CRITICAL\_EXIT();
return (p\_void); /\* Yes, Return message received \*/
}
//没有请求到消息
if ((opt & OS\_OPT\_PEND\_NON\_BLOCKING) != (OS\_OPT)0) { /\* Caller wants to block if not available? \*/
CPU\_CRITICAL\_EXIT();
\*p\_err = OS\_ERR\_PEND\_WOULD\_BLOCK; /\* No \*/
return ((void \*)0);
} else {
if (OSSchedLockNestingCtr > (OS\_NESTING\_CTR)0) { /\* Can't pend when the scheduler is locked \*/
CPU\_CRITICAL\_EXIT();
\*p\_err = OS\_ERR\_SCHED\_LOCKED;
return ((void \*)0);
}
}
/\* Lock the scheduler/re-enable interrupts \*/
OS\_CRITICAL\_ENTER\_CPU\_EXIT();
//阻塞任务并加入等待队列
OS\_Pend(&pend\_data, /\* Block task pending on Message Queue \*/
(OS\_PEND\_OBJ \*)((void \*)p\_q),
OS\_TASK\_PEND\_ON\_Q,
timeout);
OS\_CRITICAL\_EXIT\_NO\_SCHED();
OSSched(); /\* Find the next highest priority task ready to run \*/
CPU\_CRITICAL\_ENTER();
switch (OSTCBCurPtr->PendStatus) {
case OS\_STATUS\_PEND\_OK: /\* Extract message from TCB (Put there by Post) \*/
p\_void = OSTCBCurPtr->MsgPtr;
\*p\_msg\_size = OSTCBCurPtr->MsgSize;
if (p\_ts != (CPU\_TS \*)0) {
\*p\_ts = OSTCBCurPtr->TS;
}
\*p\_err = OS\_ERR\_NONE;
break;
case OS\_STATUS\_PEND\_ABORT: /\* Indicate that we aborted \*/
p\_void = (void \*)0;
\*p\_msg\_size = (OS\_MSG\_SIZE)0;
if (p\_ts != (CPU\_TS \*)0) {
\*p\_ts = OSTCBCurPtr->TS;
}
\*p\_err = OS\_ERR\_PEND\_ABORT;
break;
case OS\_STATUS\_PEND\_TIMEOUT: /\* Indicate that we didn't get event within TO \*/
p\_void = (void \*)0;
\*p\_msg\_size = (OS\_MSG\_SIZE)0;
if (p\_ts != (CPU\_TS \*)0) {
\*p\_ts = (CPU\_TS )0;
}
\*p\_err = OS\_ERR\_TIMEOUT;
break;
case OS\_STATUS\_PEND\_DEL: /\* Indicate that object pended on has been deleted \*/
p\_void = (void \*)0;
\*p\_msg\_size = (OS\_MSG\_SIZE)0;
if (p\_ts != (CPU\_TS \*)0) {
\*p\_ts = OSTCBCurPtr->TS;
}
\*p\_err = OS\_ERR\_OBJ\_DEL;
break;
default:
p\_void = (void \*)0;
\*p\_msg\_size = (OS\_MSG\_SIZE)0;
\*p\_err = OS\_ERR\_STATUS\_INVALID;
break;
}
CPU\_CRITICAL\_EXIT();
//返回消息的地址
return (p\_void); }
void *OSQPend()
************************************************************************************************************************
* RETRIEVE MESSAGE FROM MESSAGE QUEUE
*
* Description: This function retrieves a message from a message queue
*
* Arguments : p_msg_q is a pointer to the message queue where we want to extract the message from
* -------
*
* p_msg_size is a pointer to where the size (in bytes) of the message will be placed
*
* p_ts is a pointer to where the time stamp will be placed
*
* p_err is a pointer to an error code that will be returned from this call.
*
* OS_ERR_Q_EMPTY
* OS_ERR_NONE
*
* Returns : The message (a pointer)
*
* Note(s) : 1) This function is INTERNAL to uC/OS-III and your application MUST NOT call it.
************************************************************************************************************************
*/
void *OS_MsgQGet (OS_MSG_Q *p_msg_q,
OS_MSG_SIZE *p_msg_size,
CPU_TS *p_ts,
OS_ERR *p_err)
{
OS_MSG *p_msg;
void *p_void;
#ifdef OS_SAFETY_CRITICAL
if (p_err == (OS_ERR *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((void *)0);
}
#endif
//消息队列为空？
if (p_msg_q->NbrEntries == (OS_MSG_QTY)0) { /* Is the queue empty? */
*p_msg_size = (OS_MSG_SIZE)0; /* Yes */
if (p_ts != (CPU_TS *)0) {
*p_ts = (CPU_TS )0;
}
*p_err = OS_ERR_Q_EMPTY;
return ((void *)0);
}
//不为空 ，取出消息地址及大小
p_msg = p_msg_q->OutPtr; /* No, get the next message to extract from the queue */
p_void = p_msg->MsgPtr;
*p_msg_size = p_msg->MsgSize;
if (p_ts != (CPU_TS *)0) {
*p_ts = p_msg->MsgTS;
}
//修改消息队列出队地址
p_msg_q->OutPtr = p_msg->NextPtr; /* Point to next message to extract */
if (p\_msg\_q->OutPtr == (OS\_MSG \*)0) { /\* Are there any more messages in the queue? \*/
p\_msg\_q->InPtr = (OS\_MSG \*)0; /\* No \*/
p\_msg\_q->NbrEntries = (OS\_MSG\_QTY)0;
} else {
//消息队列数减一
p\_msg\_q->NbrEntries--; /\* Yes, One less message in the queue \*/
}
//倒回消息池
p\_msg->NextPtr = OSMsgPool.NextPtr; /\* Return message control block to free list \*/
OSMsgPool.NextPtr = p\_msg;
OSMsgPool.NbrFree++;
OSMsgPool.NbrUsed--;*p_err = OS_ERR_NONE;
return (p_void);
}
*OS_MsgQGet()
3，发布消息
在消息的发布过程中如果有任务在等待消息就不用调用）OS_MsgQPut()函数将消息放入消息队列而是直接传入请求任务，负责就舀一个消息的内存存放消息，并且将消息放入消息队列，在放入时根据Opt选项判断消息队列的模式然后进行但向链表的插入操作。
************************************************************************************************************************
* POST MESSAGE TO A QUEUE
*
* Description: This function sends a message to a queue. With the 'opt' argument, you can specify whether the message
* is broadcast to all waiting tasks and/or whether you post the message to the front of the queue (LIFO)
* or normally (FIFO) at the end of the queue.
*
* Arguments : p_q is a pointer to a message queue that must have been created by OSQCreate().
*
* p_void is a pointer to the message to send.
*
* msg_size specifies the size of the message (in bytes)
*
* opt determines the type of POST performed:
*
* OS_OPT_POST_ALL POST to ALL tasks that are waiting on the queue. This option
* can be added to either OS_OPT_POST_FIFO or OS_OPT_POST_LIFO
* OS_OPT_POST_FIFO POST message to end of queue (FIFO) and wake up a single
* waiting task.
* OS_OPT_POST_LIFO POST message to the front of the queue (LIFO) and wake up
* a single waiting task.
* OS_OPT_POST_NO_SCHED Do not call the scheduler
*
* Note(s): 1) OS_OPT_POST_NO_SCHED can be added (or OR'd) with one of the other options.
* 2) OS_OPT_POST_ALL can be added (or OR'd) with one of the other options.
* 3) Possible combination of options are:
*
* OS_OPT_POST_FIFO
* OS_OPT_POST_LIFO
* OS_OPT_POST_FIFO + OS_OPT_POST_ALL
* OS_OPT_POST_LIFO + OS_OPT_POST_ALL
* OS_OPT_POST_FIFO + OS_OPT_POST_NO_SCHED
* OS_OPT_POST_LIFO + OS_OPT_POST_NO_SCHED
* OS_OPT_POST_FIFO + OS_OPT_POST_ALL + OS_OPT_POST_NO_SCHED
* OS_OPT_POST_LIFO + OS_OPT_POST_ALL + OS_OPT_POST_NO_SCHED
*
* p_err is a pointer to a variable that will contain an error code returned by this function.
*
* OS_ERR_NONE The call was successful and the message was sent
* OS_ERR_MSG_POOL_EMPTY If there are no more OS_MSGs to use to place the message into
* OS_ERR_OBJ_PTR_NULL If 'p_q' is a NULL pointer
* OS_ERR_OBJ_TYPE If the message queue was not initialized
* OS_ERR_Q_MAX If the queue is full
*
* Returns : None
************************************************************************************************************************
*/
void OSQPost (OS_Q *p_q,
void *p_void,
OS_MSG_SIZE msg_size,
OS_OPT opt,
OS_ERR *p_err)
{
CPU_TS ts;
#ifdef OS_SAFETY_CRITICAL
if (p_err == (OS_ERR *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return;
}
#endif
#if OS_CFG_ARG_CHK_EN > 0u
if (p_q == (OS_Q *)0) { /* Validate 'p_q' */
*p_err = OS_ERR_OBJ_PTR_NULL;
return;
}
switch (opt) { /* Validate 'opt' */
//发布模式选择
case OS_OPT_POST_FIFO:
case OS_OPT_POST_LIFO:
case OS_OPT_POST_FIFO | OS_OPT_POST_ALL:
case OS_OPT_POST_LIFO | OS_OPT_POST_ALL:
case OS_OPT_POST_FIFO | OS_OPT_POST_NO_SCHED:
case OS_OPT_POST_LIFO | OS_OPT_POST_NO_SCHED:
case OS_OPT_POST_FIFO | OS_OPT_POST_ALL | OS_OPT_POST_NO_SCHED:
case OS_OPT_POST_LIFO | OS_OPT_POST_ALL | OS_OPT_POST_NO_SCHED:
break;
default:
\*p\_err = OS\_ERR\_OPT\_INVALID;
return;
} #endif
#if OS_CFG_OBJ_TYPE_CHK_EN > 0u
if (p_q->Type != OS_OBJ_TYPE_Q) { /* Make sure message queue was created */
*p_err = OS_ERR_OBJ_TYPE;
return;
}
#endif
ts = OS\_TS\_GET(); /\* Get timestamp \*/ //是否延迟发布？
#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
if (OSIntNestingCtr > (OS_NESTING_CTR)0) {
OS_IntQPost((OS_OBJ_TYPE)OS_OBJ_TYPE_Q, /* Post to ISR queue */
(void *)p_q,
(void *)p_void,
(OS_MSG_SIZE)msg_size,
(OS_FLAGS )0,
(OS_OPT )opt,
(CPU_TS )ts,
(OS_ERR *)p_err);
return;
}
#endif
//否，立即发布
OS_QPost(p_q,
p_void,
msg_size,
opt,
ts,
p_err);
}
OSQPost ()
void OS_QPost (OS_Q *p_q,
void *p_void,
OS_MSG_SIZE msg_size,
OS_OPT opt,
CPU_TS ts,
OS_ERR *p_err)
{
OS_OBJ_QTY cnt;
OS_OPT post_type;
OS_PEND_LIST *p_pend_list;
OS_PEND_DATA *p_pend_data;
OS_PEND_DATA *p_pend_data_next;
OS_TCB *p_tcb;
CPU_SR_ALLOC();
OS\_CRITICAL\_ENTER();
//取出等待队列
p\_pend\_list = &p\_q->PendList;
//无等待队列？
if (p\_pend\_list->NbrEntries == (OS\_OBJ\_QTY)0) { /\* Any task waiting on message queue? \*/
// 是，队列模式选择
if ((opt & OS\_OPT\_POST\_LIFO) == (OS\_OPT)0) { /\* Determine whether we post FIFO or LIFO \*/
post\_type = OS\_OPT\_POST\_FIFO;
} else {
post\_type = OS\_OPT\_POST\_LIFO;
}
//将消息放入消息对列
OS\_MsgQPut(&p\_q->MsgQ, /\* Place message in the message queue \*/
p\_void,
msg\_size,
post\_type,
ts,
p\_err);
OS\_CRITICAL\_EXIT();
return;
}
//有等待队列，选则发布给最高优先级任务还是全部发布
if ((opt & OS\_OPT\_POST\_ALL) != (OS\_OPT)0) { /\* Post message to all tasks waiting? \*/
cnt = p\_pend\_list->NbrEntries; /\* Yes \*/
} else {
cnt = (OS\_OBJ\_QTY)1; /\* No \*/
}
//取出等待队列头地址
p\_pend\_data = p\_pend\_list->HeadPtr;
while (cnt > 0u) {
p\_tcb = p\_pend\_data->TCBPtr;
p\_pend\_data\_next = p\_pend\_data->NextPtr;
//发布信号给一个任务
OS\_Post((OS\_PEND\_OBJ \*)((void \*)p\_q),
p\_tcb,
p\_void,
msg\_size,
ts);
p\_pend\_data = p\_pend\_data\_next;
cnt--;
}
OS\_CRITICAL\_EXIT\_NO\_SCHED();
if ((opt & OS\_OPT\_POST\_NO\_SCHED) == (OS\_OPT)0) {
OSSched(); /\* Run the scheduler \*/
} *p_err = OS_ERR_NONE;
}
OS_QPost()
将消息加入队列
void OS_MsgQPut (OS_MSG_Q *p_msg_q,
void *p_void,
OS_MSG_SIZE msg_size,
OS_OPT opt,
CPU_TS ts,
OS_ERR *p_err)
{
OS_MSG *p_msg;
OS_MSG *p_msg_in;
#ifdef OS_SAFETY_CRITICAL
if (p_err == (OS_ERR *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return;
}
#endif
if (p\_msg\_q->NbrEntries >= p\_msg\_q->NbrEntriesSize) {
\*p\_err = OS\_ERR\_Q\_MAX; /\* Message queue cannot accept any more messages \*/
return;
}
//消息池剩余空
if (OSMsgPool.NbrFree == (OS\_MSG\_QTY)0) {
\*p\_err = OS\_ERR\_MSG\_POOL\_EMPTY; /\* No more OS\_MSG to use \*/
return;
}
//舀
p\_msg = OSMsgPool.NextPtr; /\* Remove message control block from free list \*/
OSMsgPool.NextPtr = p\_msg->NextPtr;
OSMsgPool.NbrFree--;
OSMsgPool.NbrUsed++;
if (OSMsgPool.NbrUsedMax < OSMsgPool.NbrUsed) {
OSMsgPool.NbrUsedMax = OSMsgPool.NbrUsed;
}
//队列为空的插入
if (p\_msg\_q->NbrEntries == (OS\_MSG\_QTY)0) { /\* Is this first message placed in the queue? \*/
p\_msg\_q->InPtr = p\_msg; /\* Yes \*/
p\_msg\_q->OutPtr = p\_msg;
p\_msg\_q->NbrEntries = (OS\_MSG\_QTY)1;
p\_msg->NextPtr = (OS\_MSG \*)0;
} else { /\* No \*/
if ((opt & OS\_OPT\_POST\_LIFO) == OS\_OPT\_POST\_FIFO) { /\* Is it FIFO or LIFO? \*/
//FIFO 模式插入
p\_msg\_in = p\_msg\_q->InPtr; /\* FIFO, add to the head \*/
p\_msg\_in->NextPtr = p\_msg;
p\_msg\_q->InPtr = p\_msg;
p\_msg->NextPtr = (OS\_MSG \*)0;
} else {
//LIFO 模式插入
p\_msg->NextPtr = p\_msg\_q->OutPtr; /\* LIFO, add to the tail \*/
p\_msg\_q->OutPtr = p\_msg;
}
p\_msg\_q->NbrEntries++;
}
//跟新历史最大达用量值
if (p\_msg\_q->NbrEntriesMax < p\_msg\_q->NbrEntries) {
p\_msg\_q->NbrEntriesMax = p\_msg\_q->NbrEntries;
}
//消息放入p\_msg
p\_msg->MsgPtr = p\_void; /\* Deposit message in the message queue entry \*/
p\_msg->MsgSize = msg\_size;
p\_msg->MsgTS = ts; *p_err = OS_ERR_NONE;
}
#endif
OS_MsgQPut ()
发布消息的过程如果有任务在等待信号就不用放入消息队列,直接发给等待的任务。消息队列的数据结构组成清楚后，理解消息队列的发布过程请求等过程就显得容易很多了，其中如果消息队列的长为一字节在早期称为消息邮箱。对于所有的Pend的过程中函数内定义的Pend_data设计的非常巧妙，利用编译器自动释放内存的机制，在用完后及时的自动释放内存，从而减小了系统内核的内存开销和效率。
剩下的就是一些对消息队列进行操作的相关函数主要有：
删除消息队列
************************************************************************************************************************
* DELETE A MESSAGE QUEUE
*
* Description: This function deletes a message queue and readies all tasks pending on the queue.
*
* Arguments : p_q is a pointer to the message queue you want to delete
*
* opt determines delete options as follows:
*
* OS_OPT_DEL_NO_PEND Delete the queue ONLY if no task pending
* OS_OPT_DEL_ALWAYS Deletes the queue even if tasks are waiting.
* In this case, all the tasks pending will be readied.
*
* p_err is a pointer to a variable that will contain an error code returned by this function.
*
* OS_ERR_NONE The call was successful and the queue was deleted
* OS_ERR_DEL_ISR If you tried to delete the queue from an ISR
* OS_ERR_OBJ_PTR_NULL if you pass a NULL pointer for 'p_q'
* OS_ERR_OBJ_TYPE if the message queue was not created
* OS_ERR_OPT_INVALID An invalid option was specified
* OS_ERR_TASK_WAITING One or more tasks were waiting on the queue
*
* Returns : == 0 if no tasks were waiting on the queue, or upon error.
* > 0 if one or more tasks waiting on the queue are now readied and informed.
*
* Note(s) : 1) This function must be used with care. Tasks that would normally expect the presence of the queue MUST
* check the return code of OSQPend().
*
* 2) OSQAccept() callers will not know that the intended queue has been deleted.
*
* 3) Because ALL tasks pending on the queue will be readied, you MUST be careful in applications where the
* queue is used for mutual exclusion because the resource(s) will no longer be guarded by the queue.
************************************************************************************************************************
*/
#if OS_CFG_Q_DEL_EN > 0u
OS_OBJ_QTY OSQDel (OS_Q *p_q,
OS_OPT opt,
OS_ERR *p_err)
{
OS_OBJ_QTY cnt;
OS_OBJ_QTY nbr_tasks;
OS_PEND_DATA *p_pend_data;
OS_PEND_LIST *p_pend_list;
OS_TCB *p_tcb;
CPU_TS ts;
CPU_SR_ALLOC();
#ifdef OS_SAFETY_CRITICAL
if (p_err == (OS_ERR *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return ((OS_OBJ_QTY)0);
}
#endif
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* Can't delete a message queue from an ISR */
*p_err = OS_ERR_DEL_ISR;
return ((OS_OBJ_QTY)0);
}
#endif
#if OS_CFG_ARG_CHK_EN > 0u
if (p_q == (OS_Q *)0) { /* Validate 'p_q' */
*p_err = OS_ERR_OBJ_PTR_NULL;
return ((OS_OBJ_QTY)0u);
}
switch (opt) { /* Validate 'opt' */
case OS_OPT_DEL_NO_PEND:
case OS_OPT_DEL_ALWAYS:
break;
default:
\*p\_err = OS\_ERR\_OPT\_INVALID;
return ((OS\_OBJ\_QTY)0u);
} #endif
#if OS_CFG_OBJ_TYPE_CHK_EN > 0u
if (p_q->Type != OS_OBJ_TYPE_Q) { /* Make sure message queue was created */
*p_err = OS_ERR_OBJ_TYPE;
return ((OS_OBJ_QTY)0);
}
#endif
CPU\_CRITICAL\_ENTER();
p\_pend\_list = &p\_q->PendList;
cnt = p\_pend\_list->NbrEntries;
nbr\_tasks = cnt;
switch (opt) {
case OS\_OPT\_DEL\_NO\_PEND: /\* Delete message queue only if no task waiting \*/
if (nbr\_tasks == (OS\_OBJ\_QTY)0) { #if OS_CFG_DBG_EN > 0u
OS_QDbgListRemove(p_q);
#endif
OSQQty--;
OS_QClr(p_q);
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_NONE;
} else {
CPU_CRITICAL_EXIT();
*p_err = OS_ERR_TASK_WAITING;
}
break;
case OS\_OPT\_DEL\_ALWAYS: /\* Always delete the message queue \*/
OS\_CRITICAL\_ENTER\_CPU\_EXIT();
ts = OS\_TS\_GET(); /\* Get local time stamp so all tasks get the same time \*/
while (cnt > 0u) { /\* Remove all tasks from the pend list \*/
p\_pend\_data = p\_pend\_list->HeadPtr;
p\_tcb = p\_pend\_data->TCBPtr;
OS\_PendObjDel((OS\_PEND\_OBJ \*)((void \*)p\_q),
p\_tcb,
ts);
cnt--;
} #if OS_CFG_DBG_EN > 0u
OS_QDbgListRemove(p_q);
#endif
OSQQty--;
OS_QClr(p_q);
OS_CRITICAL_EXIT_NO_SCHED();
OSSched(); /* Find highest priority task ready to run */
*p_err = OS_ERR_NONE;
break;
default:
CPU\_CRITICAL\_EXIT();
\*p\_err = OS\_ERR\_OPT\_INVALID;
break;
}
return (nbr\_tasks); }
#endif
OSQDel ()
初始化消息池
************************************************************************************************************************
* INITIALIZE THE POOL OF 'OS_MSG'
*
* Description: This function is called by OSInit() to initialize the free list of OS_MSGs.
*
* Argument(s): p_err is a pointer to a variable that will contain an error code returned by this function.
*
* OS_ERR_MSG_POOL_NULL_PTR
* OS_ERR_MSG_POOL_EMPTY
* OS_ERR_NONE
*
* Returns : none
*
* Note(s) : 1) This function is INTERNAL to uC/OS-III and your application MUST NOT call it.
************************************************************************************************************************
*/
void OS_MsgPoolInit (OS_ERR *p_err)
{
OS_MSG *p_msg1;
OS_MSG *p_msg2;
OS_MSG_QTY i;
OS_MSG_QTY loops;
#ifdef OS_SAFETY_CRITICAL
if (p_err == (OS_ERR *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return;
}
#endif
#if OS_CFG_ARG_CHK_EN > 0u
if (OSCfg_MsgPoolBasePtr == (OS_MSG *)0) {
*p_err = OS_ERR_MSG_POOL_NULL_PTR;
return;
}
if (OSCfg_MsgPoolSize == (OS_MSG_QTY)0) {
*p_err = OS_ERR_MSG_POOL_EMPTY;
return;
}
#endif
p\_msg1 = OSCfg\_MsgPoolBasePtr;
p\_msg2 = OSCfg\_MsgPoolBasePtr;
p\_msg2++;
loops = OSCfg\_MsgPoolSize - 1u;
for (i = 0u; i < loops; i++) { /\* Init. list of free OS\_MSGs \*/
p\_msg1->NextPtr = p\_msg2;
p\_msg1->MsgPtr = (void \*)0;
p\_msg1->MsgSize = (OS\_MSG\_SIZE)0u;
p\_msg1->MsgTS = (CPU\_TS )0u;
p\_msg1++;
p\_msg2++;
}
p\_msg1->NextPtr = (OS\_MSG \*)0; /\* Last OS\_MSG \*/
p\_msg1->MsgPtr = (void \*)0;
p\_msg1->MsgSize = (OS\_MSG\_SIZE)0u;
p\_msg1->MsgTS = (CPU\_TS )0u;
OSMsgPool.NextPtr = OSCfg\_MsgPoolBasePtr;
OSMsgPool.NbrFree = OSCfg\_MsgPoolSize;
OSMsgPool.NbrUsed = (OS\_MSG\_QTY)0;
OSMsgPool.NbrUsedMax = (OS\_MSG\_QTY)0; *p_err = OS_ERR_NONE;
}
OS_MsgPoolInit ()
还有的其他操作函数就是和信号量相似的操作函数了。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章