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

【经验分享】STM32 HAL CubeMX 串口IDLE接收空闲中断+DMA

[复制链接]
STMCU小助手 发布时间:2022-3-23 17:00
本篇文章提供两种方法:
3 b1 H2 R9 j( O2 W- w1 ~& D5 n一种是 :IDLE 接收空闲中断+DMA
9 A5 V/ p$ ^) T$ [! }一种是: IDLE 接收空闲中断+RXNE接收数据中断8 i" e& j1 s- {9 e; F
0 ]' p1 A. b4 H6 o% S4 k
都可完成串口数据的收发% \# h3 b' P' }

$ u1 O, k5 J; o: [' {知识点介绍:* A, l; l& h' ^& V
STM32 IDLE 接收空闲中断

) w- d& {$ W7 A功能:% \8 a7 G( S4 q
在使用串口接受字符串时,可以使用空闲中断(IDLEIE置1,即可使能空闲中断),这样在接收完一个字符串,进入空闲状态时(IDLE置1)便会激发一个空闲中断。在中断处理函数,我们可以解析这个字符串。
7 y/ w! V4 D" {1 q) G% `9 ?& P# P; q- d7 G+ A: g
接受完一帧数据,触发中断; f7 A5 V6 N$ q7 Z& Z9 I

! l5 u8 \: F# s: BSTM32的IDLE的中断产生条件:+ `0 g$ P/ P5 q1 J
在串口无数据接收的情况下,不会产生,当清除IDLE标志位后,必须有接收到第一个数据后,才开始触发,一但接收的数据断流,没有接收到数据,即产生IDLE中断
$ r% C8 Y* N% X) x7 F% o. f( _
# \  e3 [& N, [7 {& pSTM32 RXNE接收数据中断
( h' e3 e7 n2 m3 j: ]- z; j功能:
5 h0 h4 `0 G9 Q' c% u5 n% V$ s当串口接收到一个bit的数据时,(读取到一个停止位) 便会触发 RXNE接收数据中断
" U  O/ p$ L7 A2 N0 }) u) s/ y
3 T) J9 I1 \. F+ {' U" b4 l接受到一个字节的数据,触发中断
; F' p) O% i  O9 n5 ~: W& [' k) F( L; i
比如给上位机给单片机一次性发送了8个字节,就会产生8次RXNE中断,1次IDLE中断。4 ]" K  G/ d% {7 p0 q

4 v) @! M7 y/ [# Q& O; D串口CR1寄存器) x! [; y5 y) l

- \, T4 U/ }% l* x0 Q- W5 t KPGP$%K4Z`P]5~NPWSBD91K.png
+ `& n1 E/ O: X) U2 L
# x' ~3 G! }( o4 H对bit4写1开启IDLE接受空闲中断
5 I' M) k& o, K! R/ g2 _( a8 O, D,对bit5写1开启RXNE接收数据中断。$ H6 G! f3 i7 h; \+ f

! g- R+ q. E( G. f4 U; |+ W3 m' e串口ISR寄存器$ x6 D8 P& c4 @

, f8 o, ]1 b9 B. s$ u L%TE0SWP0~FE)I7T4TOEER9.png
9 X) X1 C- i2 v* ^/ K, z9 W9 q. W1 Q6 D0 ^
此寄存器为串口状态查询寄存器
8 `8 L& X2 H' D- R/ c
: l* W" M( S3 ?7 u$ w4 I当串口接收到数据时,bit5 RXNE就会自动变成1,当接收完一帧数据后,bit4就会变成1.
) \# Q* x+ T0 b- k6 O. g7 E# `1 }, t- t7 U8 p, D
清除RXNE中断标志位的方法为:' M1 z$ A2 o4 Q/ a
8 w+ i, u& q* M* C- @
只要把接收到的一个字节读出来,就会清除这个中断
5 P5 }# L5 \; L; n# O/ v
, `. G) M8 B# R: v( r' l在STM32F1 /STM32F4 系列中 清除IDLE中断标志位的方法为:
9 q% x/ {2 Q) I9 u) B. u. F6 V
/ ^& s; A/ G3 e: H1.先读SR寄存器,
3 E% O1 L9 f* P4 D% J* h/ Z3 U& Q2.再读DR寄存器。

" m8 l, v1 i& M. [3 _( Q3 v7 ]( B/ L9 T. \! `! Z; Q
3F]Q2F56KOVOR(9K8AF{TS2.png ' M) A" p% G9 h7 }' N/ N- K! S2 z

: j( v- Z# P  F% _# Rmemset()函数
% v& c5 Z3 p. T7 `* f6 s; ?" v
! D( U: D5 C  @# N- U; V
  1. extern void *memset(void *buffer, int c, int count)        
复制代码
: t4 A2 Z. v  X) y$ _- F' }* R
buffer:为指针或是数组
" H. N8 O" i- V1 B+ R& qc:是赋给buffer的值
/ D' x- v1 u4 ?count:是buffer的长度./ M% o! E+ u' A
USART采用DMA接收时,如何读取当前接收字节数?8 c5 y6 A3 c3 x
  1.    #define __HAL_DMA_GET_COUNTER(__HANDLE__) ((__HANDLE__)->Instance->CNDTR);
复制代码

# @/ }3 b  |9 w9 n& U- f) Q- ]DMA接收时该宏将返回当前接收空间剩余字节
$ ^- E" c- E$ M. N
) s$ ]9 c. O; ^2 F, k2 Q实际接受的字节= 预先定义的接收总字节 - __HAL_DMA_GET_COUNTER()
) V- X/ i7 f& ~5 i' I
* T! L4 j' o  @* y. k0 [# l其本质就是读取NTDR寄存器,DMA通道结构体中定义了NDTR寄存器,读取该寄存器即可得到未传输的数据数呢,3 I. E9 `2 a% J: [- I' D
% q7 i% T: d/ P# t3 l6 v
NTDR寄存器
7 }$ a: h$ D# X4 X: v. A) p1 Q' d- `& E- R+ |" c$ }
_[`8QZUY((Y87)B8BSJ36}B.png
. z$ w% ]+ ?3 i6 M  d* q7 l1 d/ a+ f. |9 K
实现方法:3 ^1 E7 k/ d6 K! y3 p
两种利用串口IDLE空闲中断的方式接收一帧数据,方法如下:; [  l* G% M6 _" T
* t9 P7 N- S$ q, L. q6 u) a* p
方法1:实现思路:采用STM32F103的串口1,并配置成空闲中断IDLE模式且使能DMA接收,并同时设置接收缓冲区和初始化DMA。那么初始化完成之后,当外部给单片机发送数据的时候,假设这次接受的数据长度是200个字节,那么在单片机接收到一个字节的时候并不会产生串口中断,而是DMA在后台把数据默默地搬运到你指定的缓冲区数组里面。当整帧数据发送完毕之后串口才会产生一次中断,此时可以利用__HAL_DMA_GET_COUNTER(&hdma_usart1_rx);函数计算出当前DMA接收存储空间剩余字节# O' |+ E' }6 J% Y* k' Y: ]! h

- @$ E- A; L0 J% d6 c; b本次的数据接受长度=预先定义的接收总字节-接收存储空间剩余字节
, L: ^2 A2 y: \) ^6 O# D" w8 A' T7 v5 k- }
比方说 本次串口接受200个字节,
( v% @, S' N/ i) C, i* q7 y- G
  1. HAL_UART_Receive_DMA(&huart1,rx_buffer,200);//打开DMA接收
复制代码

4 [0 k1 T% n$ O4 q然后我发送了 Zxiaoxuan 9个字节的数据长度, O( A1 J' W) W* m
# y* D% x, o+ k. i, Y
那么此时 GET_COUNTER函数读出来 接收存储空间剩余字节 就是191个字节
0 [6 B; A7 ^0 V% z3 X1 N$ W
, u$ [% _) `4 N; Y% e. W( |实际接受的字节(9) = 预先定义的接收总字节(200) - __HAL_DMA_GET_COUNTER()(191)# A8 H% x" F, U( R9 t
9 = 200-191) Z/ Z- Z9 t6 L+ s8 l
, u  ], C8 {  x3 L3 _) ~  S
应用对象:适用于各种串口相关的通信协议,如:MODBUS,PPI ;还有类似于GPS数据接收解析,串口WIFI的数据接收等,都是很好的应用对象。
2 M; ?+ U( z' A8 |% X  ^
) H9 Q2 Q! s' \" z2 M$ M0 e方法2:实现思路:直接利用stm32的RXNE和IDLE中断进行接收不定字节数据。 每次接收到一个字节的数据,触发RXNE中断 将该字节数据存放到数组里,传输完成之后,触发一次IDLE中断,对已经获取到的数据进行处理( ?% {- u' j; \% C2 d: E
' v9 f5 M! h4 b: ]3 T
例程1
9 Y  {, o/ o' m0 |4 @/ _5 h; b, }本例程功能:

' @0 c0 }" _  P# i& l! C2 m+ [% n7 Z4 R. f3 O# J+ r
使用DMA+串口接受空闲中断 实现将接收的数据完整发送到上位机的功能# T& r1 y  ^7 y: H' }" T+ M5 B+ U
' H0 D- p9 U- r! V# S% X- ]5 b
, o0 k" y' P* w
  `( _. q( P* E& J# k4 I
接收数据的流程:
1 \! k( l3 Z- _: ]4 }) U' y7 }, ]0 ^( {. _2 D5 ^4 E
首先在初始化的时候打开DMA接收,当MCU通过USART接收外部发来的数据时,在进行第①②③步的时候,DMA直接将接收到的数据写入缓存rx_buffer[100] //接收数据缓存数组,程序此时也不会进入接收中断,在软件上无需做任何事情,要在初始化配置的时候设置好配置就可以了。$ y  |: A, X3 X" y' r: f, ^

0 F/ Q9 W) f1 F% a, v8 k3 l数据接收完成的流程:2 P9 |- Z+ a- {$ N

" R0 i% P% k5 x当数据接收完成之后产生接收空闲中断④
+ ~0 t$ h' l+ l' v+ U9 s. R* N; ]9 U( r1 t. |, z9 q
在中断服务函数中做这几件事:& W" n$ M! C: U. z
判断是否为IDLE接受空闲中断) _, n; p& ]* X2 P8 t/ ]
在中断服务函数中将接收完成标志位置1+ K# V3 X0 Z" X/ @% c  j! \) h) S
关闭DMA防止在处理数据时候接收数据,产生干扰。
6 h$ d4 g# ~9 J! ^  U; [, N' \计算出接收缓存中的数据长度,清除中断位,
; H8 v7 Y+ t6 ]" q1 @8 S
" b4 T; a, C# v9 L3 W6 Zwhile循环 主程序流程:
8 P% a' v& l# e( d. i; h1 [主程序中检测到接收完成标志被置1! m" \8 k% X- z/ D& q% x& A
进入数据处理程序,现将接收完成标志位置0,
$ }0 B9 g6 B$ A& c; v( v将接收到的数据重新发送到上位机
9 l, @- o# Z0 J& n重新设置DMA下次要接收的数据字节数,使能DMA进入接收数据状态。
+ |; K3 t+ T) `, D9 p
% }8 K; K3 l, D2 v2 o0 n( T( Z例程代码:! R  `2 ]. _  d& X, o4 T
uart.c
9 Z" n4 ^9 I* n# a
  1. volatile uint8_t rx_len = 0;  //接收一帧数据的长度
    2 a4 E- v6 e2 r7 T  A7 S* F
  2. volatile uint8_t recv_end_flag = 0; //一帧数据接收完成标志9 i; W2 ?/ [& b& K- W
  3. uint8_t rx_buffer[100]={0};  //接收数据缓存数组
复制代码
  1. void MX_USART1_UART_Init(void)
    : d! M% v' C/ r' u
  2. {
    7 [! a# ^) f3 M6 @
  3. & k: X( S% ]. P1 r% P) i7 J" e' F
  4.   huart1.Instance = USART1;
    0 _+ W1 b* i* m" k7 n. _$ c( J( w. v! N
  5.   huart1.Init.BaudRate = 115200;
    9 w  r# ~" b" M3 r9 g7 v* r
  6.   huart1.Init.WordLength = UART_WORDLENGTH_8B;5 h4 M" J5 V  `/ V, Q3 o" d
  7.   huart1.Init.StopBits = UART_STOPBITS_1;; j) n. z! n3 N+ `
  8.   huart1.Init.Parity = UART_PARITY_NONE;
    ' G5 _  R/ o  m/ r2 m* y) ~/ |  T  R
  9.   huart1.Init.Mode = UART_MODE_TX_RX;
    : n- M; y, U6 M$ h+ n
  10.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    0 I& s7 ]- z8 g& H% P
  11.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;- w* [$ B' N6 v- G8 u" e8 L6 e
  12.   if (HAL_UART_Init(&huart1) != HAL_OK), b4 ?3 F( v$ B; k
  13.   {' R2 K! X9 e, ?* s$ t
  14.     Error_Handler();
      U0 ?% h, ?- c
  15.   }+ o& @( p( ?9 j
  16. //下方为自己添加的代码
    % \& Y: w' J* Z6 r" I) S# R7 q
  17.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); //使能IDLE中断
    8 p* q7 F1 ~7 n3 K# v# q5 x
  18. 9 H9 j6 V& C/ M$ z9 @3 J9 G
  19. //DMA接收函数,此句一定要加,不加接收不到第一次传进来的实数据,是空的,且此时接收到的数据长度为缓存器的数据长度
    3 v2 F5 A' X* z. R
  20.         HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);; a' E4 p/ X$ g/ I( c- f. M
  21. ; c1 _' u# I5 \4 [( d% `9 h
  22.         0 B6 e  z& {1 B9 O+ E
  23. }
复制代码

( t- \5 l+ h1 \) Z0 a: suart.h8 q, g! F& F  f) H
  1. extern UART_HandleTypeDef huart1;1 v1 g7 q" }8 e$ U4 [% M& ?0 J
  2. extern DMA_HandleTypeDef hdma_usart1_rx;6 X2 X" q- {  O3 D
  3. extern DMA_HandleTypeDef hdma_usart1_tx;$ `* s$ g' p* B, n: v
  4. /* USER CODE BEGIN Private defines */# \$ x) q' q3 e( r) O+ ?, w# W
  5. 5 Q  x, E: `" g* s( ?) z. b! |

  6. 8 X5 V' b" H! t$ Y. t' G
  7. #define BUFFER_SIZE  100  
    ; C* K2 ~& x) k- q/ I+ ]
  8. extern  volatile uint8_t rx_len ;  //接收一帧数据的长度: d% I+ `% @$ n) f3 Y# B
  9. extern volatile uint8_t recv_end_flag; //一帧数据接收完成标志
    , y: U- g& L+ }4 A
  10. extern uint8_t rx_buffer[100];  //接收数据缓存数组
复制代码

9 E- B8 C9 K' r; Pmain.c
5 R, A! t' S# a4 P$ K! z
" Q7 T' U) t, l# N! y/ |
  1. /*, K4 Z4 R9 t9 a4 [% p4 v$ c
  2. *********************************************************************************************************% K1 l0 S& z% W% q# {4 J0 o. j
  3. * 函 数 名: DMA_Usart_Send
    0 I/ J% E# X7 {* L
  4. * 功能说明: 串口发送功能函数
    9 f( U0 K1 h% J+ G1 ]; v
  5. * 形  参: buf,len0 s" E  Q9 Z- ^$ W) s3 u3 b9 F
  6. * 返 回 值: 无
    ( C" ^" v6 t; @  h1 Y0 \* ?+ t
  7. *********************************************************************************************************
    9 E! @1 l" j+ G
  8. */
    / Z% F  [" \& v( _( d/ W  V! L
  9. void DMA_Usart_Send(uint8_t *buf,uint8_t len)//串口发送封装9 J1 c5 O; u8 ^* S# V& J: h! G
  10. {
    3 o9 b4 J4 }  J0 i5 u+ w
  11. if(HAL_UART_Transmit_DMA(&huart1, buf,len)!= HAL_OK)   //判断是否发送正常,如果出现异常则进入异常中断函数
    ) |( g% R9 f8 j6 M0 I
  12.   {
    * ~2 l# P2 W- Z- T  y) E
  13.    Error_Handler();9 I1 f5 Z& Q* i
  14.   }
    , z- {+ R' g& G' c0 j

  15. , q( e  P( X' K: Z- N* r
  16. }. R6 ?9 S4 g9 v' u& b
  17. , `" ]1 u- N. b1 ?$ h
  18. ; D: x6 [2 |1 b2 y+ Z% z6 d
  19. : X" @3 Y8 ^0 b1 z5 v+ U7 r
  20. /*
    6 V: c! h& \% R/ y! Y$ v
  21. *********************************************************************************************************& f" i2 d! d  U4 z* O- W0 n/ ^# o
  22. * 函 数 名: DMA_Usart1_Read9 D6 m, a$ T& a6 M
  23. * 功能说明: 串口接收功能函数( o+ J2 H2 F' p# y0 o2 S
  24. * 形  参: Data,len
    9 l; [0 \6 R: {: U9 ?: {
  25. * 返 回 值: 无
    " S8 w' m! \, K0 z5 C
  26. *********************************************************************************************************
    1 Y: h2 p$ H$ N& q, I1 c5 d
  27. */
    $ B* a2 D: g  Z* h# `2 z
  28. void DMA_Usart1_Read(uint8_t *Data,uint8_t len)//串口接收封装
    2 o( ]  S' n" m/ a
  29. {
    ' X* _, C$ O$ B+ n; S  W
  30.         HAL_UART_Receive_DMA(&huart1,Data,len);//重新打开DMA接收7 r( A; e, }8 j# l, R" k
  31. }
    . J- f# Z6 V3 _/ I8 O0 ?- g! s
复制代码

# O- Y9 p; I2 p' Lwhile循环; X( W7 ^) {; h' N. B. Q, j% q
# V; g2 ?* P5 Q! v
  1. while (1)
    ' B( K$ y# L9 W% ]* [$ _% W1 Z
  2.   {" h, c; v5 E  ~4 y$ o5 d$ d
  3.     /* USER CODE END WHILE */2 Z" h8 q4 k! D: \# h+ H- M/ D

  4. 2 e: ^2 T1 I- ]2 i
  5.     /* USER CODE BEGIN 3 */
    5 o4 M" b0 d+ i$ {5 e, U  X' l+ n6 g- Z1 V
  6.                  if(recv_end_flag == 1)  //接收完成标志
    % N# ~2 \; O7 U5 ]% W$ j; O
  7.                 {$ r2 q# e$ S$ ]4 d. I
  8.                         5 _8 T) T6 P) e2 a
  9.                         
    : |0 }3 ]0 j6 ?9 i5 n" K8 \
  10.                         DMA_Usart_Send(rx_buffer, rx_len);. _/ I) j* B0 f6 n& P7 H7 z
  11.                         rx_len = 0;//清除计数8 }" ~9 [6 |! c2 z% m  o# @* x! j
  12.                         recv_end_flag = 0;//清除接收结束标志位
    6 U# L1 J6 w7 D
  13. //                        for(uint8_t i=0;i<rx_len;i++)
      |9 V4 |. ~! u! h3 d6 E. v7 g  ^
  14. //                                {0 m! G% }8 p3 _! `( i
  15. //                                        rx_buffer<i>=0;//清接收缓存</i>7 N4 ~4 _4 P; ^. F' d
  16. //                                }
    % z6 s( ^) o$ ]
  17.                                 memset(rx_buffer,0,rx_len);/ A# n- ]& [; d' w+ A* u) b$ V! x
  18.   }% R+ E  n8 N- {0 ?0 c# }0 C5 S) e
  19.                 HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);//重新打开DMA接收
    ; k, t, ^  ]! c+ T% G' t% @8 Z
  20. }
    , n' H9 w+ T$ A: `7 S
复制代码

9 b1 Q' |1 _) d' k% ?1 H2 @stm32f1xx_it.c中  ^" Y6 v9 W- L; r! C; M% U

. v1 z2 q' |/ @! Q2 ?* ~( Q
  1. #include "usart.h"
    0 o" L6 f' q( c

  2. ) u! V! v" f! D" Q  `8 V5 @
  3. void USART1_IRQHandler(void)2 b) t& E! Z- y# s$ b" e
  4. {
    0 Q. z/ S" Y+ z' Y! }4 a2 b
  5.         uint32_t tmp_flag = 0;) ?" J, n( C' ]& ~
  6.         uint32_t temp;: e1 T, }% m2 b& a' Y6 G
  7.         tmp_flag =__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE); //获取IDLE标志位
    : X$ d8 c% y1 C& @/ L7 w' s
  8.         if((tmp_flag != RESET))//idle标志被置位; l7 z8 i9 g/ ~) Q# H
  9.         {
    ; q4 _1 f+ N! I7 {5 B  j
  10.                 __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除标志位6 N6 c+ W1 X% h) F8 i0 i8 U
  11.                 //temp = huart1.Instance->SR;  //清除状态寄存器SR,读取SR寄存器可以实现清除SR寄存器的功能
    & p" i$ o  e( d' U' t" n! D
  12.                 //temp = huart1.Instance->DR; //读取数据寄存器中的数据( X/ n: S7 I3 y' P$ ]& o
  13.                 //这两句和上面那句等效
    9 \9 {7 C! u1 N! |  c8 v" L9 P) Z
  14.                 HAL_UART_DMAStop(&huart1); //  停止DMA传输,防止# _, x3 b5 n, F# C. u- q1 n
  15.                 temp  =  __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);// 获取DMA中未传输的数据个数   
    * g% m" C4 O6 n! \% a' {2 g+ O
  16.                 //temp  = hdma_usart1_rx.Instance->NDTR;// 读取NDTR寄存器,获取DMA中未传输的数据个数,
    9 S% d; P/ v' S; t
  17.                 rx_len =  BUFFER_SIZE - temp; //总计数减去未传输的数据个数,得到已经接收的数据个数
    9 A# R8 a4 r; ~! R
  18.                 recv_end_flag = 1;        // 接受完成标志位置1        
    ; s1 L  i. ~6 x" D" B
  19.          }
    6 a* _( q7 J4 G& D! g* t
  20.   HAL_UART_IRQHandler(&huart1);6 U6 Z+ E# A% E. S; h4 B9 e: Y$ y1 A

  21. 1 R3 G7 {1 `, d4 e3 ^
  22. }+ c# e, l, ]* E' I/ Q: X4 v( X
复制代码
, t0 }# @" ?: ?
注释详解:% a+ p, p, O4 G( p
注释1:
& y9 `% D0 _7 q- o. L# A
  1. temp = UartHandle.Instance->SR;  //清除状态寄存器SR,读取SR寄存器可以实现清除SR寄存器的功能# G( {+ o9 k0 g5 N
  2. temp = UartHandle.Instance->DR; //读取数据寄存器中的数据
复制代码
# n( u; o0 V7 f
这两句被屏蔽的原因是它们实现的功能和这下面串口IDLE状态寄存器SR标志位清零的宏定义实现的功能是一样的:
; n% X( ?2 J6 E. D" `; l" C# ~- l- o# b# `# b# R
__HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除标志位( }  Z1 g/ H4 {2 n- l+ A

8 w' A# e% S" l! {我们可以点击这个宏定义进去看看,它实现的功能和上面两句是一样的:) U" r6 u/ R( b! a

$ k, j' u% [8 {4 J- S#define __HAL_UART_CLEAR_IDLEFLAG(HANDLE) __HAL_UART_CLEAR_PEFLAG(HANDLE)
8 h: f- i- s5 A9 X/ @6 T5 E9 e5 r# D+ a  Q
MGNYWWUU8_60()GL0)P@]RJ.png   O: {: I7 D0 i: T
8 F  |- M" |  e/ z) }/ ^
注释2:6 Y3 p9 C, X9 F- b, |3 e2 z- L

* \1 G0 |" N9 S8 f( H6 K
  1. temp  = hdma_usart1_rx.Instance->NDTR;// 获取DMA中未传输的数据个数,NDTR寄存器分析见下面  
复制代码

) K2 l2 F8 W- c. N1 @同理, 这句被屏蔽的原因是因为他和上面的__HAL_DMA_GET_COUNTER的作用也是一样的,都可以获取DMA中未传输的数据个数
) k' V* l. K: k$ K! G5 A% y
2 ]5 G0 Z0 f! F7 S" X* u7 j ZO1V@ZT1H)]~NR@V])59TT1.png   ~- }/ D; e$ q1 ?; b2 r. x
/ w" [4 k# B- x. r2 x% Q
测试正常:  C/ y9 k/ ^7 @
$ M7 k  ~: v' F" M) X
J92(YI{0KM`ID{%8[LRX9`M.png 1 n$ D9 q$ G+ R; M# c

" \1 Y0 t: n- X. {8 X此程序可以进行接收不定长的数据帧,不需像RXNE每次接收到一个字节就进一次中断。$ ?% Z& o( q6 i$ A- X6 P7 R
同时开启DMA传输速率也会加快7 m- F" E- ]& k& U$ H, P$ K, V
例程2
$ `) z/ J* Y% ~* v+ `  u: {2 k' iUART中断使能函数' a$ D$ e/ R8 P* B. K
  1. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)
复制代码
7 k8 t; q  C  u4 v$ P- Q
功能: 该函数的作用是使能对应的UART中断9 @, E6 f! @- G& P) j% [$ e

  ^2 t: a; i9 f在stm32f1xx_hal_uart.h中被宏定义" b: E  W2 U4 k/ Z( w

5 N6 b! ^) W) v4 N, Y; z/ ~ DWY99KRLDC0B_J1WG{$N`30.png 7 g' E" f: x- }4 c1 Z4 q& i+ s, X% f
, p7 S5 {+ d5 C: e$ d
可以使能的中断一共有这些:) E* Q! q- e, ^9 @: D3 J
  v" R' x2 @7 D
%H4WBTH~8)WZY49JBXC6}[M.png 7 H6 F: Q: L7 d# y' q& w3 {

. Q) `( Q% m; z1 B我们现在所用到的为:! L7 w0 O' N" R, y2 B8 i
  1.   *  @arg UART_IT_RXNE: Receive Data register not empty interrupt
    ! n; g7 L8 l8 h& `: p" V1 J" D
  2.   *  @arg UART_IT_IDLE: Idle line detection interrupt
复制代码
* y% e/ Y7 \* `6 D3 j
RXNE接收数据中断
8 F  A! y8 |. S1 f+ U* V" YIDLE 接收空闲中断
. u5 @5 [  ]2 e/ q, i  x/ F+ ?* R8 i1 f9 p$ d* L# k
U5PXUTDR$S1Z2XH0U5SHRKC.png
3 K- T. [% c0 k' D
/ k: t3 Y& M! K: z7 S! E2 X本例程功能:
. s0 v2 B) I6 W; O3 V$ @  C& a% U: i' F- @' B
使用RXNE接收数据中断+IDLE串口接受空闲中断 实现将接收的数据完整发送到上位机的功能
4 G' b# Q& V% S
% v1 p9 J6 s( i. G0 O& v; j接收数据的流程:
; ?  ^$ g$ {- P/ @5 l' v, \, O9 s! a9 a1 K8 ?( A5 P3 Y6 s
首先在初始化的时候打开DMA接收,当MCU通过USART接收外部发来的数据时,在进行第①②③步的时候,DMA直接将接收到的数据写入缓存rx_buffer[100] //接收数据缓存数组,同样初始化配置的时候设置好配置就可以了。
" r- W. T) H1 o) j! X2 C, C! P9 M$ ^' c* t5 V
接收到一个字节数据:2 m' W# u! p* ~- g* l  L8 S) Q
接收到一个字节的数据之后,便会进入RXNE接收数据中断,
- }; t" W* p* x% f& H: ]) t8 j( t  \. {# Q
接受完一帧数据之后,便会进入IDLE 接收空闲中断
' }9 R6 g" `4 {) C4 r
. K% v6 C8 i! n. M# H+ u& y6 S在uart.c中添加中断函数+ u4 h6 D; j( R0 f' ^

) A* y5 i! Q. p, F  x8 t9 g9 b6 J
  1. void MX_USART1_UART_Init(void)
    & v0 f2 y' ?: x5 n* J
  2. {
    ' X# V0 O5 z. k3 C

  3. 6 U, g- y0 `' T, [. a0 E* K
  4.   huart1.Instance = USART1;
    * d& V0 e$ `6 w$ Z* G
  5.   huart1.Init.BaudRate = 115200;8 f! {) V+ A6 L  M. X6 L
  6.   huart1.Init.WordLength = UART_WORDLENGTH_8B;" `$ B( |' @$ R
  7.   huart1.Init.StopBits = UART_STOPBITS_1;
    1 a# [$ y# r8 T# M
  8.   huart1.Init.Parity = UART_PARITY_NONE;$ i& M& {: `7 b1 i$ {" t
  9.   huart1.Init.Mode = UART_MODE_TX_RX;
    ( D* d% N: |* m; q& x7 Z7 E1 F" ~
  10.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;- y+ J) H- K* h- w
  11.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    : q" s3 @; @+ c( v8 S3 L; P# b
  12.   if (HAL_UART_Init(&huart1) != HAL_OK)5 x9 Z+ S5 }# w6 k/ ^% n
  13.   {
    + R' l6 j) t7 \+ N: u3 L
  14.     Error_Handler();4 z. y% S: ?& c( @" ?% U
  15.   }3 x& H/ l8 @: l; O/ C% n

  16. 5 G( L7 z3 U# I" x8 n1 X5 n
  17.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE); //使能IDLE中断6 e3 }, O5 `: l7 w9 u$ ^+ P
  18.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); //使能IDLE中断
    " ?5 m3 Y$ a$ t+ a7 S4 j

  19. ; }! I5 C! U/ W2 g; z
  20. //DMA接收函数,此句一定要加,不加接收不到第一次传进来的实数据,是空的,且此时接收到的数据长度为缓存器的数据长度2 I# \2 D4 D) l. [% _
  21.         HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);6 \8 s& L# q3 w

  22. 3 u/ Z! e- s( t; O# f- x9 X" |
  23.         
    2 ~8 ^0 e5 F0 f4 x. P/ F0 h
  24. }
    9 H2 }& `9 _; d) Q
复制代码
其核心代码就是下面的两句
4 Y/ V$ j5 t/ E% t7 L  X) W/ g  N$ l- N" b/ O' i/ Y2 |8 N2 v
4R[EVR6ESO3C7R2K_B$FN.png
& j# Z' z" G" x4 P9 ]; w& g- |/ Z' J$ L0 `8 k. ~/ A" ^
第一条语句用来判断是否接收到1个字节,第二条语句用来判断是否接收到1帧数据' Q5 _' r4 i7 O: [" `

  1. : s, G- u0 Z8 \; X% B1 Y3 h5 u/ l
  2.         if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET)  //如果接收到了一个字节的数据" m& {* G8 ?$ A, I' X' ~
  3.         {
    % p2 ?4 i: g0 `9 ]
  4.                         HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_5);    //反转LED& G' j- ^2 s* _. a
  5.         }
    ; v- x+ L+ o. J3 L0 |5 R& H3 Z  [
  6.         
    6 T4 j/ x1 O9 ?/ l
  7.         if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET)//如果接受到了一帧数据! {* k( ^6 z1 D
  8.         { ! ~3 w( V' N7 f. ?% T
  9.                 __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除标志位
复制代码
9 d  i9 q7 M2 g, Y
其余部分于上方例程1基本相同
, I8 i1 z1 p* Z0 i4 ]
- ?& J( K8 |% u; e5 D: G; Y本次测试是检测接收到一个字节就反转LED
' r2 e/ U$ r1 E0 f9 D" Y3 _# ~经测试,历程正常:
% S+ h+ d3 P) f! d# v1 t6 _1 N
/ H" E5 d* }: E* x5 k5 y+ d5 w: x& Z3 t6 |
, z- v% }1 u6 R! n

1 t8 A; |  |6 P+ y8 r3 S. Q) `! G/ ^: t6 T% R! D
赞 收藏 1 评论0 发布时间:2022-3-23 17:00

举报

0个回答

所属标签

相似技术帖

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