JN5169 zigbee3.0协议栈----消息队列

127 阅读 0 评论 84 点赞

我是靠谱客的博主自觉曲奇，这篇文章主要介绍JN5169 zigbee3.0协议栈----消息队列，现在分享给大家，希望可以做个参考。

消息队列

节点上的应用程序任务之间的通信是通过消息队列实现的。应用程序可以为特定的通信通道创建专用的消息队列
在zigbee协议栈中关于队列相关相关函数如下和队列加入消息和读取消息流程图

复制代码

1
2
3
4
5
6
7
PUBLIC void ZQ_vQueueCreate (tszQueue *psQueueHandle, const uint32 uiQueueLength, const uint32 uiItemSize, uint8* pu8StartQueue);
PUBLIC bool_t ZQ_bQueueSend(void *pvQueueHandle, const void *pvItemToQueue);
PUBLIC bool_t ZQ_bQueueReceive(void *pvQueueHandle, void *pvItemFromQueue);
PUBLIC bool_t ZQ_bQueueIsEmpty(void *pvQueueHandle);
PUBLIC uint32 ZQ_u32QueueGetQueueSize(void *pvQueueHandle);
PUBLIC uint32 ZQ_u32QueueGetQueueMessageWaiting ( void*    pu8QueueHandle );

在这里插入图片描述

队列管理的结构体

复制代码

1
2
3
4
5
6
7
8
9
10
typedef struct
{
   uint32 u32Length;                    /*队列的成员个数，而不是字节数 */
   uint32 u32ItemSize;                /*< The size of each items that the queue will hold. */
   uint32 u32MessageWaiting;
   void  *pvHead;                        /*头节点 指针*/
   void  *pvWriteTo;                    /*指向存储区中空闲的下一个位置 */
   void  *pvReadFrom;                /*指向存储区中空闲的下一个位置 */
}tszQueue;

队列创建，必须指定队列的大小和队列中消息的大小，以及队列在内存中的起始位置
ZQ_vZQueueCreate()

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
PUBLIC void ZQ_vQueueCreate ( tszQueue*       psQueueHandle, 
                             const uint32    u32QueueLength, 
                             const uint32    u32ItemSize, 
                             uint8*          pu8StartQueue )
{
       psQueueHandle->pvHead =  pu8StartQueue;
       psQueueHandle->u32ItemSize =  u32ItemSize;
       psQueueHandle->u32Length =  u32QueueLength;
       psQueueHandle->pvWriteTo =  psQueueHandle->pvHead;
       psQueueHandle->u32MessageWaiting =  0;
       psQueueHandle->pvReadFrom =  psQueueHandle->pvHead;
}

参数：psQueueHandle 指向自己定义tszQueue类型消息队列
u32QueueLength 是根据队列可以容纳的消息数量确定队列的大小
u32ItemSize 队列中消息的大小，以字节为单位
pu8StartQueue 指向消息队列开始的指针

我们一般会在工程初始化时，系统需要创建必须队列
示例如下：

复制代码

1
2
3
4
5
    ZQ_vQueueCreate(&zps_msgMlmeDcfmInd,         MLME_QUEQUE_SIZE,      sizeof(MAC_tsMlmeVsDcfmInd), (uint8*)asMacMlmeVsDcfmInd);
    ZQ_vQueueCreate(&zps_msgMcpsDcfmInd,         MCPS_QUEUE_SIZE,       sizeof(MAC_tsMcpsVsDcfmInd), (uint8*)asMacMcpsDcfmInd);
    ZQ_vQueueCreate(&zps_TimeEvents,             TIMER_QUEUE_SIZE,      sizeof(zps_tsTimeEvent),     (uint8*)asTimeEvent);
    ZQ_vQueueCreate(&zps_msgMcpsDcfm,            MCPS_DCFM_QUEUE_SIZE,  sizeof(MAC_tsMcpsVsCfmData),(uint8*)asMacMcpsDcfm);

3.ZQ_bQueueSend 添加指定队列添加成员数据

复制代码

PUBLIC bool_t ZQ_bQueueSend ( void*          pvQueueHandle, 
                              const void*    pvItemToQueue )
{

uint32 u32Store;
    tszQueue *psQueueHandle = (tszQueue *)pvQueueHandle;
    bool bReturn = FALSE;
    MICRO_DISABLE_AND_SAVE_INTERRUPTS(u32Store);
    if(psQueueHandle->u32MessageWaiting >= psQueueHandle->u32Length)
    {
        DBG_vPrintf(TRACE_ZQUEUE, "ZQ: Queue overflow: Handle=%08xn", (uint32)pvQueueHandle);
    }
    else
    {        
        if( psQueueHandle->pvWriteTo >= (psQueueHandle->pvHead+(psQueueHandle->u32Length*psQueueHandle->u32ItemSize)))
        {
             psQueueHandle->pvWriteTo = psQueueHandle->pvHead;
        }
        ( void ) memcpy( psQueueHandle->pvWriteTo, pvItemToQueue, psQueueHandle->u32ItemSize );
        psQueueHandle->u32MessageWaiting++;
        psQueueHandle->pvWriteTo += psQueueHandle->u32ItemSize;
        
        /* Increase power manager activity count */
        PWRM_eStartActivity();        
        bReturn = TRUE;
    }
    MICRO_RESTORE_INTERRUPTS(u32Store);
    return bReturn;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
PUBLIC bool_t ZQ_bQueueSend ( void*          pvQueueHandle, 
                              const void*    pvItemToQueue )
{

    uint32 u32Store;
    tszQueue *psQueueHandle = (tszQueue *)pvQueueHandle;
    bool bReturn = FALSE;
    MICRO_DISABLE_AND_SAVE_INTERRUPTS(u32Store);
    if(psQueueHandle->u32MessageWaiting >= psQueueHandle->u32Length)
    {
        DBG_vPrintf(TRACE_ZQUEUE, "ZQ: Queue overflow: Handle=%08xn", (uint32)pvQueueHandle);
    }
    else
    {        
        if( psQueueHandle->pvWriteTo >= (psQueueHandle->pvHead+(psQueueHandle->u32Length*psQueueHandle->u32ItemSize)))
        {
             psQueueHandle->pvWriteTo = psQueueHandle->pvHead;
        }
        ( void ) memcpy( psQueueHandle->pvWriteTo, pvItemToQueue, psQueueHandle->u32ItemSize );
        psQueueHandle->u32MessageWaiting++;
        psQueueHandle->pvWriteTo += psQueueHandle->u32ItemSize;
        
        /* Increase power manager activity count */
        PWRM_eStartActivity();        
        bReturn = TRUE;
    }
    MICRO_RESTORE_INTERRUPTS(u32Store);
    return bReturn;
}

参数：pvQueueHandle指向自己定义tszQueue类型的队列
pvItemToQueue 指向要添加到队列中的消息的指针
返回值：TRUE -消息成功添加到队列
FALSE-消息没有添加到队列

ZQ_bQueueReceive此函数从指定的消息队列获取一条消息。返回代码指示是否成功地从队列获取了一条消息。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
PUBLIC bool_t ZQ_bQueueReceive ( void*    pvQueueHandle, 
                                 void*    pvItemFromQueue )
{
    uint32 u32Store;
    tszQueue *psQueueHandle = (tszQueue *)pvQueueHandle;
    bool bReturn = FALSE;
    MICRO_DISABLE_AND_SAVE_INTERRUPTS(u32Store);
    if( psQueueHandle->u32MessageWaiting >  0)
    {
        if( psQueueHandle->pvReadFrom >= (psQueueHandle->pvHead+(psQueueHandle->u32Length*psQueueHandle->u32ItemSize) ))
        {
            psQueueHandle->pvReadFrom = psQueueHandle->pvHead;
        }
        ( void ) memcpy( pvItemFromQueue, psQueueHandle->pvReadFrom, psQueueHandle->u32ItemSize );
        psQueueHandle->pvReadFrom += psQueueHandle->u32ItemSize;
        psQueueHandle->u32MessageWaiting--;
        
        /* Decrease power manager activity count */
        PWRM_eFinishActivity();
        bReturn = TRUE;        
    }
    else
    {
        bReturn =  FALSE;
    }
    MICRO_RESTORE_INTERRUPTS(u32Store);
    return bReturn;
}