本篇文章提供两种方法:
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
+ `& 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
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
' 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- 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
- #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$ }
. 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- 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- volatile uint8_t rx_len = 0; //接收一帧数据的长度
2 a4 E- v6 e2 r7 T A7 S* F - volatile uint8_t recv_end_flag = 0; //一帧数据接收完成标志9 i; W2 ?/ [& b& K- W
- uint8_t rx_buffer[100]={0}; //接收数据缓存数组
复制代码- void MX_USART1_UART_Init(void)
: d! M% v' C/ r' u - {
7 [! a# ^) f3 M6 @ - & k: X( S% ]. P1 r% P) i7 J" e' F
- huart1.Instance = USART1;
0 _+ W1 b* i* m" k7 n. _$ c( J( w. v! N - huart1.Init.BaudRate = 115200;
9 w r# ~" b" M3 r9 g7 v* r - huart1.Init.WordLength = UART_WORDLENGTH_8B;5 h4 M" J5 V `/ V, Q3 o" d
- huart1.Init.StopBits = UART_STOPBITS_1;; j) n. z! n3 N+ `
- huart1.Init.Parity = UART_PARITY_NONE;
' G5 _ R/ o m/ r2 m* y) ~/ | T R - huart1.Init.Mode = UART_MODE_TX_RX;
: n- M; y, U6 M$ h+ n - huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
0 I& s7 ]- z8 g& H% P - huart1.Init.OverSampling = UART_OVERSAMPLING_16;- w* [$ B' N6 v- G8 u" e8 L6 e
- if (HAL_UART_Init(&huart1) != HAL_OK), b4 ?3 F( v$ B; k
- {' R2 K! X9 e, ?* s$ t
- Error_Handler();
U0 ?% h, ?- c - }+ o& @( p( ?9 j
- //下方为自己添加的代码
% \& Y: w' J* Z6 r" I) S# R7 q - __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); //使能IDLE中断
8 p* q7 F1 ~7 n3 K# v# q5 x - 9 H9 j6 V& C/ M$ z9 @3 J9 G
- //DMA接收函数,此句一定要加,不加接收不到第一次传进来的实数据,是空的,且此时接收到的数据长度为缓存器的数据长度
3 v2 F5 A' X* z. R - HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);; a' E4 p/ X$ g/ I( c- f. M
- ; c1 _' u# I5 \4 [( d% `9 h
- 0 B6 e z& {1 B9 O+ E
- }
复制代码
( t- \5 l+ h1 \) Z0 a: suart.h8 q, g! F& F f) H
- extern UART_HandleTypeDef huart1;1 v1 g7 q" }8 e$ U4 [% M& ?0 J
- extern DMA_HandleTypeDef hdma_usart1_rx;6 X2 X" q- { O3 D
- extern DMA_HandleTypeDef hdma_usart1_tx;$ `* s$ g' p* B, n: v
- /* USER CODE BEGIN Private defines */# \$ x) q' q3 e( r) O+ ?, w# W
- 5 Q x, E: `" g* s( ?) z. b! |
8 X5 V' b" H! t$ Y. t' G- #define BUFFER_SIZE 100
; C* K2 ~& x) k- q/ I+ ] - extern volatile uint8_t rx_len ; //接收一帧数据的长度: d% I+ `% @$ n) f3 Y# B
- extern volatile uint8_t recv_end_flag; //一帧数据接收完成标志
, y: U- g& L+ }4 A - 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/ |- /*, K4 Z4 R9 t9 a4 [% p4 v$ c
- *********************************************************************************************************% K1 l0 S& z% W% q# {4 J0 o. j
- * 函 数 名: DMA_Usart_Send
0 I/ J% E# X7 {* L - * 功能说明: 串口发送功能函数
9 f( U0 K1 h% J+ G1 ]; v - * 形 参: buf,len0 s" E Q9 Z- ^$ W) s3 u3 b9 F
- * 返 回 值: 无
( C" ^" v6 t; @ h1 Y0 \* ?+ t - *********************************************************************************************************
9 E! @1 l" j+ G - */
/ Z% F [" \& v( _( d/ W V! L - void DMA_Usart_Send(uint8_t *buf,uint8_t len)//串口发送封装9 J1 c5 O; u8 ^* S# V& J: h! G
- {
3 o9 b4 J4 } J0 i5 u+ w - if(HAL_UART_Transmit_DMA(&huart1, buf,len)!= HAL_OK) //判断是否发送正常,如果出现异常则进入异常中断函数
) |( g% R9 f8 j6 M0 I - {
* ~2 l# P2 W- Z- T y) E - Error_Handler();9 I1 f5 Z& Q* i
- }
, z- {+ R' g& G' c0 j
, q( e P( X' K: Z- N* r- }. R6 ?9 S4 g9 v' u& b
- , `" ]1 u- N. b1 ?$ h
- ; D: x6 [2 |1 b2 y+ Z% z6 d
- : X" @3 Y8 ^0 b1 z5 v+ U7 r
- /*
6 V: c! h& \% R/ y! Y$ v - *********************************************************************************************************& f" i2 d! d U4 z* O- W0 n/ ^# o
- * 函 数 名: DMA_Usart1_Read9 D6 m, a$ T& a6 M
- * 功能说明: 串口接收功能函数( o+ J2 H2 F' p# y0 o2 S
- * 形 参: Data,len
9 l; [0 \6 R: {: U9 ?: { - * 返 回 值: 无
" S8 w' m! \, K0 z5 C - *********************************************************************************************************
1 Y: h2 p$ H$ N& q, I1 c5 d - */
$ B* a2 D: g Z* h# `2 z - void DMA_Usart1_Read(uint8_t *Data,uint8_t len)//串口接收封装
2 o( ] S' n" m/ a - {
' X* _, C$ O$ B+ n; S W - HAL_UART_Receive_DMA(&huart1,Data,len);//重新打开DMA接收7 r( A; e, }8 j# l, R" k
- }
. 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
- while (1)
' B( K$ y# L9 W% ]* [$ _% W1 Z - {" h, c; v5 E ~4 y$ o5 d$ d
- /* USER CODE END WHILE */2 Z" h8 q4 k! D: \# h+ H- M/ D
2 e: ^2 T1 I- ]2 i- /* USER CODE BEGIN 3 */
5 o4 M" b0 d+ i$ {5 e, U X' l+ n6 g- Z1 V - if(recv_end_flag == 1) //接收完成标志
% N# ~2 \; O7 U5 ]% W$ j; O - {$ r2 q# e$ S$ ]4 d. I
- 5 _8 T) T6 P) e2 a
-
: |0 }3 ]0 j6 ?9 i5 n" K8 \ - DMA_Usart_Send(rx_buffer, rx_len);. _/ I) j* B0 f6 n& P7 H7 z
- rx_len = 0;//清除计数8 }" ~9 [6 |! c2 z% m o# @* x! j
- recv_end_flag = 0;//清除接收结束标志位
6 U# L1 J6 w7 D - // for(uint8_t i=0;i<rx_len;i++)
|9 V4 |. ~! u! h3 d6 E. v7 g ^ - // {0 m! G% }8 p3 _! `( i
- // rx_buffer<i>=0;//清接收缓存</i>7 N4 ~4 _4 P; ^. F' d
- // }
% z6 s( ^) o$ ] - memset(rx_buffer,0,rx_len);/ A# n- ]& [; d' w+ A* u) b$ V! x
- }% R+ E n8 N- {0 ?0 c# }0 C5 S) e
- HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);//重新打开DMA接收
; k, t, ^ ]! c+ T% G' t% @8 Z - }
, 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- #include "usart.h"
0 o" L6 f' q( c
) u! V! v" f! D" Q `8 V5 @- void USART1_IRQHandler(void)2 b) t& E! Z- y# s$ b" e
- {
0 Q. z/ S" Y+ z' Y! }4 a2 b - uint32_t tmp_flag = 0;) ?" J, n( C' ]& ~
- uint32_t temp;: e1 T, }% m2 b& a' Y6 G
- tmp_flag =__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE); //获取IDLE标志位
: X$ d8 c% y1 C& @/ L7 w' s - if((tmp_flag != RESET))//idle标志被置位; l7 z8 i9 g/ ~) Q# H
- {
; q4 _1 f+ N! I7 {5 B j - __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除标志位6 N6 c+ W1 X% h) F8 i0 i8 U
- //temp = huart1.Instance->SR; //清除状态寄存器SR,读取SR寄存器可以实现清除SR寄存器的功能
& p" i$ o e( d' U' t" n! D - //temp = huart1.Instance->DR; //读取数据寄存器中的数据( X/ n: S7 I3 y' P$ ]& o
- //这两句和上面那句等效
9 \9 {7 C! u1 N! | c8 v" L9 P) Z - HAL_UART_DMAStop(&huart1); // 停止DMA传输,防止# _, x3 b5 n, F# C. u- q1 n
- temp = __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);// 获取DMA中未传输的数据个数
* g% m" C4 O6 n! \% a' {2 g+ O - //temp = hdma_usart1_rx.Instance->NDTR;// 读取NDTR寄存器,获取DMA中未传输的数据个数,
9 S% d; P/ v' S; t - rx_len = BUFFER_SIZE - temp; //总计数减去未传输的数据个数,得到已经接收的数据个数
9 A# R8 a4 r; ~! R - recv_end_flag = 1; // 接受完成标志位置1
; s1 L i. ~6 x" D" B - }
6 a* _( q7 J4 G& D! g* t - HAL_UART_IRQHandler(&huart1);6 U6 Z+ E# A% E. S; h4 B9 e: Y$ y1 A
1 R3 G7 {1 `, d4 e3 ^- }+ c# e, l, ]* E' I/ Q: X4 v( X
复制代码 , t0 }# @" ?: ?
注释详解:% a+ p, p, O4 G( p
注释1:& y9 `% D0 _7 q- o. L# A
- temp = UartHandle.Instance->SR; //清除状态寄存器SR,读取SR寄存器可以实现清除SR寄存器的功能# G( {+ o9 k0 g5 N
- 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
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- 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
~- }/ D; e$ q1 ?; b2 r. x
/ w" [4 k# B- x. r2 x% Q
测试正常: C/ y9 k/ ^7 @
$ M7 k ~: v' F" M) X
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
- __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/ ~
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
7 H6 F: Q: L7 d# y' q& w3 {
. Q) `( Q% m; z1 B我们现在所用到的为:! L7 w0 O' N" R, y2 B8 i
- * @arg UART_IT_RXNE: Receive Data register not empty interrupt
! n; g7 L8 l8 h& `: p" V1 J" D - * @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
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- void MX_USART1_UART_Init(void)
& v0 f2 y' ?: x5 n* J - {
' X# V0 O5 z. k3 C
6 U, g- y0 `' T, [. a0 E* K- huart1.Instance = USART1;
* d& V0 e$ `6 w$ Z* G - huart1.Init.BaudRate = 115200;8 f! {) V+ A6 L M. X6 L
- huart1.Init.WordLength = UART_WORDLENGTH_8B;" `$ B( |' @$ R
- huart1.Init.StopBits = UART_STOPBITS_1;
1 a# [$ y# r8 T# M - huart1.Init.Parity = UART_PARITY_NONE;$ i& M& {: `7 b1 i$ {" t
- huart1.Init.Mode = UART_MODE_TX_RX;
( D* d% N: |* m; q& x7 Z7 E1 F" ~ - huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;- y+ J) H- K* h- w
- huart1.Init.OverSampling = UART_OVERSAMPLING_16;
: q" s3 @; @+ c( v8 S3 L; P# b - if (HAL_UART_Init(&huart1) != HAL_OK)5 x9 Z+ S5 }# w6 k/ ^% n
- {
+ R' l6 j) t7 \+ N: u3 L - Error_Handler();4 z. y% S: ?& c( @" ?% U
- }3 x& H/ l8 @: l; O/ C% n
5 G( L7 z3 U# I" x8 n1 X5 n- __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE); //使能IDLE中断6 e3 }, O5 `: l7 w9 u$ ^+ P
- __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); //使能IDLE中断
" ?5 m3 Y$ a$ t+ a7 S4 j
; }! I5 C! U/ W2 g; z- //DMA接收函数,此句一定要加,不加接收不到第一次传进来的实数据,是空的,且此时接收到的数据长度为缓存器的数据长度2 I# \2 D4 D) l. [% _
- HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);6 \8 s& L# q3 w
3 u/ Z! e- s( t; O# f- x9 X" |-
2 ~8 ^0 e5 F0 f4 x. P/ F0 h - }
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
& j# Z' z" G" x4 P9 ]; w& g- |/ Z' J$ L0 `8 k. ~/ A" ^
第一条语句用来判断是否接收到1个字节,第二条语句用来判断是否接收到1帧数据' Q5 _' r4 i7 O: [" `
: s, G- u0 Z8 \; X% B1 Y3 h5 u/ l- if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET) //如果接收到了一个字节的数据" m& {* G8 ?$ A, I' X' ~
- {
% p2 ?4 i: g0 `9 ] - HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_5); //反转LED& G' j- ^2 s* _. a
- }
; v- x+ L+ o. J3 L0 |5 R& H3 Z [ -
6 T4 j/ x1 O9 ?/ l - if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET)//如果接受到了一帧数据! {* k( ^6 z1 D
- { ! ~3 w( V' N7 f. ?% T
- __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 k 5 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
|