你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

基于STM32L051串口测试与Enocean模块通讯问题

[复制链接]
攻城狮Melo 发布时间:2023-6-12 16:46
前言

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

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

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

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

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


$ @" G& x! |* V4 r" ]* s一、串口接收处理的几种方式
1.1 串口接收发送不定长度的数据(非DMA方式)

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

  1. void USART2_IRQHandler(void)                 //串口2中断服务程序  m9 }  d  O  ^  l
  2. {( T" |, R# z. O- N, a
  3. u8 clear=clear;    //消除编译器没有用到的提醒  f" g( w; S( g. C" d, m2 _+ j; c
  4. / a% S" X, G( W
  5. //USART_ClearFlag(USART2,USART_FLAG_TC);, w, ?/ |6 ^3 h
  6.   if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  
    " Y) ?7 i; ]7 u. K' m
  7.   {
    ) Z/ P/ c& }/ X
  8.    USART_RX_BUF[RX_Data++] = USART2->DR;
    ! @" f5 ?' b( U/ C, W  H
  9.   }
    & g  a# i/ i. R
  10.   else if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET)    3 L( G* P; C# V. _$ L$ D7 U) w
  11.   {4 F; B1 E- d4 R! y% M) ]* s
  12.     clear=USART2->SR; //读SR寄存器 可以清空寄存器) v* b0 R1 `9 ]& N5 \" h8 [
  13.          clear=USART2->DR; //读DR寄存器(先读SR寄存器,再读DR,为了清除IDLE中断)      , [( u3 }  ?! j# I. t% @3 R
  14.          ReceiveState=1;   //标记接收到了一帧数据- X) ~8 g  Y# B$ e# u+ W1 y7 s
  15.   }
    & V, f- L( ?8 ?" c; L% ]$ h
  16. }
复制代码

$ l3 \' |. t0 Q7 F, s

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

  1. RETURN_TYPE blue_getTelegram(TEL_RADIO_TYPE *pu8RxRadioTelegram, TEL_PARAM_TYPE *pu8TelParam)
    5 n5 ^. D2 h5 w; x! [$ H  V
  2. {
    ' V( Y* k8 G9 ]9 j  B
  3. // uint8 i=0;; \7 N7 m- s( ?4 w3 t1 K0 f( n  @! g
  4. uint8 u8CRC = 0;
    9 N1 e3 a# H3 d# W, W
  5. uint8 u8Count = 0;
    % |9 g) `0 {, }& g/ |8 n' W
  6. uint8 TmpVal = 0;* n' i7 P2 }& [, ]  T' t, c4 A
  7. uint8 DATA_LEN = 0;
    & `* g2 g' J! F( v- H( s1 _4 p9 n
  8. uint8 n = 0;; _1 d5 V  Q" w5 f, U5 O& s- Z: S
  9. uint8 HEADER_BYTES[4];
    " i9 }4 f& f- Z0 r3 j* R1 _
  10. uint8 DatBuf[30] = {0};
    $ h) u, y# [- H& P% S
  11. u8state = GET_SYNC_STATE;, O  L3 U9 m5 C
  12. if (Read_pt != Enocean_Data){: ~0 q! ]- |& V- T3 p8 Z- L2 S
  13.   delay_ms(7);  //这里的等待就是干等!从收到第一个字节开始干等
    . N, O3 N- B0 \, Q2 L: p6 z0 y/ X6 n
  14.   while (Read_pt != Enocean_Data)
    ( E* _0 T* j" m2 a; d5 @$ o
  15.   {
    # }( A' a3 w" t1 R4 J% W
  16.    TmpVal = USART_Enocean_BUF[Read_pt++];7 I" L/ i: A  [" b
  17.    if(Read_pt >= 100)                        //定义缓存大小,测试时候用100直接替代
    4 R1 U9 I# Y! `1 r# s2 U; ?7 F7 P
  18.      Read_pt = 0;
      v6 P8 d( l4 h" t3 L( r
  19.    switch(u8state)
    7 O+ m* l& h- U9 [2 @
  20.    ...
复制代码

2 i, a) L4 T9 Q8 [( B- |! E

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

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

  1. if(test_data != Enocean_Data){
    . }; e# J, x! J+ E8 _# Q
  2.         HAL_Delay(7);; |5 z0 z1 P+ P) V% v- Q
  3.         // printf("Enocean_Data ID is: 0x %d  test_data is : 0x%d \r\n",Enocean_Data,test_data);- y, {$ V2 s" o0 {
  4.         if(Enocean_Data > 10){
    ) v7 x' L) p0 R
  5.           HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出 8 i& p+ t1 f9 X, O, W5 t4 }
  6.         }      * C5 U3 B* w4 V+ x; a: I0 `3 A
  7.         memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF));   //清空缓存区
    7 U# R1 H# V% ]3 f& I
  8.         Enocean_Data=0;
    ( Q2 n. V) T1 Q8 I  {3 B* d
  9.         // (&hlpuart1)->pRxBuffPtr = &USART_Enocean_BUF[Enocean_Data];//用下面的简洁,数组名就可以当做指针用
    5 _' W/ i1 ]/ K
  10.         (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要,没有这一句,后面接收会出错
    3 T6 R( l9 i8 S8 ~
  11.     }( U" U8 ~5 c0 g- r2 t& i: x
  12.     }
复制代码
, |9 S5 M$ i+ W& j7 N* F! m4 O: @6 l' [

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

  1. HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[0], 1);
复制代码
& C' R8 [, Z3 ^) w& t% S+ ?

现在我们要开启IDLE中断

  1. __HAL_UART_ENABLE_IT(&hlpuart1,UART_IT_IDLE);4 e4 \0 {- p) Y7 S6 F
  2.   HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[0], 1);
复制代码
, B' M& i3 f! H

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

  1. void LPUART1_IRQHandler(void)
      f9 d) R: ]. G' }
  2. {
    3 ^: _+ P1 s* g# y) l, |: p( Y6 M
  3.   /* USER CODE BEGIN LPUART1_IRQn 0 */4 `: |. n" {3 W7 h
  4.   if((__HAL_UART_GET_FLAG(&hlpuart1,UART_FLAG_IDLE) != RESET))( j+ s2 G( [1 ~. s1 i
  5.   {
    3 D2 I1 P/ |3 V9 @
  6.       __HAL_UART_CLEAR_IDLEFLAG(&hlpuart1);" K- Y; ]  m+ W% A8 Y# ~
  7.         ReceiveState = 1;   , Q* ?; [* G% Q$ }
  8.   }  x+ N1 H* k4 e! E6 [2 N
  9.   /* USER CODE END LPUART1_IRQn 0 */, q% O" e  D, V; T5 a7 I& g9 j
  10.   HAL_UART_IRQHandler(&hlpuart1);. V# y" }5 l" ~2 Q* h  `
  11.   /* USER CODE BEGIN LPUART1_IRQn 1 */
      ?, |) |/ n% z- W7 C& ~

  12. . Q7 W* d2 H; s% I, ^: s- w4 F
  13.   /* USER CODE END LPUART1_IRQn 1 */
      G" v9 ^- c+ ~$ L
  14. }
复制代码
% J  _8 U1 ]" I! P

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

  1. if(ReceiveState == 1){: B$ B" f2 j) W, u7 a1 O% F
  2.         ReceiveState = 0;      
    ' f* S) b+ _! G* {& s, d# H
  3.         HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出            ! j( T+ x2 `' j) J# n
  4.         memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF));   //清空缓存区 ' ]# r; W9 V, n" A! q: z
  5.         Enocean_Data=0;
    8 |! ]$ e2 B' k8 Y1 B
  6.         (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要,没有这一句,后面接收会出错
    3 p. ~* A' N; |/ Y# J
  7.     }
复制代码
4 y1 [2 ?5 ]5 ^. _/ N

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

; H9 d! _$ b% ]' U8 `3 E: u) B

微信图片_20230612164617.png


# L7 r5 Z& l% R- p. ?* |2 ^

微信图片_20230612164615.png

! ~2 H4 p' ^: G5 g) B

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

  1. if(ReceiveState == 1){
    : A5 C$ Z! K! G0 ]4 x/ v4 o. n; |
  2.         HAL_Delay(7); //测试,重要
    9 f7 q) d; d8 e6 H$ K, O
  3.         ReceiveState = 0;      
    0 g- A( e2 z5 _# m: t* j
  4.         HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出            ! G& R& K$ o& A+ M0 t! Q
  5.         memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF));   //清空缓存区 : d- ^1 e! X+ R  ^2 m
  6.         Enocean_Data=0;/ I) \5 N" Q  L/ X
  7.         (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要,没有这一句,后面接收会出错3 j' W/ ^: z; k. U6 \. z
  8.     }
复制代码

7 R6 x6 c* P% g

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

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


0 s4 M! A* F" @0 J6 a1 s' x
  1. __HAL_UART_ENABLE_IT(&hlpuart1,UART_IT_IDLE);
复制代码

1 U; G* C. {9 Y2 R2 S' I

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


/ y. A1 I3 p; G6 L

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

  1. void LPUART1_IRQHandler(void)
    ( ~# ]5 e: _) V: i
  2. {
    # S& [# }( o/ |9 x
  3.   /* USER CODE BEGIN LPUART1_IRQn 0 */+ t  R/ y; r/ e5 P- X' R. G
  4.   
    8 b, }% i' g- A# o& K" S
  5.   /* USER CODE END LPUART1_IRQn 0 */0 u, X" K  [& V4 h% }5 Y! A1 v
  6.   HAL_UART_IRQHandler(&hlpuart1);
    3 Q4 ~7 Q2 ]" n: b5 e
  7.   /* USER CODE BEGIN LPUART1_IRQn 1 */
    2 S4 |% A- _6 P* k6 A3 i
  8.   if((__HAL_UART_GET_FLAG(&hlpuart1,UART_FLAG_IDLE) != RESET))
    5 g8 h5 }7 \5 {8 ]/ o  u7 W
  9.   {' {& Y, l1 c* F
  10.     usartreceive_IDLE(&hlpuart1);
    8 S% I$ H8 P8 a3 Z; c1 I" l4 k
  11.   }; Y4 y  w5 w4 s' f, n  t' b
  12.   /* USER CODE END LPUART1_IRQn 1 */
    % |' n# w3 j& l4 h) ?
  13. }
    - c+ p, K; u: b- n
  14.   l- z! T7 T3 Q: q: F' d" u
  15. /* USER CODE BEGIN 1 */  H3 w1 p. ^( z) D0 R# D
  16. void usartreceive_IDLE(UART_HandleTypeDef *huart)
    & H' U  w  d2 n9 K' U9 h* v
  17. {$ O0 Z3 ~5 J1 a! Q! _
  18.   __HAL_UART_CLEAR_IT(&hlpuart1,UART_CLEAR_IDLEF); //清除中断. u$ T% L/ Q7 I" F) _
  19.   // HAL_UART_AbortReceive_IT(huart); //终止接收
    & C9 H" _% Q/ G, E) f' e7 ]
  20.   ReceiveState = 1;
      w$ ^* ]% Q. v3 h' C
  21. }
复制代码

& |  C( k9 r# l$ u9 D. B

用一个标志位表示收到了一帧数据,即便这个一帧不完全,也至少表示收到一段数据了,这里不能加 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);. g" k- x, Y! `! O1 j. {
  2. printf("send command !\r\n");+ i6 Y' ~  V# w4 ]7 }% \$ b
  3. COMMAND_GetmoduleID();* Y5 U- b$ B4 r; e# @5 C  w
  4. // HAL_Delay(10); //7ms不够
    . p" |' a- g9 b7 J9 ^  ]& u, B! w
  5. while ((Enocean_Data - Read_pt) < ID_blueNum);//加了这句不需要加上面的延时,这句就是等待,这句很重要,能够过滤掉不相关的报文# Q) g( V0 W% U0 o% J
  6. // while ((Enocean_Data - Read_pt) < ID_blueNum){
    2 {  o3 w( |: s, x7 g8 U! x( \* ^
  7. //  HAL_UART_Receive_IT(&hlpuart1, &USART_Enocean_BUF[Enocean_Data], 1);
    6 K" v8 v1 d3 |$ x
  8. // }//2021/8/11  不是很懂为什么这里这个while等待必须得加点东西- G- p2 v' M2 x) `8 _7 O
  9. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
复制代码
) h7 X) x1 [+ q7 W8 @

微信图片_20230612164551.png


4 S# G9 ]2 e1 U1 j, P8 M

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

测试代码1(好理解,发送命令了,等待一会,让串口把数据收完):

  1. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
    5 w: Y/ g, {( q
  2. printf("send command !\r\n");. J; g' E+ X+ Y
  3. COMMAND_GetmoduleID();5 i8 i- Z+ M& I  d% d
  4. HAL_Delay(10);//7ms不够 * E' b1 W8 Y) H* N) D# F
  5. while ((Enocean_Data - Read_pt) < ID_blueNum);//加了这句不需要加上面的延时,这句就是等待,这句很重要,能够过滤掉不相关的报文
    + j3 K' T8 Y9 c$ ]4 X
  6. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
复制代码
$ W$ _- N3 f" X! O6 s/ i' z$ K  H

微信图片_20230612164547.png


; y- r; k6 D4 R; n) F8 x9 ]* Y

测试代码2(本来是想看看等待时候打印什么东西,加个条件怕一直循环):

  1. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);) {! ]$ A- `# U
  2. printf("send command !\r\n");
    $ m0 V+ o: J& @* z$ q
  3. COMMAND_GetmoduleID();( ^  B2 F, {4 D% O9 T
  4. while ((Enocean_Data - Read_pt) < ID_blueNum){
    $ e* \/ M0 F8 i  i
  5.   if(Enocean_Data < 10)printf("测试过随便打印点东西都可以!\r\n");
    ! ]' A1 C" ]4 x/ T
  6. }//2021/8/11  不是很懂为什么这里这个while等待必须得加点东西1 {; K2 P  B4 h2 o) V0 K3 I
  7. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
复制代码

- L6 s9 I: T: W

微信图片_20230612164544.png


0 i2 {- f3 n7 ]) P' Z0 l

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

8 X, P/ R- U5 @  U' Z3 C) u

; x1 W6 ~- e7 Q, b

3 Q, ^9 G# R9 U6 |% R
  1. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);/ c8 b# R1 O& f+ G) H  @5 ~' o
  2. printf("send command !\r\n");
    . B5 V+ C  f: `* ^9 k; o6 D4 p: H
  3. COMMAND_GetmoduleID();4 s! I8 C. y/ h
  4. while ((Enocean_Data - Read_pt) < ID_blueNum){
    ( b; }6 T! v# E, z
  5.   printf("不要条件乱打都可以测试过随便打印点东西都可以!\r\n");# A; m& t7 Y6 I: R
  6.   //HAL_Delay(1);//延时可以,1ms就可以
    " I/ a9 t9 T% Y; u; f' Z
  7. }//2021/8/11  不是很懂为什么这里这个while等待必须得加点东西
    ! s4 k6 {6 W, \3 i3 r3 N
  8. printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
复制代码

1 F% N! o  `7 k; u9 }$ b+ q& L; p( g, G  I8 Q: F7 w0 W
$ E7 U$ ?' q8 Z) }- O7 V# P: T, @
2 U) D0 g- R( \2 q/ q# ~9 }7 `7 u
微信图片_20230612164540.png
4 c. `: S& P" {8 _$ r( t. q  N7 P# l& D* x" ~, x# [9 D

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


  R8 m7 {2 t2 b7 k1 L/ m1.2 串口接收发送不定长度的数据(DMA方式)

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

  1. #define USART3_DMA_REC_SIE 256   //DMAbuf空间大小1 x! x) k$ D9 v+ \  j
  2. #define USART3_REC_SIE 512      //接收区空间大小两倍,以保持两条历史数据' t# y1 H; O" B
  3. typedef struct; m1 b; ]3 p: i. @/ C: E
  4. {   
    5 m$ p0 m1 [  A$ m4 T
  5.     uint8_t UsartRecFlag;   //接收数据Flag
    & C: }+ h) t$ I3 O& m1 Y% ~; _# H
  6.     uint16_t UsartDMARecLen; //DMA接收到数据的长度
    9 u2 ]5 {; n# A0 W
  7.     uint16_t UsartRecLen;    //RecBuffer中已经存储数据的长度7 y" c1 ?/ R! V
  8.     uint8_t  Usart3DMARecBuffer[USART3_DMA_REC_SIE];  //dma7 Q7 K% J( V: t) ?4 G7 _* F# R
  9.     uint8_t  Usart3RecBuffer[USART3_REC_SIE];         //RecBuffer- X4 d; W4 E, U/ Y6 {
  10. } Usart3DMAbufstr;
    & R* _6 L1 n. K& T
  11. extern Usart3DMAbufstr Usart3type;  
复制代码
  1. void USART3_IRQHandler(void)
    5 d, _) h+ w; N4 R1 M1 F
  2. {
    0 v1 l8 v: \$ D+ o. a: B$ x9 x4 N
  3.   /* USER CODE BEGIN USART3_IRQn 0 */
    - {! g! g, V$ f: |( H& T$ V/ @
  4. / U# D% |; H; T- d# L
  5.   /* USER CODE END USART3_IRQn 0 */
    % i$ L* m! M5 n. y
  6.   HAL_UART_IRQHandler(&huart3);! l5 n6 c! z. h* q$ _0 D
  7.   /* USER CODE BEGIN USART3_IRQn 1 */6 L2 E  G5 t2 e
  8.   if(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_IDLE) == SET)  //判断空闲中断; I0 z; A/ b+ ~/ j
  9.     {  
    3 D2 E. X5 f3 k
  10.       u16 res = 0;                        
      J7 R2 {; v% m! M
  11.       __HAL_UART_CLEAR_IDLEFLAG(&huart3);       //清楚空闲中断标志6 \1 K& ?  ~7 {" H
  12.       HAL_UART_DMAStop(&huart3);                //暂时关闭DMA中断! k) W) P5 W4 Q1 r
  13.      res = huart3.Instance->ISR;          * a- w6 ]& G4 R4 H8 v- H
  14.       res = huart3.Instance->RDR;              
    % f5 K# ]- W7 z* n% u
  15.       res = hdma_usart3_rx.Instance->NDTR;                     //读取DMA接收的那个buf还剩多少空间" ?5 }2 e+ C" B! |4 |
  16.    Usart3type.UsartDMARecLen = USART3_DMA_REC_SIE - temp;   //总空间减去还剩下的空间等于存入数据的空间大小  4 Z: c# v5 N. f$ Y! g( a
  17.       HAL_UART_RxCpltCallback(&huart3);                     //手动调用中断回调,因为空闲中断不会主动调用6 C2 O% y. w" y, c% Q3 z3 N) w* I
  18.    }1 [" R3 {, z7 @' D# e- @
  19.   /* USER CODE END USART3_IRQn 1 */
    : J5 u0 }% O# B6 q
  20. }
复制代码

# ?. f" J. r- M6 W0 O

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

  1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    7 G! x& H. ^$ p3 y* v
  2. {
    ( k$ [, I: A$ e0 k% P+ ^/ z5 Z
  3.     //可行选着是否开启多条数据缓存,默认不开启,开启删除下划线
    + l: w/ c- o1 O0 E! e# g! w
  4.     if(huart->Instance == USART3)! q; j8 [; J$ ~7 n" y
  5.     {6 M& T' b0 K$ g
  6.       //  if(Usart3type.UsartRecLen>0)//判断RecLen是否清0,如果没有清零代表上一个数据没有读取 9 C( t9 ], Q4 T
  7.       //  {
    6 J; _( t/ P" ^# q
  8.         //    memcpy(&Usart3type.Usart3RecBuffer[Usart3type.UsartRecLen],Usart3type.Usart3DMARecBuffer,Usart3type.UsartDMARecLen); //把数据顺延
    . N- r( ]/ f6 e# _: C8 n( ?
  9.        //     Usart3type.UsartRecLen +=  Usart3type.UsartDMARecLen;//数据长度增加相应的位数
    3 w9 d: z4 ~* l! h: A+ F8 U. k8 J
  10.       //  }  I" Q% v3 h% Y7 ^' f
  11.       //  else
    2 |8 {$ Y4 g5 q  c: N0 H/ I
  12.      //   {
    0 S( ]7 g9 j& K' v3 d' |1 O
  13.             memcpy(Usart3type.Usart3RecBuffer,Usart3type.Usart3DMARecBuffer,Usart3type.UsartDMARecLen);                          //把输入放入buf开头
    , x3 U7 D) g# m) ~# Q
  14.             Usart3type.UsartRecLen =  Usart3type.UsartDMARecLen;        //记录数据长度                  
    % d0 i) U, \: L( `* H$ ~
  15.        // }' o$ H; [& F7 i/ F: w5 f  Y
  16.    
    / {( p/ Z% G& ^
  17.         memset(Usart3type.Usart3DMARecBuffer, 0x00, sizeof(Usart3type.Usart3DMARecBuffer));                                     //把DMA缓存中的数据清空,方便下一次接收
    5 ?4 D" R4 t* {- R3 y9 p) {
  18.         Usart3type.UsartRecFlag = 1;                                                                                            //RecFlag置1,代表RecBuffer中有数据
    4 \& C- y8 |9 V/ U! s9 q8 _4 p
  19.      HAL_UART_Receive_DMA(&huart3,Usart3type.Usart3DMARecBuffer,USART3_DMA_REC_SIE);                                         //重新开启DMA中断,方便再一次接收
    : `6 g* Z) F, w3 n: q" b
  20.     }
    : c" w% ^' n, S7 a! r" ~6 |6 A7 C* b
  21. }
复制代码

! h9 c( X- `: J

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

  1. if(Usart3type.UsartRecFlag == 1)//如果Recbuffer中有数据( Z( q" W' g, w  j) y' ~
  2. {
    , _8 H5 y8 \7 T; i- V
  3. HAL_UART_Transmit(&huart1,Usart3type.Usart3RecBuffer,256,0xffff);//把RecBuffer中的数据发送到串口1# j- }9 k4 m& k; q
  4. memset(Usart3type.Usart3RecBuffer, 0x00, sizeof(Usart3type.Usart3RecBuffer));//读取完数据后记得一定要把RecBuffer中的数据清除0 W/ h# e) o/ Z2 S6 c) Q
  5. Usart3type.UsartRecFlag = 0;//标志位清0
    * p) o3 |2 m+ h$ v7 u
  6. Usart3type.UsartRecLen = 0;//已有数据长度清09 v& \  H1 `6 J- p( M) @0 m
  7. }
复制代码
4 V! Y& G( }9 h- @3 W
1.3 环形缓冲区

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


7 w0 ?) X. o1 M9 w% z2 ^5 Z4 w, W二、串口接收卡死处理

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

2.1 清除错误标志位

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

, x2 q- U; O( P/ l" t+ C, X& Q

微信图片_20230612164537.png

2 [+ F" ^* F2 ^7 r

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

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


' p% ~; S$ ]. k# ~% [
  1. __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_PE);//清标志$ R0 H6 c, g& G! R! _
  2. __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_FE);( A$ j/ B; f! `  y* F' O9 y5 D5 d/ b
  3. __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_NE);, a2 W9 s0 O; Y
  4. __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_ORE);
复制代码
5 y# \. F, |: B$ n' Q5 x

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


) w1 W5 ]% Y5 g$ t4 r

& e1 Q$ f5 \: v9 o1 W 微信图片_20230612164533.png
/ x( Y: W' P5 u* n
& h' b: F3 O8 C9 R' b

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


+ h$ K& K" I2 y2 x" t7 x2.2 HAL 库函数问题

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

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

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

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


: |" a  f: t/ _5 V3 R 微信图片_20230612164530.png
. w# S4 v+ y& m( I: R
" T: J* {! p# l. u5 d$ \7 w

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

$ W) h8 }0 [( f( p" n

2 k5 O. U. A/ ~8 b6 i1 x; p 微信图片_20230612164527.png
: r$ Y( C( e$ b/ v( V: m6 f8 [: S: D

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

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

/ D& Y7 R: b2 N8 m$ z% d

微信图片_20230612164511.png

3 m6 `6 c4 n6 {0 b! p3 B; B

判断的语句如下:

  1. if(huart->Instance == LPUART1){; T. q7 f9 h3 C; M
  2.     Enocean_Data++;
    ( W2 E+ p3 n& f( r+ V
  3.     if(Enocean_Data > 98)Enocean_Data = 0;
    5 \: T. V7 I$ i5 s$ \
  4.     while(HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[Enocean_Data], 1) != HAL_OK){
    ) n( K7 y, L7 [
  5.       hlpuart1.RxState = HAL_UART_STATE_READY;
    % V7 R+ a" _9 Y; ]1 |% q# I1 ~9 `; u
  6.       __HAL_UNLOCK(&hlpuart1);, ~' t/ h6 j2 B" C
  7.     }
    # J0 S% ~$ y6 W/ n
  8.   }
复制代码
9 @. O$ D% k/ i- Q: L3 |

如有侵权请联系删除% c$ K; I0 [! a, N- p

转载自: 矜辰所致

* c' z$ h6 G! l3 E# i
赞 收藏 评论0 发布时间:2023-6-12 16:46

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版