前言

早些时候写的一些测试记录的文章，并没有完全是以那种教材的方式写的，所以相对于最新的文章，整体格式框架可能没那么好。

好的一面是，我是实打实的实际应用记录，每次遇到问题会来重新更新文章，做新的记录！

经过前面一段时间的测试，我们把STM32L051 的需要用到的基本功能都测试过了，这次我们得把产品替换成L051了。

基本的IO使用都没问题，数据存储EEPROM和flash也没有问题，测试过正常用就可以了（实际上后来 EEPROM折腾了好久），在串口的使用上，也需要测试一下。

这里贴的代码是我测试流程使用过的代码，当时的文章以记录各种测试数据为主，仅供参考！

一、串口接收处理的几种方式1.1 串口接收发送不定长度的数据（非DMA方式）

以前在在标准库STM32F103标准库的使用上用到的IDLE中断接收一帧数据，测试用起来确实好用

1. void USART2_IRQHandler(void)                 //串口2中断服务程序
   * E- {  |) q1 a% L3 f) E. I' F4 I
2. {
   , n$ ~( G  `" x: Z" Q
3. u8 clear=clear;    //消除编译器没有用到的提醒
   1 C/ T# }' g2 g- P) z8 Q4 u# u
4. 
   
5. //USART_ClearFlag(USART2,USART_FLAG_TC);
   
6.   if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  
   
7.   {
   * ~4 F2 ~8 _- J/ S' h5 d- s
8.    USART_RX_BUF[RX_Data++] = USART2->DR;
   
9.   }
   
10.   else if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET)   
    
11.   {
    
12.     clear=USART2->SR; //读SR寄存器 可以清空寄存器
    ; f# F( F" q5 Y: g4 o! ^
13.          clear=USART2->DR; //读DR寄存器（先读SR寄存器，再读DR，为了清除IDLE中断）      
    4 W! C/ V* k  }* `1 \) ?! I) p
14.          ReceiveState=1;   //标记接收到了一帧数据
    : [% ~- D) D5 f2 _8 F: ~
15.   }
    
16. }

复制代码

+ ^2 i+ E% d; V! l+ H+ Z

不需要自己做延时处理，在某些情况下，比如通讯模块的串口3使用中，还是用到了延时处理，具体就是判断串口是否接收到一个字节的数据？如果接收到一个字节的数据，那么延时一定时间，一般是几毫秒（这个延时时间就是干等，等待这一串数据全部接收完成，所以这个时间需要实际使用中不同的测试优化，干等时间太长了不太合理，太短数据接收不完全处理起来会出错），如下：

1. RETURN_TYPE blue_getTelegram(TEL_RADIO_TYPE *pu8RxRadioTelegram, TEL_PARAM_TYPE *pu8TelParam)
   & T0 ]3 o  C0 K; [& P
2. {
   
3. // uint8 i=0;
   * f$ G& q9 t( R/ q
4. uint8 u8CRC = 0;
   5 H+ ?1 w- f( C" G) ~4 M, b
5. uint8 u8Count = 0;
   ) O2 n( l- I) O8 f
6. uint8 TmpVal = 0;
   ; [' P+ c& w' `6 m. r; z
7. uint8 DATA_LEN = 0;
   
8. uint8 n = 0;
   
9. uint8 HEADER_BYTES[4];
   
10. uint8 DatBuf[30] = {0};
    $ D5 t9 k, s+ J' a
11. u8state = GET_SYNC_STATE;
    : V* Q4 l8 F; z* A2 E
12. if (Read_pt != Enocean_Data){
    9 [6 w& x3 F; J& _- J
13.   delay_ms(7);  //这里的等待就是干等！从收到第一个字节开始干等
    7 x& i* \1 Q5 l' o5 A4 U
14.   while (Read_pt != Enocean_Data)
    ; [* }- i  u- x% K2 z
15.   {
    - @& \4 ^8 ^3 V" `5 }8 }5 e
16.    TmpVal = USART_Enocean_BUF[Read_pt++];
    
17.    if(Read_pt >= 100)                        //定义缓存大小，测试时候用100直接替代
    9 G! ?4 K8 {7 b, ]# W
18.      Read_pt = 0;
    " P: S; N- e' o8 I5 ?
19.    switch(u8state)
    
20.    ...

复制代码

' S* I/ f, W: c3 C* V# ~

自己也使用过环形缓冲区等一些方式进行优化，可能目前的处理方式能够满足大部分功能需求，所以也没有确实的花心思正真去测试优化一个环形缓冲区的使用。

那么现在再L051下面，我们怎么来使用 IDLE  中断呢？ 当然我先去网上查找了大神们的各种帖子，然后还是得自己修改一下程序，来一步一步做测试，先回到串口接收简单的测试：

1. if(test_data != Enocean_Data){
   2 B  R6 \% l0 j# Y" [
2.         HAL_Delay(7);
   * C0 c% e" T5 N* [, o
3.         // printf("Enocean_Data ID is: 0x %d  test_data is : 0x%d \r\n",Enocean_Data,test_data);
   
4.         if(Enocean_Data > 10){
   # G/ W" q/ e+ [* _& c% l3 j- A
5.           HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出
   
6.         }      
   ) h1 l& C2 u- X5 L7 s
7.         memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF));   //清空缓存区
   
8.         Enocean_Data=0;
   
9.         // (&hlpuart1)->pRxBuffPtr = &USART_Enocean_BUF[Enocean_Data];//用下面的简洁，数组名就可以当做指针用
   
10.         (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要，没有这一句，后面接收会出错
    
11.     }
    + _8 a8 f1 Y9 k3 U: J) G5 h  }
12.     }

复制代码

# X! y: u) V' N1 v+ f9 y

在主函数初始化串口后，有这么一句，打开串口中断（这里的中断可不可以理解为打开IT中断）

1. HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[0], 1);

复制代码

8 C  a( I% i0 ]* V. H

现在我们要开启IDLE中断

1. __HAL_UART_ENABLE_IT(&hlpuart1,UART_IT_IDLE);
   
2.   HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[0], 1);

复制代码

$ j) t4 B( B/ h4 ~) F1 Z/ s' Y

在stm32l0xx_it.c中找到 LPUART1_IRQHandler函数，因为所有中断先是进入 stm32l0xx_it.c 中相应的IRQHandler函数中，调用对应函数，最后才会进入到 自己设置的 Callback函数中，我们这次测试直接在void LPUART1_IRQHandler(void)函数中系统设置的函数前写一个 实现 IDLE中断后操作的函数：

1. void LPUART1_IRQHandler(void)
   
2. {
   
3.   /* USER CODE BEGIN LPUART1_IRQn 0 */
   
4.   if((__HAL_UART_GET_FLAG(&hlpuart1,UART_FLAG_IDLE) != RESET))
   
5.   {
   1 j5 ?& f! V# F4 W7 t
6.       __HAL_UART_CLEAR_IDLEFLAG(&hlpuart1);
   
7.         ReceiveState = 1;   
   
8.   }
   
9.   /* USER CODE END LPUART1_IRQn 0 */
   1 C; J$ E: C7 Y
10.   HAL_UART_IRQHandler(&hlpuart1);
    9 k# K0 {/ G% {
11.   /* USER CODE BEGIN LPUART1_IRQn 1 */
    $ s! @; u: K* k4 q0 u+ g
12. 
    3 K# d+ [  l0 D* d( N4 f4 X
13.   /* USER CODE END LPUART1_IRQn 1 */
      p. g5 B/ u& t
14. }

复制代码

- K9 v# F( u- o" a. K, S! n

用 ReceiveState 来标志是否接受到了一串数据，然后打印函数变成

1. if(ReceiveState == 1){
   
2.         ReceiveState = 0;      
   
3.         HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出            
   / [$ i6 ^6 p' s. R; G
4.         memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF));   //清空缓存区
   # v* t) {* O; {! w
5.         Enocean_Data=0;
   
6.         (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要，没有这一句，后面接收会出错
   
7.     }

复制代码

% ?, e( \! k4 p% D% g* {; P

结果， 数据异常，就是收不全，结尾会有问题，明天得继续测试优化了，先上个正常的接收，这是上面用HAL_Delay(7)测试得到的正常结果。

% T- n. u4 A7 Z% }8 q

' _% Y3 k# c( K: X+ ~

6 @! `$ ^' f& h# y/ v% D

实际测试，数据会断接收不全，考虑了一下，是否本身我的通讯模组串口给MCU的时候一包数据就是分两次发送（其实就是一包数据中间有个时间会长一点，然后MCU判定为2帧数据，每次能够收到开头的一段）， 我测试的打印函数每次收到一包数据，都会把数据全部打印出来，然后清空缓存区，所以下一包数据直接被清掉了，因为在进行输出的过程，可能下一包的数据中断进来了，为了验证一下，还是加上了一个延时，代码改成如下：

1. if(ReceiveState == 1){
   ; }0 P/ W. t5 \/ J% b
2.         HAL_Delay(7); //测试，重要
   
3.         ReceiveState = 0;      
   
4.         HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出            
   
5.         memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF));   //清空缓存区
   
6.         Enocean_Data=0;
   
7.         (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要，没有这一句，后面接收会出错
   & M# I8 ~& q3 P: {: R3 e* ^
8.     }

复制代码

9 Z. i( M; y/ y% j

发现加上延时后，数据就正常了……，其实中途测试的时候在IDLE中断处理时候，我打印过 测试语句，发现我正常的一包数据，都会打印2次测试语句，也进一步的证实了，测试模块给MCU的正常的一包数据会被MCU认为是 2帧数据。那么我们怎么来解决这个问题呢，还是直接加一个ms延时吗？至少IDLE中断在这里用不了，一帧数据会触发2次中断，可能和通讯模块有关，因为以前测试的时候也遇到过类似情况。

但至少IDLE中断我们可以用起来，在这里做一个小结：1、正常初始化串口以后，打开IDLE中断：

1. __HAL_UART_ENABLE_IT(&hlpuart1,UART_IT_IDLE);

复制代码

9 s$ U( `5 U& ~0 J: R% L4 c

这个语句可以放在串口初始化函数MX_LPUART1_UART_Init中，也可以放在main函数后面，看个人习惯；

2、在stm32l0xx_it.c 文件中响应的中断相应函数LPUART1_IRQHandler 中加入关于IDLE中断的处理于语句：

1. void LPUART1_IRQHandler(void)
   5 n8 X( k% @: l- b! ]* S
2. {
   ) z4 [2 O8 O* ]9 k; `* o) X
3.   /* USER CODE BEGIN LPUART1_IRQn 0 */
   
4.   
   
5.   /* USER CODE END LPUART1_IRQn 0 */
   
6.   HAL_UART_IRQHandler(&hlpuart1);
   
7.   /* USER CODE BEGIN LPUART1_IRQn 1 */
   
8.   if((__HAL_UART_GET_FLAG(&hlpuart1,UART_FLAG_IDLE) != RESET))
   , ~6 d/ p  H0 b
9.   {
   
10.     usartreceive_IDLE(&hlpuart1);
    " K  H( f4 p& v/ p
11.   }
    
12.   /* USER CODE END LPUART1_IRQn 1 */
    ( x: U5 v$ |3 k- z6 I* n- e2 F3 h
13. }
    ) G  n, C! g2 t5 b$ @, D
14. 
    ! ^' c" o( O" w3 q3 ~) }$ G6 m
15. /* USER CODE BEGIN 1 */
    . A6 s' K% F  i& |8 _) o
16. void usartreceive_IDLE(UART_HandleTypeDef *huart)
    ) \0 {6 [. I) A+ `3 l* M) ~* u2 k
17. {
    , M$ N, F  b8 Z* L5 i, H
18.   __HAL_UART_CLEAR_IT(&hlpuart1,UART_CLEAR_IDLEF); //清除中断
    7 d4 T4 w: f8 S- h' r
19.   // HAL_UART_AbortReceive_IT(huart); //终止接收
    . g( U3 H% g2 f$ v  Y( A
20.   ReceiveState = 1;
    
21. }

复制代码

- S6 ~- D4 G( g; q& |, |

用一个标志位表示收到了一帧数据，即便这个一帧不完全，也至少表示收到一段数据了，这里不能加 HAL_UART_AbortReceive_IT(huart); //终止接收 ，因为IT中断可以继续接收，如果终止了，数据处理不够及时，下一帧数据就收不到了。

3、最后通过判断标志位 ReceiveState  来处理数据，一般情况下直接处理，特除情况，在标志位至1 后，刻意的等待几个毫秒，等待数据接收完全再处理。

！！！最后移植又发现一个问题代码中  #define ID_blueNum 44

1. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
   : @2 J( E; U, a- Q8 q
2. printf("send command !\r\n");
   
3. COMMAND_GetmoduleID();
   
4. // HAL_Delay(10); //7ms不够
   
5. while ((Enocean_Data - Read_pt) < ID_blueNum);//加了这句不需要加上面的延时，这句就是等待,这句很重要，能够过滤掉不相关的报文
   
6. // while ((Enocean_Data - Read_pt) < ID_blueNum){
   3 D" O6 O7 e6 a8 J/ S* _
7. //  HAL_UART_Receive_IT(&hlpuart1, &USART_Enocean_BUF[Enocean_Data], 1);
   , `. e1 T* {* N5 a
8. // }//2021/8/11  不是很懂为什么这里这个while等待必须得加点东西
   
9. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);

复制代码

如果按照上面的代码，会一直卡在这里过不去，其实就是while ((Enocean_Data - Read_pt) < ID_blueNum);过不去，开始怀疑是不是通讯模块本来就是坏的，我们有多种方式测试：

测试代码1（好理解，发送命令了，等待一会，让串口把数据收完）：

1. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
   ! x0 M  @/ C( Y. Y
2. printf("send command !\r\n");
   % f, C; l# ]5 P
3. COMMAND_GetmoduleID();
   
4. HAL_Delay(10);//7ms不够
   + |4 l: k. {6 t4 {8 d% r+ ^
5. while ((Enocean_Data - Read_pt) < ID_blueNum);//加了这句不需要加上面的延时，这句就是等待,这句很重要，能够过滤掉不相关的报文
   
6. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);

复制代码

# T" J# a8 P: |) M3 S6 s9 P& @5 Q

测试代码2（本来是想看看等待时候打印什么东西，加个条件怕一直循环）：

1. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
   - T8 Q) x- G" O1 B% C( b7 Q/ r
2. printf("send command !\r\n");
   
3. COMMAND_GetmoduleID();
   
4. while ((Enocean_Data - Read_pt) < ID_blueNum){
   
5.   if(Enocean_Data < 10)printf("测试过随便打印点东西都可以!\r\n");
   ! g+ F0 g! w# e9 Q+ c
6. }//2021/8/11  不是很懂为什么这里这个while等待必须得加点东西
   
7. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);

复制代码

( r( z" z+ p' _+ m/ Y' D4 @+ k

0 Y5 E( v- i; u, h

测试代码3 , 4（不加条件随便在等待中打印 ,  延时 ）

- |$ [" n" m$ d' |7 K2 ?( L

1. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
   5 z8 m7 E% r0 t5 c, E4 s
2. printf("send command !\r\n");
   5 Z$ v6 n! p8 \4 G3 p' I
3. COMMAND_GetmoduleID();
   
4. while ((Enocean_Data - Read_pt) < ID_blueNum){
   
5.   printf("不要条件乱打都可以测试过随便打印点东西都可以!\r\n");
   7 d) L# Z5 R3 r" l6 P
6.   //HAL_Delay(1);//延时可以，1ms就可以
   0 L9 y2 J9 U2 E
7. }//2021/8/11  不是很懂为什么这里这个while等待必须得加点东西
   
8. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);

复制代码

# u# ]4 `) h& q  m  Y" d
$ h. w1 Y: m. d# s  i
/ b- f5 S  Z( J9 L
& B# {( E& M+ \( y9 X2 Q/ |( [! m2 j
/ Z6 Q% G) |- Z

经过测试发现，while中虽然是干等，但是没有语句就会有问题，不是很明白，因为以前都可以，虽然知道解决办法，但是不知道问题原因，所以也不知道哪种是更优的解决办法！=  =！

. ~. L6 x. x0 ]' u/ M1.2 串口接收发送不定长度的数据（DMA方式）

在实际使用中，我没有在L051下面测试使用DMA利用 IDLE  中断进行DMA接收发送，实际上，通过我们上面做的实验和测试，对于目前使用的通讯模块，一包数据会触发2次IDLE 中断的情况，也不太适合。本例程是以前STM32L1系列中使用的例程，以前也是在网上参考过其他人的设计然后自己用起来的，正好也在这里做个笔记

1. #define USART3_DMA_REC_SIE 256   //DMAbuf空间大小
   4 y4 E2 p* w# {$ O/ O1 V+ w
2. #define USART3_REC_SIE 512      //接收区空间大小两倍，以保持两条历史数据
   
3. typedef struct
   * g# `2 ]9 Y" k2 M8 |
4. {   
   6 O" G% i) n) {  K4 f/ a  a
5.     uint8_t UsartRecFlag;   //接收数据Flag
   
6.     uint16_t UsartDMARecLen; //DMA接收到数据的长度
   
7.     uint16_t UsartRecLen;    //RecBuffer中已经存储数据的长度
   9 A! K3 S) Z! O3 K
8.     uint8_t  Usart3DMARecBuffer[USART3_DMA_REC_SIE];  //dma
   2 e: O! a- x6 H1 p6 y2 G
9.     uint8_t  Usart3RecBuffer[USART3_REC_SIE];         //RecBuffer
     @  n1 J9 i6 d9 @- h* w
10. } Usart3DMAbufstr;
    ) G4 \& ]4 U" w0 M
11. extern Usart3DMAbufstr Usart3type;  

复制代码

1. void USART3_IRQHandler(void)
   
2. {
   ! ?1 n/ J3 ^% c! r7 {/ {3 ~, W
3.   /* USER CODE BEGIN USART3_IRQn 0 */
   ' O9 L! e: M$ y" _: [3 J
4. 
   
5.   /* USER CODE END USART3_IRQn 0 */
   . J9 c) u- f2 }1 F( K4 l1 k
6.   HAL_UART_IRQHandler(&huart3);
   6 N: H# \* @" Y4 @2 U
7.   /* USER CODE BEGIN USART3_IRQn 1 */
   
8.   if(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_IDLE) == SET)  //判断空闲中断
   
9.     {  
   2 B7 l3 R' {. U% v4 T: {0 ~
10.       u16 res = 0;                        
    
11.       __HAL_UART_CLEAR_IDLEFLAG(&huart3);       //清楚空闲中断标志
    
12.       HAL_UART_DMAStop(&huart3);                //暂时关闭DMA中断
    5 v: ?1 Z8 G- C! Q" u
13.      res = huart3.Instance->ISR;         
    
14.       res = huart3.Instance->RDR;              
    
15.       res = hdma_usart3_rx.Instance->NDTR;                     //读取DMA接收的那个buf还剩多少空间
    3 x1 ~4 R6 d7 }6 S5 D# l- s; u
16.    Usart3type.UsartDMARecLen = USART3_DMA_REC_SIE - temp;   //总空间减去还剩下的空间等于存入数据的空间大小  
    
17.       HAL_UART_RxCpltCallback(&huart3);                     //手动调用中断回调，因为空闲中断不会主动调用
    ) I: U+ R$ Y$ N0 |9 I, ~( z
18.    }
    
19.   /* USER CODE END USART3_IRQn 1 */
    6 n0 T+ Q% `- ^* P( Z& E
20. }

复制代码

% l4 x9 T: o: g) O! _

数据最初都存储在DMARecBuffer中，然后转存到RecBuffer中。DMARecBuffer中的数据每接收到新的数据都会清空。

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
2. {
   $ C; Z$ c) ~. W3 f' h
3.     //可行选着是否开启多条数据缓存，默认不开启，开启删除下划线
   
4.     if(huart->Instance == USART3)
     X% g4 G9 j. M* E; E
5.     {
   + \8 l$ |* g% e* t  H
6.       //  if(Usart3type.UsartRecLen>0）//判断RecLen是否清0，如果没有清零代表上一个数据没有读取
   
7.       //  {
   
8.         //    memcpy(&Usart3type.Usart3RecBuffer[Usart3type.UsartRecLen],Usart3type.Usart3DMARecBuffer,Usart3type.UsartDMARecLen); //把数据顺延
   
9.        //     Usart3type.UsartRecLen +=  Usart3type.UsartDMARecLen;//数据长度增加相应的位数
   
10.       //  }
    ; _1 j0 W3 k* w1 C* `: ]
11.       //  else
    5 p4 `6 m6 w1 P1 b- c# D( Z
12.      //   {
    5 B4 M4 E2 S& R- i( D
13.             memcpy(Usart3type.Usart3RecBuffer,Usart3type.Usart3DMARecBuffer,Usart3type.UsartDMARecLen);                          //把输入放入buf开头
    
14.             Usart3type.UsartRecLen =  Usart3type.UsartDMARecLen;        //记录数据长度                  
    
15.        // }
    
16.    
    0 B2 b" ~+ L7 a% f
17.         memset(Usart3type.Usart3DMARecBuffer, 0x00, sizeof(Usart3type.Usart3DMARecBuffer));                                     //把DMA缓存中的数据清空，方便下一次接收
      B, \; z1 v! W- c  T
18.         Usart3type.UsartRecFlag = 1;                                                                                            //RecFlag置1，代表RecBuffer中有数据
    + H4 y- X/ T& j6 I" K1 Y: K# d
19.      HAL_UART_Receive_DMA(&huart3,Usart3type.Usart3DMARecBuffer,USART3_DMA_REC_SIE);                                         //重新开启DMA中断，方便再一次接收
    & i8 Y, z; t" P" Q9 v; q; B
20.     }
    + l+ X( d; T, Q: a1 Y
21. }

复制代码

在相应的程序中把上面的代码添加好，然后在主函数循环中使用，RecBuffer中的数据会一直增加，直到用户读取以后才会清空：

1. if(Usart3type.UsartRecFlag == 1)//如果Recbuffer中有数据
   
2. {
   
3. HAL_UART_Transmit(&huart1,Usart3type.Usart3RecBuffer,256,0xffff);//把RecBuffer中的数据发送到串口1
   ( C$ ^, x6 J& J7 D! Q+ y- A
4. memset(Usart3type.Usart3RecBuffer, 0x00, sizeof(Usart3type.Usart3RecBuffer));//读取完数据后记得一定要把RecBuffer中的数据清除
   - A0 `7 Y: W& _9 K( I* x
5. Usart3type.UsartRecFlag = 0;//标志位清0
   9 ]0 [5 |, x9 \# f) b! Z1 o
6. Usart3type.UsartRecLen = 0;//已有数据长度清0
   
7. }

复制代码

1.3 环形缓冲区

因为单单靠数组方式，接收处理，总感觉不是那么聪明，有时候需要干等，所以还是得花时间研究下环形缓冲区。。。

* h* k4 |( E4 ]! K; D) C二、串口接收卡死处理

在使用了了段时间后，测试部反馈偶尔会有串口卡死说明，最终就是接收不到串口数据，但是轮询发送是正常，后来查阅了一些资料，找到了需要处理的地方，这里特此来记录一下。

2.1 清除错误标志位

在使用 HAL 库的时候，有4个错误 flag，如下图：

8 v4 t3 X( L! M1 F4 _

2 P8 X; W# q0 [) J; _

出错的时候，HAL库会把以上flag置位如果不清除就再也接收不到数据了。

所以我们可以在需要的时候使用，下面的语句清除错误标志:

2 R! ?8 L3 c& V) L+ Q, g% m4 q+ x

1. __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_PE);//清标志
   4 f9 t0 _1 B. g% e% C, F, F
2. __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_FE);
   
3. __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_NE);
   
4. __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_ORE);

复制代码

比如，在我清除串口接收缓存的函数中，我加上了这几句代码：

这是实际使用的情况，我并没有详细的测试到底是哪一个错误置位了，在自己了解的简单产品上，直接一步到位也是一种方式。

+ _$ v$ ?! G8 p' _2.2 HAL 库函数问题

产品使用了上面的串口清除错误标志，在压力测试下下面还是有问题：

现象就是串口发送正常，但是永远接收不到数据了。

实在是没办法，后来继续找答案。

最后确实发现网上也有小伙伴遇到过相同的问题，我使用的是 HAL_UART_Receive_IT 开启中断：

# s* P% F. v) L& U# C+ t: _: _

在这个函数中有这么一段：

. m7 J; m$ v# O7 l4 |  [0 n
- A) _! J1 {, ?0 ~# l& J  ]

6 S% ~8 t) d! z7 B5 O

里面有个加锁操作，正式因为这个加锁操作，如果收发同时进行，会有概率卡死。

这个时候的处理方式就是手动解锁，每次接收到一个字节后需要再次开启中断接收，判断一下是否有错误：

判断的语句如下：

1. if(huart->Instance == LPUART1){
   
2.     Enocean_Data++;
   
3.     if(Enocean_Data > 98)Enocean_Data = 0;
   
4.     while(HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[Enocean_Data], 1) != HAL_OK){
   " v0 i+ b# x: ?& Q
5.       hlpuart1.RxState = HAL_UART_STATE_READY;
   1 M" ]0 Q1 E1 Q: t+ _
6.       __HAL_UNLOCK(&hlpuart1);
   % f1 j2 \9 c, `5 p
7.     }
   4 {- v# T  K# ~
8.   }

复制代码

如有侵权请联系删除
* k. U' [: @' b* b. q

转载自： 矜辰所致