前言
消息队列缓存，支持阻塞、非阻塞模式；支持协议、非协议模式
可自定义消息结构体数据内容
使用者只需设置一些宏定义、调用相应接口即可
这里我用蓝牙消息服务举例
有纰漏请指出，转载请说明。
学习交流请发邮件 1280253714@qq.com
原理讲解
队列采用"生产者-消费者"模式，
当接收数据时，生产者即为外部输入，输入的消息入列；消费者即为消息处理函数，处理消息前先出列，然后消费者处理出列的消息
当发送数据时，生产者为消息产生的任务，该任务将产生的消息入列；消费者为消息发送任务，该任务将待发送的消息出列并发送。
接口
接收消息接口
以蓝牙接收消息服务为例
接收消息处理接口
这里我开了一个定时任务来处理消息
待发送消息装载接口
由任务产生消息并调用装载函数，以下提供透明传输和协议传输接口
待发送消息发送接口
以蓝牙发送消息服务为例，这里我先进行出列判断，如果数据成功出列，则将消息通过蓝牙的内核发送出去
代码
msg.h
#ifndef _MSG_H
#define _MSG_H
#include "includes.h"
#define MsgProtocol 1 //是否使用协议
#define MsgBlock 1 //消息是否阻塞，即当队列已满时，是否继续入列，
//入列会导致前面接收到且未来得及处理的数据被覆盖
#define QueueMaxSize 5 //队列最大存放的数据个数
#define MsgMaxSize 64 //单帧数据最大长度
#define MsgPrefix 0xA5
#define MsgStuffix 0x5A
#define MsgIndexPrefix 0
#define MsgIndexLen 1
#define MsgIndexCmdId 2
#define MsgIndexCmd 3
#define MsgIndexDataBase 4
typedef enum //队列当前状态
{
eQueueEmpty, //队列为空
eQueueNormal, //队列不为空
eQueueFull, //队列已满
} QueueState_E;
typedef enum //出列的数据情况
{
eDataEmpty, //数据为空
eDataNormal, //数据不为空
} DeQueueState_E;
typedef struct //数据格式
{
u8 u8Len;
u8 szData[MsgMaxSize];
} MSG_S;
typedef struct //队列结构体
{
u32 msgCnt;
u32 msgProcCnt;
MSG_S dataEnQueue;
MSG_S dataDeQueue;
MSG_S data[QueueMaxSize];
QueueState_E state; //队列当前状态
u8 front; //队头
u8 rear; //队尾
u8 size; //队列大小
}MSG_ATTR_S;
typedef struct //蓝牙消息结构体
{
MSG_ATTR_S stRx;
MSG_ATTR_S stTx;
}BLE_MSG_S;
QueueState_E MsgQueueStateDetermine(MSG_ATTR_S *queue);
void MsgEnQueue(MSG_ATTR_S *queue, MSG_S *data);
DeQueueState_E MsgDeQueue(MSG_ATTR_S *queue);
void MsgRxDataProc(void);
int MsgProcCrc(u8 *pRxData);
void LoadTransparentMsg(MSG_ATTR_S *queue, MSG_S *txMsg);
void LoadProtocalMsg(MSG_ATTR_S *queue, MSG_S *txMsg);
void BleMsgInit(void);
extern MSG_ATTR_S stRxQueue;
extern BLE_MSG_S stBle;
#endif
msg.c
#include "includes.h"
BLE_MSG_S stBle;
int MsgProcCrc(u8 *pRxData)
{
u8 i = 0;
u8 crc = 0;
u8 size = pRxData[MsgIndexLen];
if ((pRxData[MsgIndexPrefix] == MsgPrefix) && (pRxData[size - 1] == MsgStuffix))
{
for (i = 1; i <= size - 3; i++)
{
crc += pRxData[i];
}
if (crc == pRxData[size - 2])
{
return 0;
}
}
return -1;
}
QueueState_E MsgQueueStateDetermine(MSG_ATTR_S *queue)
{
#if MsgBlock
if (queue->size == 0)
{
return eQueueEmpty;
}
else if (queue->size == QueueMaxSize)
{
return eQueueFull;
}
else
{
return eQueueNormal;
}
#else
if (queue->msgCnt == 0)
{
return eQueueEmpty;
}
else if ( queue->msgCnt > 0)
{
return eQueueNormal;
}
#endif
}
void MsgEnQueue(MSG_ATTR_S *queue, MSG_S *data)
{
#if MsgBlock
if (queue->size == QueueMaxSize)
{
return;
}
#endif
queue->dataEnQueue = *data;
queue->data[queue->rear] = queue->dataEnQueue;
queue->size++;
queue->msgCnt++;
queue->rear++;
if (queue->rear == QueueMaxSize)
{
queue->rear = 0;
}
queue->state = MsgQueueStateDetermine(queue);
}
DeQueueState_E MsgDeQueue(MSG_ATTR_S *queue)
{
if (queue->size == 0)
{
return eDataEmpty;
}
queue->dataDeQueue = queue->data[queue->front];
memset(&queue->data[queue->front], 0, sizeof(queue->data[queue->front]));
queue->size--;
queue->front++;
if (queue->front == QueueMaxSize)
{
queue->front = 0;
}
queue->state = MsgQueueStateDetermine(queue);
return eDataNormal;
}
void MsgRxDataProc(void)
{
if (stBle.stRx.state != eQueueEmpty)
{
if (MsgDeQueue(&stBle.stRx) != eDataEmpty)
{
stBle.stRx.msgProcCnt++;
}
}
}
void LoadTransparentMsg(MSG_ATTR_S *queue, MSG_S *txMsg)
{
MsgEnQueue(queue, txMsg);
}
void LoadProtocalMsg(MSG_ATTR_S *queue, MSG_S *txMsg)
{
u8 i;
u8 checkSum = 0;
MSG_S tmpMsg;
memset(&tmpMsg, 0, sizeof(MSG_S));
for (i = 0; i < txMsg->u8Len; i++)
{
checkSum += txMsg->szData[i];
tmpMsg.szData[i+2] = txMsg->szData[i];
}
tmpMsg.szData[MsgIndexPrefix] = MsgPrefix;
tmpMsg.szData[txMsg->u8Len + 3] = MsgStuffix;
tmpMsg.szData[MsgIndexLen] = txMsg->u8Len + 4;
checkSum += tmpMsg.szData[MsgIndexLen];
tmpMsg.szData[txMsg->u8Len + 2] = checkSum;
tmpMsg.u8Len = txMsg->u8Len + 4;
MsgEnQueue(queue, &tmpMsg);
}
void BleMsgInit(void)
{
memset(&stBle, 0, sizeof(BLE_MSG_S));
}
一个图图
