UART学习笔记一:如何判断一帧数据收完

淩亂°似流年 2022-07-14 04:58 433阅读 0赞

好久就想写个东东总结下，但是一直没有时间（都是借口，就是因为懒）。今天下午在整理UART模块驱动，正好记录下，想到哪里，写到哪里，大家勿怪。。。

UART接收数据，一个字节一个字节接收，底层硬件只能知道现在收到了一个字节，然后保存在一个buffer里面。怎么去判断现在一帧协议收完了呢？也就是说，我要发送一个协议帧，根据协议他是不定长的，怎么判断现在收完了呢？

方法一：

也许有人会想到，我边接收边判断，就是在接收驱动函数里，去解析协议，一般是这个样子：

\#pragma vector = INTSR2\_vect  
\_\_interrupt static void r\_uart2\_interrupt\_receive(void)  
\{

buffer\[CNT\] = RXD2;

CNT++;

if(CNT > 帧头长度)\{

找帧头，然后记住帧头位置；

//找帧长位置

//等待接收完

//判断帧尾或者校验

//通知APP，一帧接收完毕

//请标志

SRIF2 = 0;  
\}

这么做，我感觉是效率最高的，我的驱动层封装的时候，得暴露\_\_interrupt static void r\_uart2\_interrupt\_receive(void)给用户，同时提供用户底层接收完清除标志等API。

方法二：

也会有人会想到我在协议前加一个字节长度不就完了，根据这个区接收，然后接收完了，告诉APP层或者协议解析层。这种方法实现的前提是大家都按这个做，否则通信失败，适合公司内部使用。

方法三：

我开始用的是TIMER\_OUT方法，什么意思呢？举例说，9600波特率，发送一个字节大约需要1ms时间，假如认为发送是连续的而不是断续的，那么我是否可以认为你在超过1MS时间（为了留有足够的富裕时间，认为20MS）没有接收中断发生，我就可以认为接收完毕。接着通知APP或者协议解析模块去解析协议。但是这么处理有几个问题需要注意：

1、如果对方用的查询方式发送，那么需要获得对方的最大发送间隔；

2、帧于帧之间发送间隔必须大于接收方设定的TIMER\_OUT时间；（其实这段不满足的话，也可以处理，在RAM资源足够的情况下，协议解析模块按着解析多帧的思路去写）

3、整个通信带宽被拉低，因为帧间隔是TIMER\_OUT时间，肯定是MS级以上，一般20~50ms吧；

但是这种方法是最简单的，也适合解耦，便于模块化封装。

方法四：

我现在用的方法是环形buffer。也就是UART一直在收数据，并且放到一个环形buffer里面（是为了防止溢出），APP或者协议解析模块不停的去读取数据，并做协议解析。这种方法优点就是处理速度快，没有了TIMER\_OUT时间。目前问题是，我不知道怎么把buffer去解耦，索性我就把buffer全部丢给了协议解析模块。

既然谈到了UART驱动封装，我就说说我目前做法，其实我也是刚学习封装这块，水平有限，就是想和大家聊聊，大神轻喷。

首先我定义了几个接口：

//UART0  
extern void uart0\_drive\_mode\_init(void (\*pRxCallBack)(uint8\_t));  
extern bool uart0\_cfg(uart\_cfg\_t \*ptUartCfg,uint32\_t wBaudRate,uint16\_t hwErrorRange,void (\*callback)());  
extern bool uart0\_txd\_query(uint8\_t \*pchTxdBuffer,uint16\_t hwTxdNum);  
extern void uart0\_enable\_rx\_interrupt(interrupt\_level\_t tLevel);  
extern void uart0\_disable\_rx\_interrupt(void);  
extern void uart0\_set\_tx\_interrupt\_level(interrupt\_level\_t tLevel);  
extern bool uart0\_txd\_interrupt\_start(uint8\_t \*pchBuffer,uint16\_t hwTxdLong);

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* UART0 \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
//模块初始化  
\#define USER\_UART0\_DRIVE\_MODE\_INIT(\_\_CALLBACK) uart0\_drive\_mode\_init(\_\_CALLBACK)  
//USER0  
\#define USER\_UART0\_CFG(\_CONFIG,\_BAUDRATE,\_Rang,\_CALLBACK) uart0\_cfg((\_CONFIG),(\_BAUDRATE),(\_Rang),(\_CALLBACK))  
\#define USER\_UART0\_TXD\_QUERY(\_BUFFER,\_TXD\_NUM) uart0\_txd\_query((\_BUFFER),(\_TXD\_NUM))  
\#define USER\_UART0\_ENABLE\_RX\_INTERRUPT(\_LEVEL) uart0\_enable\_rx\_interrupt(\_LEVEL)  
\#define USER\_UART0\_DISABLE\_RX\_INTERRUPT() uart0\_disable\_rx\_interrupt()  
\#define USER\_UART0\_SET\_TX\_INTERRUPT\_LEVEL(\_LEVEL) uart0\_set\_tx\_interrupt\_level(\_LEVEL)  
\#define USER\_UART0\_TXD\_INTERRUPT\_START(\_\_BUFFER,\_\_TXD\_NUM) uart0\_txd\_interrupt\_start((\_\_BUFFER),(\_\_TXD\_NUM))

解释：

uart0\_drive\_mode\_init()，模块初始化函数，需要传入一个void (\*pRxCallBack)(uint8\_t)型函数指针，这个函数是为了接收中断回调用户接收处理函数，把RXD0数据放到环形接收缓存区；

uart0\_cfg()配置函数,需要回调用户的I/O口配置函数，因为UARTI/O口是可选（偷懒了）

uart0\_txd\_query()查询发送函数，线程安全的

uart0\_enable\_rx\_interrupt()使能接收中断，并设置优先级

uart0\_disable\_rx\_interrupt()关闭接收中断

uart0\_set\_tx\_interrupt\_level()设置发送优先级

uart0\_txd\_interrupt\_start()中断发送，线程安全的

然后，我把所有的中断和函数封装到底层里面。

这里有一点我不明白怎么做，这个接收环形buffer怎么设计实现解耦？

<-----------------------------------------------------------------------华丽分割线----------------------------------------------------------------------------->

最近一直在学习OOPC和数据结构方面的知识，突然领悟到怎么把环形buffer分离出来，原来方法是如此简单，怪我以前想复杂了。

首先我们定义一个queue的类，定义四个接口：

bool init\_byte\_queue(byte\_queue\_t\* ptQueue,uint8\_t\* pchBuffer,uint16\_t hwSize);  
bool is\_queue\_empty(byte\_queue\_t\* ptQueue);  
void enqueue\_byte(byte\_queue\_t\* ptQueue,uint8\_t chInData);  
void dequeue\_byte(byte\_queue\_t\* ptQueue,uint8\_t\* pchOutData);

然后定义个数据结构体：

struct byte\_queue\_t\{

uint8\_t \*pchBuffer;  
uint16\_t hwSize;  
uint16\_t hwHead;  
uint16\_t hwTail;  
uint16\_t hwLength;

\};

实现如下：

\#define this (\*ptThis)  
  
bool init\_byte\_queue(byte\_queue\_t\* ptQueue,uint8\_t\* pchBuffer,uint16\_t hwSize)  
\{  
CLASS(byte\_queue\_t) \*ptThis = (CLASS(byte\_queue\_t) \*)ptQueue;  
if(NULL == ptQueue)\{  
return false;  
\}  
this.pchBuffer = pchBuffer;  
this.hwSize = hwSize;  
this.hwHead = 0;  
this.hwTail = 0;  
this.hwLength = 0;  
\}  
  
bool is\_queue\_empty(byte\_queue\_t\* ptQueue)  
\{  
CLASS(byte\_queue\_t) \*ptThis = (CLASS(byte\_queue\_t) \*)ptQueue;  
if(NULL == ptQueue)\{  
return true;  
\}  
return (0 == this.hwLength);  
\}  
  
void enqueue\_byte(byte\_queue\_t\* ptQueue,uint8\_t chInData)  
\{  
CLASS(byte\_queue\_t) \*ptThis = (CLASS(byte\_queue\_t) \*)ptQueue;  
if(NULL == ptQueue)\{  
return;  
\}  
this.pchBuffer\[this.hwHead\] = chInData;  
this.hwHead++;  
if(this.hwHead >= this.hwSize)\{  
this.hwHead = 0;  
\}  
this.hwLength++;  
\}  
  
void dequeue\_byte(byte\_queue\_t\* ptQueue,uint8\_t\* pchOutData)  
\{  
CLASS(byte\_queue\_t) \*ptThis = (CLASS(byte\_queue\_t) \*)ptQueue;  
if(NULL == ptQueue)\{  
return;  
\}  
if(NULL == pchOutData)\{  
return;  
\}  
if(!this.hwLength)\{  
return;  
\}  
\*pchOutData = this.pchBuffer\[this.hwTail\];  
this.hwTail++;  
if(this.hwTail >= this.hwSize)\{  
this.hwTail = 0;  
\}  
this.hwLength--;  
\}  
  
到此基本UART就说完了，但是我今天看了篇关于环形队列同步加锁问题，有必要再补充下。

上面的环形队列是有问题的，什么问题呢？就是hwLength的同步问题，hwLength--和hwLength++

位于不同的线程，所以需要加锁，以确保原子性问题。

QUEUE\_ENTER\_CRITICAL();  
this.hwLength--; //必须保证原子性  
QUEUE\_LEAVE\_CRITICAL();

//QUEUE\_ENTER\_CRITICAL();  
this.hwLength++; //放在了中断中，本身任务优先级就高  
//QUEUE\_LEAVE\_CRITICAL();

如果写入和读出线程优先级是平级的，那么都需要加锁；如果有一个优先级高，一个优先级低，那个低优先级

线程需要加锁，高优先级不需要。

[UART学习笔记二：如何去check数据帧][UART_check]

[UART学习笔记三：最优接收模型][UART]

[UART_check]: http://blog.csdn.net/wuhenyouyuyouyu/article/details/54377176
[UART]: http://blog.csdn.net/wuhenyouyuyouyu/article/details/62435683