|
前言 早些时候写的一些测试记录的文章,并没有完全是以那种教材的方式写的,所以相对于最新的文章,整体格式框架可能没那么好。 好的一面是,我是实打实的实际应用记录,每次遇到问题会来重新更新文章,做新的记录! 经过前面一段时间的测试,我们把STM32L051 的需要用到的基本功能都测试过了,这次我们得把产品替换成L051了。 基本的IO使用都没问题,数据存储EEPROM和flash也没有问题,测试过正常用就可以了(实际上后来 EEPROM折腾了好久),在串口的使用上,也需要测试一下。 这里贴的代码是我测试流程使用过的代码,当时的文章以记录各种测试数据为主,仅供参考!
$ @" G& x! |* V4 r" ]* s一、串口接收处理的几种方式1.1 串口接收发送不定长度的数据(非DMA方式)以前在在标准库STM32F103标准库的使用上用到的IDLE中断接收一帧数据,测试用起来确实好用 - void USART2_IRQHandler(void) //串口2中断服务程序 m9 } d O ^ l
- {( T" |, R# z. O- N, a
- u8 clear=clear; //消除编译器没有用到的提醒 f" g( w; S( g. C" d, m2 _+ j; c
- / a% S" X, G( W
- //USART_ClearFlag(USART2,USART_FLAG_TC);, w, ?/ |6 ^3 h
- if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
" Y) ?7 i; ]7 u. K' m - {
) Z/ P/ c& }/ X - USART_RX_BUF[RX_Data++] = USART2->DR;
! @" f5 ?' b( U/ C, W H - }
& g a# i/ i. R - else if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET) 3 L( G* P; C# V. _$ L$ D7 U) w
- {4 F; B1 E- d4 R! y% M) ]* s
- clear=USART2->SR; //读SR寄存器 可以清空寄存器) v* b0 R1 `9 ]& N5 \" h8 [
- clear=USART2->DR; //读DR寄存器(先读SR寄存器,再读DR,为了清除IDLE中断) , [( u3 } ?! j# I. t% @3 R
- ReceiveState=1; //标记接收到了一帧数据- X) ~8 g Y# B$ e# u+ W1 y7 s
- }
& V, f- L( ?8 ?" c; L% ]$ h - }
复制代码
$ l3 \' |. t0 Q7 F, s不需要自己做延时处理,在某些情况下,比如通讯模块的串口3使用中,还是用到了延时处理,具体就是判断串口是否接收到一个字节的数据?如果接收到一个字节的数据,那么延时一定时间,一般是几毫秒(这个延时时间就是干等,等待这一串数据全部接收完成,所以这个时间需要实际使用中不同的测试优化,干等时间太长了不太合理,太短数据接收不完全处理起来会出错),如下: - RETURN_TYPE blue_getTelegram(TEL_RADIO_TYPE *pu8RxRadioTelegram, TEL_PARAM_TYPE *pu8TelParam)
5 n5 ^. D2 h5 w; x! [$ H V - {
' V( Y* k8 G9 ]9 j B - // uint8 i=0;; \7 N7 m- s( ?4 w3 t1 K0 f( n @! g
- uint8 u8CRC = 0;
9 N1 e3 a# H3 d# W, W - uint8 u8Count = 0;
% |9 g) `0 {, }& g/ |8 n' W - uint8 TmpVal = 0;* n' i7 P2 }& [, ] T' t, c4 A
- uint8 DATA_LEN = 0;
& `* g2 g' J! F( v- H( s1 _4 p9 n - uint8 n = 0;; _1 d5 V Q" w5 f, U5 O& s- Z: S
- uint8 HEADER_BYTES[4];
" i9 }4 f& f- Z0 r3 j* R1 _ - uint8 DatBuf[30] = {0};
$ h) u, y# [- H& P% S - u8state = GET_SYNC_STATE;, O L3 U9 m5 C
- if (Read_pt != Enocean_Data){: ~0 q! ]- |& V- T3 p8 Z- L2 S
- delay_ms(7); //这里的等待就是干等!从收到第一个字节开始干等
. N, O3 N- B0 \, Q2 L: p6 z0 y/ X6 n - while (Read_pt != Enocean_Data)
( E* _0 T* j" m2 a; d5 @$ o - {
# }( A' a3 w" t1 R4 J% W - TmpVal = USART_Enocean_BUF[Read_pt++];7 I" L/ i: A [" b
- if(Read_pt >= 100) //定义缓存大小,测试时候用100直接替代
4 R1 U9 I# Y! `1 r# s2 U; ?7 F7 P - Read_pt = 0;
v6 P8 d( l4 h" t3 L( r - switch(u8state)
7 O+ m* l& h- U9 [2 @ - ...
复制代码
2 i, a) L4 T9 Q8 [( B- |! E自己也使用过环形缓冲区等一些方式进行优化,可能目前的处理方式能够满足大部分功能需求,所以也没有确实的花心思正真去测试优化一个环形缓冲区的使用。 那么现在再L051下面,我们怎么来使用 IDLE 中断呢? 当然我先去网上查找了大神们的各种帖子,然后还是得自己修改一下程序,来一步一步做测试,先回到串口接收简单的测试: - if(test_data != Enocean_Data){
. }; e# J, x! J+ E8 _# Q - HAL_Delay(7);; |5 z0 z1 P+ P) V% v- Q
- // printf("Enocean_Data ID is: 0x %d test_data is : 0x%d \r\n",Enocean_Data,test_data);- y, {$ V2 s" o0 {
- if(Enocean_Data > 10){
) v7 x' L) p0 R - HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出 8 i& p+ t1 f9 X, O, W5 t4 }
- } * C5 U3 B* w4 V+ x; a: I0 `3 A
- memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF)); //清空缓存区
7 U# R1 H# V% ]3 f& I - Enocean_Data=0;
( Q2 n. V) T1 Q8 I {3 B* d - // (&hlpuart1)->pRxBuffPtr = &USART_Enocean_BUF[Enocean_Data];//用下面的简洁,数组名就可以当做指针用
5 _' W/ i1 ]/ K - (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要,没有这一句,后面接收会出错
3 T6 R( l9 i8 S8 ~ - }( U" U8 ~5 c0 g- r2 t& i: x
- }
复制代码 , |9 S5 M$ i+ W& j7 N* F! m4 O: @6 l' [
在主函数初始化串口后,有这么一句,打开串口中断(这里的中断可不可以理解为打开IT中断) - HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[0], 1);
复制代码 & C' R8 [, Z3 ^) w& t% S+ ?
现在我们要开启IDLE中断 - __HAL_UART_ENABLE_IT(&hlpuart1,UART_IT_IDLE);4 e4 \0 {- p) Y7 S6 F
- 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中断后操作的函数: - void LPUART1_IRQHandler(void)
f9 d) R: ]. G' } - {
3 ^: _+ P1 s* g# y) l, |: p( Y6 M - /* USER CODE BEGIN LPUART1_IRQn 0 */4 `: |. n" {3 W7 h
- if((__HAL_UART_GET_FLAG(&hlpuart1,UART_FLAG_IDLE) != RESET))( j+ s2 G( [1 ~. s1 i
- {
3 D2 I1 P/ |3 V9 @ - __HAL_UART_CLEAR_IDLEFLAG(&hlpuart1);" K- Y; ] m+ W% A8 Y# ~
- ReceiveState = 1; , Q* ?; [* G% Q$ }
- } x+ N1 H* k4 e! E6 [2 N
- /* USER CODE END LPUART1_IRQn 0 */, q% O" e D, V; T5 a7 I& g9 j
- HAL_UART_IRQHandler(&hlpuart1);. V# y" }5 l" ~2 Q* h `
- /* USER CODE BEGIN LPUART1_IRQn 1 */
?, |) |/ n% z- W7 C& ~
. Q7 W* d2 H; s% I, ^: s- w4 F- /* USER CODE END LPUART1_IRQn 1 */
G" v9 ^- c+ ~$ L - }
复制代码 % J _8 U1 ]" I! P
用 ReceiveState 来标志是否接受到了一串数据,然后打印函数变成 - if(ReceiveState == 1){: B$ B" f2 j) W, u7 a1 O% F
- ReceiveState = 0;
' f* S) b+ _! G* {& s, d# H - HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出 ! j( T+ x2 `' j) J# n
- memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF)); //清空缓存区 ' ]# r; W9 V, n" A! q: z
- Enocean_Data=0;
8 |! ]$ e2 B' k8 Y1 B - (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要,没有这一句,后面接收会出错
3 p. ~* A' N; |/ Y# J - }
复制代码 4 y1 [2 ?5 ]5 ^. _/ N
结果, 数据异常,就是收不全,结尾会有问题,明天得继续测试优化了,先上个正常的接收,这是上面用HAL_Delay(7)测试得到的正常结果。 ; H9 d! _$ b% ]' U8 `3 E: u) B
# L7 r5 Z& l% R- p. ?* |2 ^
! ~2 H4 p' ^: G5 g) B
实际测试,数据会断接收不全,考虑了一下,是否本身我的通讯模组串口给MCU的时候一包数据就是分两次发送(其实就是一包数据中间有个时间会长一点,然后MCU判定为2帧数据,每次能够收到开头的一段), 我测试的打印函数每次收到一包数据,都会把数据全部打印出来,然后清空缓存区,所以下一包数据直接被清掉了,因为在进行输出的过程,可能下一包的数据中断进来了,为了验证一下,还是加上了一个延时,代码改成如下: - if(ReceiveState == 1){
: A5 C$ Z! K! G0 ]4 x/ v4 o. n; | - HAL_Delay(7); //测试,重要
9 f7 q) d; d8 e6 H$ K, O - ReceiveState = 0;
0 g- A( e2 z5 _# m: t* j - HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF); //将串口3接收到的数据通过串口1传出 ! G& R& K$ o& A+ M0 t! Q
- memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF)); //清空缓存区 : d- ^1 e! X+ R ^2 m
- Enocean_Data=0;/ I) \5 N" Q L/ X
- (&hlpuart1)->pRxBuffPtr = USART_Enocean_BUF;//这一句很重要,没有这一句,后面接收会出错3 j' W/ ^: z; k. U6 \. z
- }
复制代码
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- __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 L2、在stm32l0xx_it.c 文件中响应的中断相应函数LPUART1_IRQHandler 中加入关于IDLE中断的处理于语句: - void LPUART1_IRQHandler(void)
( ~# ]5 e: _) V: i - {
# S& [# }( o/ |9 x - /* USER CODE BEGIN LPUART1_IRQn 0 */+ t R/ y; r/ e5 P- X' R. G
-
8 b, }% i' g- A# o& K" S - /* USER CODE END LPUART1_IRQn 0 */0 u, X" K [& V4 h% }5 Y! A1 v
- HAL_UART_IRQHandler(&hlpuart1);
3 Q4 ~7 Q2 ]" n: b5 e - /* USER CODE BEGIN LPUART1_IRQn 1 */
2 S4 |% A- _6 P* k6 A3 i - if((__HAL_UART_GET_FLAG(&hlpuart1,UART_FLAG_IDLE) != RESET))
5 g8 h5 }7 \5 {8 ]/ o u7 W - {' {& Y, l1 c* F
- usartreceive_IDLE(&hlpuart1);
8 S% I$ H8 P8 a3 Z; c1 I" l4 k - }; Y4 y w5 w4 s' f, n t' b
- /* USER CODE END LPUART1_IRQn 1 */
% |' n# w3 j& l4 h) ? - }
- c+ p, K; u: b- n - l- z! T7 T3 Q: q: F' d" u
- /* USER CODE BEGIN 1 */ H3 w1 p. ^( z) D0 R# D
- void usartreceive_IDLE(UART_HandleTypeDef *huart)
& H' U w d2 n9 K' U9 h* v - {$ O0 Z3 ~5 J1 a! Q! _
- __HAL_UART_CLEAR_IT(&hlpuart1,UART_CLEAR_IDLEF); //清除中断. u$ T% L/ Q7 I" F) _
- // HAL_UART_AbortReceive_IT(huart); //终止接收
& C9 H" _% Q/ G, E) f' e7 ] - ReceiveState = 1;
w$ ^* ]% Q. v3 h' C - }
复制代码
& | C( k9 r# l$ u9 D. B用一个标志位表示收到了一帧数据,即便这个一帧不完全,也至少表示收到一段数据了,这里不能加 HAL_UART_AbortReceive_IT(huart); //终止接收 ,因为IT中断可以继续接收,如果终止了,数据处理不够及时,下一帧数据就收不到了。 3、最后通过判断标志位 ReceiveState 来处理数据,一般情况下直接处理,特除情况,在标志位至1 后,刻意的等待几个毫秒,等待数据接收完全再处理。 !!!最后移植又发现一个问题代码中 #define ID_blueNum 44 - printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);. g" k- x, Y! `! O1 j. {
- printf("send command !\r\n");+ i6 Y' ~ V# w4 ]7 }% \$ b
- COMMAND_GetmoduleID();* Y5 U- b$ B4 r; e# @5 C w
- // HAL_Delay(10); //7ms不够
. p" |' a- g9 b7 J9 ^ ]& u, B! w - while ((Enocean_Data - Read_pt) < ID_blueNum);//加了这句不需要加上面的延时,这句就是等待,这句很重要,能够过滤掉不相关的报文# Q) g( V0 W% U0 o% J
- // while ((Enocean_Data - Read_pt) < ID_blueNum){
2 { o3 w( |: s, x7 g8 U! x( \* ^ - // HAL_UART_Receive_IT(&hlpuart1, &USART_Enocean_BUF[Enocean_Data], 1);
6 K" v8 v1 d3 |$ x - // }//2021/8/11 不是很懂为什么这里这个while等待必须得加点东西- G- p2 v' M2 x) `8 _7 O
- printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
复制代码 ) h7 X) x1 [+ q7 W8 @
4 S# G9 ]2 e1 U1 j, P8 M如果按照上面的代码,会一直卡在这里过不去,其实就是while ((Enocean_Data - Read_pt) < ID_blueNum);过不去,开始怀疑是不是通讯模块本来就是坏的,我们有多种方式测试: 测试代码1(好理解,发送命令了,等待一会,让串口把数据收完): - printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
5 w: Y/ g, {( q - printf("send command !\r\n");. J; g' E+ X+ Y
- COMMAND_GetmoduleID();5 i8 i- Z+ M& I d% d
- HAL_Delay(10);//7ms不够 * E' b1 W8 Y) H* N) D# F
- while ((Enocean_Data - Read_pt) < ID_blueNum);//加了这句不需要加上面的延时,这句就是等待,这句很重要,能够过滤掉不相关的报文
+ j3 K' T8 Y9 c$ ]4 X - 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
; y- r; k6 D4 R; n) F8 x9 ]* Y 测试代码2(本来是想看看等待时候打印什么东西,加个条件怕一直循环):
- printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);) {! ]$ A- `# U
- printf("send command !\r\n");
$ m0 V+ o: J& @* z$ q - COMMAND_GetmoduleID();( ^ B2 F, {4 D% O9 T
- while ((Enocean_Data - Read_pt) < ID_blueNum){
$ e* \/ M0 F8 i i - if(Enocean_Data < 10)printf("测试过随便打印点东西都可以!\r\n");
! ]' A1 C" ]4 x/ T - }//2021/8/11 不是很懂为什么这里这个while等待必须得加点东西1 {; K2 P B4 h2 o) V0 K3 I
- printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);
复制代码
- L6 s9 I: T: W
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- printf("Enocean_Data is :%d Read_pt is :%d\n\r",Enocean_Data,Read_pt);/ c8 b# R1 O& f+ G) H @5 ~' o
- printf("send command !\r\n");
. B5 V+ C f: `* ^9 k; o6 D4 p: H - COMMAND_GetmoduleID();4 s! I8 C. y/ h
- while ((Enocean_Data - Read_pt) < ID_blueNum){
( b; }6 T! v# E, z - printf("不要条件乱打都可以测试过随便打印点东西都可以!\r\n");# A; m& t7 Y6 I: R
- //HAL_Delay(1);//延时可以,1ms就可以
" I/ a9 t9 T% Y; u; f' Z - }//2021/8/11 不是很懂为什么这里这个while等待必须得加点东西
! s4 k6 {6 W, \3 i3 r3 N - 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
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系列中使用的例程,以前也是在网上参考过其他人的设计然后自己用起来的,正好也在这里做个笔记 - #define USART3_DMA_REC_SIE 256 //DMAbuf空间大小1 x! x) k$ D9 v+ \ j
- #define USART3_REC_SIE 512 //接收区空间大小两倍,以保持两条历史数据' t# y1 H; O" B
- typedef struct; m1 b; ]3 p: i. @/ C: E
- {
5 m$ p0 m1 [ A$ m4 T - uint8_t UsartRecFlag; //接收数据Flag
& C: }+ h) t$ I3 O& m1 Y% ~; _# H - uint16_t UsartDMARecLen; //DMA接收到数据的长度
9 u2 ]5 {; n# A0 W - uint16_t UsartRecLen; //RecBuffer中已经存储数据的长度7 y" c1 ?/ R! V
- uint8_t Usart3DMARecBuffer[USART3_DMA_REC_SIE]; //dma7 Q7 K% J( V: t) ?4 G7 _* F# R
- uint8_t Usart3RecBuffer[USART3_REC_SIE]; //RecBuffer- X4 d; W4 E, U/ Y6 {
- } Usart3DMAbufstr;
& R* _6 L1 n. K& T - extern Usart3DMAbufstr Usart3type;
复制代码- void USART3_IRQHandler(void)
5 d, _) h+ w; N4 R1 M1 F - {
0 v1 l8 v: \$ D+ o. a: B$ x9 x4 N - /* USER CODE BEGIN USART3_IRQn 0 */
- {! g! g, V$ f: |( H& T$ V/ @ - / U# D% |; H; T- d# L
- /* USER CODE END USART3_IRQn 0 */
% i$ L* m! M5 n. y - HAL_UART_IRQHandler(&huart3);! l5 n6 c! z. h* q$ _0 D
- /* USER CODE BEGIN USART3_IRQn 1 */6 L2 E G5 t2 e
- if(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_IDLE) == SET) //判断空闲中断; I0 z; A/ b+ ~/ j
- {
3 D2 E. X5 f3 k - u16 res = 0;
J7 R2 {; v% m! M - __HAL_UART_CLEAR_IDLEFLAG(&huart3); //清楚空闲中断标志6 \1 K& ? ~7 {" H
- HAL_UART_DMAStop(&huart3); //暂时关闭DMA中断! k) W) P5 W4 Q1 r
- res = huart3.Instance->ISR; * a- w6 ]& G4 R4 H8 v- H
- res = huart3.Instance->RDR;
% f5 K# ]- W7 z* n% u - res = hdma_usart3_rx.Instance->NDTR; //读取DMA接收的那个buf还剩多少空间" ?5 }2 e+ C" B! |4 |
- Usart3type.UsartDMARecLen = USART3_DMA_REC_SIE - temp; //总空间减去还剩下的空间等于存入数据的空间大小 4 Z: c# v5 N. f$ Y! g( a
- HAL_UART_RxCpltCallback(&huart3); //手动调用中断回调,因为空闲中断不会主动调用6 C2 O% y. w" y, c% Q3 z3 N) w* I
- }1 [" R3 {, z7 @' D# e- @
- /* USER CODE END USART3_IRQn 1 */
: J5 u0 }% O# B6 q - }
复制代码
# ?. f" J. r- M6 W0 O数据最初都存储在DMARecBuffer中,然后转存到RecBuffer中。DMARecBuffer中的数据每接收到新的数据都会清空。 - void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
7 G! x& H. ^$ p3 y* v - {
( k$ [, I: A$ e0 k% P+ ^/ z5 Z - //可行选着是否开启多条数据缓存,默认不开启,开启删除下划线
+ l: w/ c- o1 O0 E! e# g! w - if(huart->Instance == USART3)! q; j8 [; J$ ~7 n" y
- {6 M& T' b0 K$ g
- // if(Usart3type.UsartRecLen>0)//判断RecLen是否清0,如果没有清零代表上一个数据没有读取 9 C( t9 ], Q4 T
- // {
6 J; _( t/ P" ^# q - // memcpy(&Usart3type.Usart3RecBuffer[Usart3type.UsartRecLen],Usart3type.Usart3DMARecBuffer,Usart3type.UsartDMARecLen); //把数据顺延
. N- r( ]/ f6 e# _: C8 n( ? - // Usart3type.UsartRecLen += Usart3type.UsartDMARecLen;//数据长度增加相应的位数
3 w9 d: z4 ~* l! h: A+ F8 U. k8 J - // } I" Q% v3 h% Y7 ^' f
- // else
2 |8 {$ Y4 g5 q c: N0 H/ I - // {
0 S( ]7 g9 j& K' v3 d' |1 O - memcpy(Usart3type.Usart3RecBuffer,Usart3type.Usart3DMARecBuffer,Usart3type.UsartDMARecLen); //把输入放入buf开头
, x3 U7 D) g# m) ~# Q - Usart3type.UsartRecLen = Usart3type.UsartDMARecLen; //记录数据长度
% d0 i) U, \: L( `* H$ ~ - // }' o$ H; [& F7 i/ F: w5 f Y
-
/ {( p/ Z% G& ^ - memset(Usart3type.Usart3DMARecBuffer, 0x00, sizeof(Usart3type.Usart3DMARecBuffer)); //把DMA缓存中的数据清空,方便下一次接收
5 ?4 D" R4 t* {- R3 y9 p) { - Usart3type.UsartRecFlag = 1; //RecFlag置1,代表RecBuffer中有数据
4 \& C- y8 |9 V/ U! s9 q8 _4 p - HAL_UART_Receive_DMA(&huart3,Usart3type.Usart3DMARecBuffer,USART3_DMA_REC_SIE); //重新开启DMA中断,方便再一次接收
: `6 g* Z) F, w3 n: q" b - }
: c" w% ^' n, S7 a! r" ~6 |6 A7 C* b - }
复制代码
! h9 c( X- `: J在相应的程序中把上面的代码添加好,然后在主函数循环中使用,RecBuffer中的数据会一直增加,直到用户读取以后才会清空: - if(Usart3type.UsartRecFlag == 1)//如果Recbuffer中有数据( Z( q" W' g, w j) y' ~
- {
, _8 H5 y8 \7 T; i- V - HAL_UART_Transmit(&huart1,Usart3type.Usart3RecBuffer,256,0xffff);//把RecBuffer中的数据发送到串口1# j- }9 k4 m& k; q
- memset(Usart3type.Usart3RecBuffer, 0x00, sizeof(Usart3type.Usart3RecBuffer));//读取完数据后记得一定要把RecBuffer中的数据清除0 W/ h# e) o/ Z2 S6 c) Q
- Usart3type.UsartRecFlag = 0;//标志位清0
* p) o3 |2 m+ h$ v7 u - Usart3type.UsartRecLen = 0;//已有数据长度清09 v& \ H1 `6 J- p( M) @0 m
- }
复制代码 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
2 [+ F" ^* F2 ^7 r
出错的时候,HAL库会把以上flag置位如果不清除就再也接收不到数据了。 所以我们可以在需要的时候使用,下面的语句清除错误标志:
' p% ~; S$ ]. k# ~% [- __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_PE);//清标志$ R0 H6 c, g& G! R! _
- __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_FE);( A$ j/ B; f! ` y* F' O9 y5 D5 d/ b
- __HAL_UART_CLEAR_FLAG(&hlpuart1, UART_FLAG_NE);, a2 W9 s0 O; Y
- __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
/ 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
. 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
: r$ Y( C( e$ b/ v( V: m6 f8 [: S: D
里面有个加锁操作,正式因为这个加锁操作,如果收发同时进行,会有概率卡死。 这个时候的处理方式就是手动解锁,每次接收到一个字节后需要再次开启中断接收,判断一下是否有错误: / D& Y7 R: b2 N8 m$ z% d
3 m6 `6 c4 n6 {0 b! p3 B; B
判断的语句如下: - if(huart->Instance == LPUART1){; T. q7 f9 h3 C; M
- Enocean_Data++;
( W2 E+ p3 n& f( r+ V - if(Enocean_Data > 98)Enocean_Data = 0;
5 \: T. V7 I$ i5 s$ \ - while(HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[Enocean_Data], 1) != HAL_OK){
) n( K7 y, L7 [ - hlpuart1.RxState = HAL_UART_STATE_READY;
% V7 R+ a" _9 Y; ]1 |% q# I1 ~9 `; u - __HAL_UNLOCK(&hlpuart1);, ~' t/ h6 j2 B" C
- }
# J0 S% ~$ y6 W/ n - }
复制代码 9 @. O$ D% k/ i- Q: L3 |
如有侵权请联系删除% c$ K; I0 [! a, N- p
转载自: 矜辰所致 * c' z$ h6 G! l3 E# i
|