前言* v2 G o' V! a- X# J h
用STM32CubeMx生成初始化配置代码是十分方便的,但是在处理多个项目的时候,就会发现,自动生成的中断函数调用的都是同一个回调函数,在这个回调函数中又要根据不同的句柄来处理,不同的项目外设又有所区别,还是要花点时间来进行移植。
5 k) R1 f6 H5 W比如说,我在项目A中使用到了串口1、串口2、串口3,但是在项目B中,我只使用到了串口2,并且在项目B中,串口2的功能是项目A的串口1的功能,在这种情况下,我就需要再定义一次 HAL_UART_RxCpltCallback() ,然后移植对应的功能。当然也可以重新 define 一个宏,来对应所使用的串口,这样移植上也会快许多。但是假如,后面新来了一个需求,需要实现项目C的串口3的功能,原本只要添加对应的头文件,模块处理这些外设是最简便的,但是这时候会发现,项目C中也定义了HAL_UART_RxCpltCallback(),这就需要人工去移植这部分的代码了。
. Q' H! o; q2 I# I而我就在想,项目C的串口3是已经实现的模块,且这个模块是单独的.c文件和.h文件,并且不和其他的串口耦合在一起,这样的轮子造起车子来就快了许多了。但是找遍全网,会发现,关于HAL库中串口中断的教程都是基本的实现,没有更深层次的解释了,在学习MEMS库的过程中,看到官方的代码,在使用按钮触发外部中断的时候,竟然可以自定义外部中断的回调函数,进行一番学习之后,终于掌握了自定义中断回调的方法,不仅限于串口中断函数的回调,其他的外设都是相类似的,都是可以自定义中断的回调函数。
- k- Z5 a* {6 F6 \高手可以直接跳过第一节的内容,直接跳到第二节看如何进行操作。/ u3 j- X: I1 y% f* O
一、HAL库的中断实现( u) m% J( B0 O6 m" `
中断的原理网上到处都有,也可以参考正点原子这种开源的教程。
* S/ B; Q0 a, {, n9 ^我们正常在STM32CubeMX配置好中断后,通过 GENERATE CODE 生成代码,在 stm32f7xx_it.c 中,就会自动生成中断的处理函数,比如 USART2_IRQHandler,可以看到串口2的全局中断仅仅调用了 HAL_UART_IRQHandler 函数,该函数用于处理UART中断请求。
% Q' [0 X( H* y, S
0 E+ A& l; J: m6 w: E3 @# d- /**" i4 F, L5 W; g( {; ^, O9 z. Y
- * @brief This function handles USART2 global interrupt.
6 s+ W, H/ w% Q1 H. V4 K - */
6 q: e# _% ?0 ~' [ - void USART2_IRQHandler(void)
% Q9 Z0 Q* M: s - {: j" B7 F7 x# ^
- /* USER CODE BEGIN USART2_IRQn 0 */
" u: Z8 ?) N2 u/ j V: E2 O) {
Z( t3 a0 G' _) N: q& W- f& C, i' a- /* USER CODE END USART2_IRQn 0 */
* G o- W0 N% n9 e3 d, X - HAL_UART_IRQHandler(&huart2);
, \8 Q- m- p0 q$ e' K: {9 a - /* USER CODE BEGIN USART2_IRQn 1 *// ?! H$ Z- C, w. E R" I. h. x
! Q0 S+ \( ~5 f) ~3 h! c" j- /* USER CODE END USART2_IRQn 1 */
) u5 Q. G, \& Z3 m1 q, L9 y1 {" l - }
复制代码
% ]. y3 C$ H' l4 C' _: p我们进入 HAL_UART_IRQHandler 看看里面具体的实现。这个实现虽然很长,但是逻辑比较简单。首先判断是否有错误产生,没有错误就会调用 UART_Receive_IT,用于在非阻塞模式下接收大量数据。如果在接收的过程中有错误发生,那么就会进行标志位的处理,再下面一点就可以看到 USE_HAL_UART_REGISTER_CALLBACKS 这个宏定义,这就是我们自定义中断函数的关键了。如果我们定义了 USE_HAL_UART_REGISTER_CALLBACKS,那么我们通过注册自定义的中断函数后,在这里 huart->ErrorCallback(huart) 就可以直接跳转到我们的自定义的接收异常函数了,而不是 HAL_UART_ErrorCallback(huart) 这个HAL通用的接收异常处理函数。" j* Y" \9 n* t! I
注:F7的板子在公司,写这个教程的时候手头只有 NUCLEO-L152RE 的开发板,使用的库是 STM32Cube_FW_L1_V1.10.2。 STM32CubeMx生成的代码有所区别,但原理上是一样的。F767ZI 是通过 huart->RxISR(huart) 这个方式来调用中断处理函数的,最终调用的是 UART_RxISR_8BIT 这样子的函数。当然后面推出了新的固件版本,也可能导致具体的实现有所区别。
& M. b+ T- A9 J8 p4 P
6 u% x/ n+ D) I( j- void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)) I% j4 B3 V" z- o: K
- {7 z: u" l% ^ z( G0 ^ z
- uint32_t isrflags = READ_REG(huart->Instance->SR);( Q8 _- \' x- [
- uint32_t cr1its = READ_REG(huart->Instance->CR1);
3 b" d$ s$ m% M8 K* w2 Q - uint32_t cr3its = READ_REG(huart->Instance->CR3);- \1 c6 p# `" i o5 a; g, z/ a
- uint32_t errorflags = 0x00U;% z) J. A+ h! d/ d
- uint32_t dmarequest = 0x00U;/ c7 x8 d; j. a, w7 [0 `# g
) _6 l; v) F' y7 q5 ]$ e3 g. _; S _- /* 如果没有错误发生 */2 ]7 ]9 T, j& l% V" D
- errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));$ F' I8 d3 p; M8 T4 y8 `
- if (errorflags == RESET)
3 ]8 H' G. B0 C0 X% q - {; Q7 f- f) E* Q
- /* UART处于接收模式 -------------------------------------------------*/
0 k ?8 c# x9 L2 J$ F3 L4 @; [: U - if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
; y! p; |8 f& U, C$ z* \6 q - {
8 a6 m% c6 Y5 |4 c - UART_Receive_IT(huart);
( W4 O$ w5 H6 [; X - return;
. X/ v$ g7 Q% _- E& p% o - }4 [& F4 a* N! S; w7 D+ a
- }+ N% W6 B% g Q9 R$ P8 r
5 d# h+ V7 l& s5 j6 G- L9 I# d/ T- /* 如果发生一些错误 */
& V" O, h0 i) J- l - if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
4 d( R, d2 S4 `, Q, v - {
9 {3 ^" K& U" X3 B. O - /* UART parity error interrupt occurred ----------------------------------*/( G8 D& Y: ~, t
- if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
2 K/ s: |1 S, k6 S6 a0 x7 @3 L8 [ - {8 v) [# U2 ]& N: s$ E
- huart->ErrorCode |= HAL_UART_ERROR_PE;
$ M9 K6 \ g6 {( {0 v/ s - }
" U0 s' {4 K7 t/ s - % M& i. f8 R) `
- /* UART noise error interrupt occurred -----------------------------------*/4 w$ `3 l9 y1 s9 c8 w- a! O5 ^
- if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))1 ~' F: q: E8 z! a, i
- {- }/ {/ w9 H$ A2 \4 s8 K' _
- huart->ErrorCode |= HAL_UART_ERROR_NE;
0 D% J! h. {0 C# x, G4 Y, v - }* y. d" s( v. | g1 [
! S8 ?& A* i7 I5 m5 I5 N- /* UART frame error interrupt occurred -----------------------------------*/
8 R, \5 [* T- Z, ^2 _; O0 i - if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
: J" O" f. C7 \) l. t3 D0 o& X4 D - {
4 O2 g+ v- I9 T B, O. f - huart->ErrorCode |= HAL_UART_ERROR_FE;6 O( \! Y6 q: s1 b/ g- z
- }
6 S( H/ h# l! o7 o0 d7 l8 g# t) f - 3 K, o! Y( x% y+ a7 i" _& J# s, \3 L
- /* UART Over-Run interrupt occurred --------------------------------------*/
; ^8 ?, D7 M/ B" E0 E - if (((isrflags & USART_SR_ORE) != RESET) && (((cr1its & USART_CR1_RXNEIE) != RESET) || ((cr3its & USART_CR3_EIE) != RESET)))* S: P# j- y6 y' B2 p9 S3 h5 M
- {2 {! W6 V* G) f. Z0 M
- huart->ErrorCode |= HAL_UART_ERROR_ORE;# v' F& G. T: ^
- }& [/ f0 n2 n( `' o Q
( W& ?/ q( M4 N- p6 Y- /* Call UART Error Call back function if need be --------------------------*/
8 j- x0 w0 P2 i6 i8 A! W) s - if (huart->ErrorCode != HAL_UART_ERROR_NONE)
* o( N) D! r4 }6 Y& U! G1 v) ?. O: T - {9 s- W& Y9 M! k6 G# x' t2 q7 |+ O
- /* UART in mode Receiver -----------------------------------------------*/
. b3 G2 D. m9 t( Z - if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
8 ~) o. m! u2 i) K - {. P ^9 t, A- H' m6 R7 t# r J# B
- UART_Receive_IT(huart);
) @4 @3 d( d/ z5 P$ Z - }. x9 Y: V0 \' q2 I# |% D- f
) P4 K2 E$ W8 F/ W( V( H; f# I- /* If Overrun error occurs, or if any error occurs in DMA mode reception,3 l" M- H4 j% B; {+ v! _2 M
- consider error as blocking */
5 X. k: y9 i6 W5 T5 I0 K- G5 [0 K - dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
6 V2 {/ b7 |2 `" i3 I: i# ] - if (((huart->ErrorCode & HAL_UART_ERROR_ORE) != RESET) || dmarequest)
( \1 E; s. b0 g7 ~" x1 O' S# O - {0 p1 t4 i! x, u W* l2 |
- /* Blocking error : transfer is aborted2 @5 e u, z% K. O" S- D/ U
- Set the UART state ready to be able to start again the process,
2 x2 X4 v9 _2 ~) Z - Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
; E% n- k8 l/ g - UART_EndRxTransfer(huart); u! I0 E" l# M: g; S$ o, l
- % E) Q# g3 k! d! { Q2 E% e; k" P0 r
- /* Disable the UART DMA Rx request if enabled */
* O# b2 F3 P3 B6 C" M# H# L/ E) x - if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
+ ]0 f, o) G% ?! j ] - {
" T, V) q# |9 T8 O' B4 }% G - CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);/ x" \& O$ o+ f2 r9 O
- # ^3 m% C0 L5 F& m
- /* Abort the UART DMA Rx channel */
$ T4 G i* k. W- B. O! q* G7 f - if (huart->hdmarx != NULL)- ~. f+ |# U1 D( z4 a
- {, G$ }+ O+ Z9 u3 d8 b$ }
- /* Set the UART DMA Abort callback :
. A. P x# z( J- S u' |+ q - will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */. H) y1 T2 i4 x( e6 \- ]: o
- huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;6 N" L0 V5 T; w# X. w9 Z. b ]( p
- if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)# ^- v* D* ^# m9 F
- {, L: v2 I+ w5 V1 w. G# P
- /* Call Directly XferAbortCallback function in case of error */7 @: G, t0 H u H/ l; Z4 C
- huart->hdmarx->XferAbortCallback(huart->hdmarx);$ C# N2 t8 h) D% V3 ?2 N/ c
- }) \ G& P7 v9 B1 t
- }! |: }. B5 C! U
- else
% T9 {4 L4 F, s# }; O6 M5 b - {# G7 Y9 ?, ~7 Q0 k7 Y/ K
- /* Call user error callback */2 ]6 V3 E G' p7 O* C# P
- #if (USE_HAL_UART_REGISTER_CALLBACKS == 1) ?$ \" [, }. N* l
- /*Call registered error callback*/2 A/ B1 H; |, |% N6 B
- huart->ErrorCallback(huart);$ Q$ ]" ~; ]$ m3 d+ \
- #else* @- }7 f2 V2 s9 |$ b
- /*Call legacy weak error callback*// J2 V; G+ t) z8 k- s$ f# T: x' n
- HAL_UART_ErrorCallback(huart);
2 [! _7 J' [6 W" Y U2 W1 E/ _1 f/ V - #endif /* USE_HAL_UART_REGISTER_CALLBACKS */- w! `. D% E8 R( |! N1 o
- }1 p8 O6 c; q: p3 V, s! Y
- }
4 M# a" W( a; c - else
1 O) i! v% R% g9 |/ N# ^+ S9 U - {$ S8 s9 R$ T5 {0 ]
- /* Call user error callback */! V+ d; b% X5 A: y& M& c$ ~/ m* U
- #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)& o! U9 s3 b& t) \ H0 y
- /*Call registered error callback*/, @6 F4 \8 ~( ?# Q+ D1 K+ F q
- huart->ErrorCallback(huart);
) v w S; C7 { - #else
- I/ T& v* M/ W$ F* S, d$ W- Q - /*Call legacy weak error callback*/% S* R0 _4 m/ o: U
- HAL_UART_ErrorCallback(huart);1 O, _% W$ a6 `! `# G
- #endif /* USE_HAL_UART_REGISTER_CALLBACKS */2 z1 N# r+ z% W6 d
- }
* z: O3 O$ x' g4 [; c1 k - }
0 F0 V) m2 M7 r - else1 o+ ]8 w# o1 H+ U- f p# c |- j/ u
- {
: t( R0 P) K6 Z" W M4 T8 r& ? - /* Non Blocking error : transfer could go on.
/ J. i s# Q$ N* k7 F& x4 J - Error is notified to user through user error callback */
! S3 i) f9 y7 p) P: [5 i - #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
3 H% F. k* p9 ?* H' f' r. }8 s - /*Call registered error callback*/
9 ~) d' J) }& ?9 e8 L/ f - huart->ErrorCallback(huart);
+ D# d+ H0 k9 b m n' i; B# I5 M - #else0 B5 d9 ]* y/ N K7 K& |
- /*Call legacy weak error callback*/
( W6 @4 h' y- t/ _ s& T' [1 T - HAL_UART_ErrorCallback(huart);6 Q( e* L! d1 v' B% m/ L4 x
- #endif /* USE_HAL_UART_REGISTER_CALLBACKS */
7 {3 \5 w1 [; C) j" q0 i' X - 6 |, E& I6 g- X/ a% j+ T- G
- huart->ErrorCode = HAL_UART_ERROR_NONE; {# }1 w' x" }9 m% N) {
- }; }. A+ |' o7 ]3 G9 l, U
- }
) Y. C' L: Y9 Z9 k - return;" u- E1 `- w3 u% t+ F) S
- } /* 如果发生错误则结束 */# l2 z/ k, a5 `2 G: E
- 2 v9 N& ~/ W: a' U1 T
- /* UART 处于发送模式,准备在非阻塞模式下发送大量数据。 ---------------------------*/
1 h/ U7 j# ^: c+ d/ {5 N - if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))" ~2 |+ @, i. v* C1 c0 h' n
- {
% ~. ?. A* R" G) g2 F) X - UART_Transmit_IT(huart);
& m, y% P$ |6 J/ e2 V - return;
: v! O# s+ ~0 a' i% k0 b9 |2 [' Z - }! r& ?8 f, m" k8 g+ V; a' o( X9 u
# D, Z+ n, {4 N# c" E; T: V. |1 Z- /* UART 处于发送结束模式,在非阻塞模式下结束传输。 -------------------------------*/
( g* G& G0 u+ v - if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET)). z( ]9 D0 r3 n- {
- {
* Q4 d! N- Q9 ^0 m# |" l9 T - UART_EndTransmit_IT(huart);
% E; k. n: e% k7 r3 y- P/ D - return;
' I& ^ ]; R$ f& `; o& Q$ c - }
. v; j% H# y# S' t" o8 Y - }
复制代码 0 n% ]. J3 x; i3 l9 i
然后我们看看没有接收错误发生时,调用的函数 UART_Receive_IT(huart)。这个首先根据数据位的长度来进行接收数据,(9bit和少于9bit的处理是不一样的),串口数据就保存在 huart->pRxBuffPtr,每接收一个数据,那么 huart->RxXferCount 就减一,直至为0,这时候就会触发接收完成的中断了。至于需要接收几个字节来触发中断,就取决于初始化时候的设置了。( D; @( @& a& p% R; p. ` ^
huart->pRxBuffPtr变为0后,会先关闭中断,如果使能了USE_HAL_UART_REGISTER_CALLBACKS ,就会调用 huart->RxCpltCallback(huart),我们就可以通过注册中断处理函数来跳转到我们自定义的函数,而不是HAL库本身的接收完成中断函数HAL_UART_RxCpltCallback(huart)。而如果我们使能了USE_HAL_UART_REGISTER_CALLBACKS,却没有去注册自定义函数,最终调用的还是HAL库本身的中断处理函数,这是因为在 HAL_UART_Init 初始化中会调用函数 UART_InitCallbacksToDefault,这个函数会将所有的回调函数初始化为其默认值。
0 {9 @$ N6 B; z- |$ ]- p) {注:接收完成后,这个会自动将关闭中断,接收完指定的字节之后,还需要继续接收的话就需要再次打开中断了。; o- E$ q, ~# G4 C
1 ~5 |/ m5 f4 b9 q
- static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)9 J3 e; j8 p& [
- {- ]) u% K+ t1 M2 u7 Z
- uint16_t *tmp;
( m1 u' x8 R" E: l& T* j - 8 P# H' m8 f* D9 h L- F: m
- /* 检查接收进程是否正在进行 */
$ j( @7 A" g" n& G ~* F) U+ h - if (huart->RxState == HAL_UART_STATE_BUSY_RX)
s% e/ W: a4 Y4 L4 a/ m - {
9 W' {5 P, g7 E2 o O* A0 C, Y - if (huart->Init.WordLength == UART_WORDLENGTH_9B)
4 S+ W) ] Z/ w. j - {& ?! B M: ], E
- tmp = (uint16_t *) huart->pRxBuffPtr;5 e) e: N5 G0 E
- if (huart->Init.Parity == UART_PARITY_NONE)" l5 G* S% n. Q$ w0 v9 _
- {
- |) l! V; q4 a - *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x01FF);, x+ D7 x; f4 _; m8 @. w" p
- huart->pRxBuffPtr += 2U;, ]# Z; l% c" a9 T/ w
- }/ k0 s' v6 L4 i4 s& @
- else
" `. G$ K* U6 e# P) R4 t. E% ? - {
( t3 P4 ]# G Z% `+ L6 V5 x+ `1 I9 i - *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x00FF);2 e' H" U. u# |# s3 w) H
- huart->pRxBuffPtr += 1U;
) f4 [4 W! _8 g& G - }
( U' u) Q7 L* `/ {8 P2 y- Y+ p - }$ d# f3 Z8 @6 ?: p
- else
6 g& G% h! \" w' U' U" L - {' q2 t/ E3 o( K; q8 A) f/ R
- if (huart->Init.Parity == UART_PARITY_NONE)4 G/ ?$ a& R: U2 G7 K
- {
2 x+ p. C/ w; R: y ^ - *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x00FF);
; ?+ L$ G3 q2 f0 \1 o - }
$ P# r/ C* R, Z - else
0 H2 A6 i) i) K# b8 d- d% |: c - {. {. E8 S5 o( S$ q2 S6 G' r( q
- *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x007F);
0 P) h# |& s8 a2 i/ h+ m9 |( ], ~& N - }2 z0 X+ `: N, H& e
- }1 v/ t: y( O3 ^* J" L
- 1 Z q! ?1 S8 r9 Z: c2 D
- if (--huart->RxXferCount == 0U)' \: U3 x: c7 @2 m( l& I
- {) X; e+ V6 R5 Z6 n
- /* 禁止UART数据寄存器不为空的中断 */
4 ]& T3 _; l& d! W# d5 r2 E - __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);1 Q$ m7 }- a) X6 g6 s
4 c1 Y; L+ z( I8 T/ U4 Y+ r- /* 禁用UART奇偶校验错误中断 */
8 p+ _% N/ N1 V1 }6 E4 [ - __HAL_UART_DISABLE_IT(huart, UART_IT_PE);9 o: G# b' ?3 ?# X
( W# L* ~" Q' p5 R* `$ R- /* 禁用UART错误中断:(帧错误,噪声错误,溢出错误) */
7 `# j" [& N2 ]: A6 k - __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
& Z/ y+ s% ^4 R& o- a- l
' u& N. S; ?6 h- /* Rx进程完成,将huart-> RxState还原为Ready */0 u/ J& v* X, r, w$ X) _
- huart->RxState = HAL_UART_STATE_READY;
' ~" F; t3 V1 {3 T
. Y! w2 x) S, {. B9 y5 ?- #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
- I& j% Q* L& h0 f - /* 调用注册的Rx完成回调函数 */) J A: j7 L! ]! i- |) C
- huart->RxCpltCallback(huart);5 y( o, g4 ?8 f7 |4 i' M
- #else
1 a; {( K$ _% W+ L - /*调用旧版弱Rx完成回调函数*/
) b/ V. Y2 D* B - HAL_UART_RxCpltCallback(huart);
& O9 [" Z* _# ]; U4 [; G - #endif /* USE_HAL_UART_REGISTER_CALLBACKS */
* J" G: i7 W8 z% n8 n$ ^! {( H) e
2 g. i8 J0 G6 U8 K2 I" w9 O- return HAL_OK;
/ Y& k9 x: b' @1 Y- T( e0 y# m - }
# M1 K0 o8 N* K% d: b0 k - return HAL_OK;
( j) P+ h/ @7 P/ C" S - }
. u3 M& J2 x8 v# z1 F' T - else
1 K. n: m; P4 y( R5 C: D - {
3 Q: c8 A5 u2 _0 e - return HAL_BUSY;
9 I, x( Z$ I5 @ - }3 l# q( r. l8 L1 f7 Y
- }
复制代码
) b% F _; f5 n二、使用方法" @; ~8 w- D- E2 `/ K
原理性的代码解析已经在前面一章节解析了,这一章节就是讲要如何实现,其他的都不难,重点是要知道 USE_HAL_UART_REGISTER_CALLBACKS 这个宏,其他的不懂的地方就可以根据这个线索来一步一步的追踪了。
- A" _# S) \, T0 m& h& \; ] H* i5 F
" q2 Y9 Q g& P, T3 H$ k7 `
, i6 h1 V' r/ W- p图2.1 设置串口参数# R- m/ m3 u. s" H5 ]8 o' \. ~8 p
: E* e7 c, r( q* a& H% [; k
1 ^% S. u7 \4 y+ ^
]5 b3 K" ^4 h$ P图2.2 使能串口中断并设置优先级; }1 z) ^( A3 \. S Q
" R7 K5 L# W2 f$ V. R
前两步都是设置串口中断的设置,按照常规来设置就可以了,重点了如何使能 USE_HAL_UART_REGISTER_CALLBACKS 这个宏,这个宏在 Project Manager 中的 Advanced Settings 右边的 Register Callback 中,选择 UART 为 ENABLE ,注意不是 USART,别选错了。7 f# m! P! D+ C W) L
当然也可以在生成的项目中搜索 USE_HAL_UART_REGISTER_CALLBACKS 手工改成1,但是假如后续又通过STM32CubeMX修改配置的话,再生成代码,会将这里的配置覆盖过去,如果没注意这个点的就很容易出错,建议还是在这里修改比较稳妥一些。
+ p8 o" d6 B. P! U, }/ F4 d8 C: _% e
) f8 y& Y# _" S. S' d' X
2 M/ q7 S5 O1 j( [代码生成之后,默认是没有打开串口中断的,通过 HAL_UART_RegisterCallback() 自定义回调函数,再开启中断就完成了我们的目的。
^9 a$ I2 Y, r; |1 {) i我们可以专门在一个.c文件来自定义接收完成的回调函数并打开中断,在main函数中调用这个初始化函数就可以了。这样就能和其他串口解耦,移植起来就很方便了。比如我需要指定一个串口来使用 Letter Shell( github上的开源项目,我的文章中也有这个教程),那么我就写一个 shell_port.c 文件,仅仅需要通过宏来指定使用shell 的串口句柄,其他的都不需要修改,直接添加这个 c文件,在main函数中使用 userShellInit() 来初始化,就能直接使用这个扩展模块了,相比于其他的方式,这个移植过程可以说是相当简便省事了(其他的形式需要在 usart.c 中定义串口接收的数组,再定义接收的个数,再在中断中移植自己的功能,再在main函数中打开串口中断,每建立一个新的项目都需要这么做,尤其时间长了之后,要配置串口中断的函数的时候就容易忘记函数名称,真的很烦)。
4 f& }7 K, s% z' ^/ f3 b" g
! X8 T! `4 L% H5 P" mHAL_UART_RegisterCallback()
4 o1 j6 E$ ^7 r% N( J4 d+ J这个函数的第一个参数是 huart ,要配置的串口句柄。' p) ]: \% J `' G( H
这个函数的第二个参数是 CallbackID ,不同的外设所支持的回调函数ID不同,对于串口来说,HAL_UART_CallbackIDTypeDef 列出了所支持的各个功能ID,我们要在串口接收完成后调用我们自定义的ID,使用的就是 HAL_UART_RX_COMPLETE_CB_ID 。+ H6 {8 K3 Y; W: w5 E- r* l
这个函数的第三个参数是 pCallback ,我们自定义的回调函数,但是这个函数有要求,参照 pUART_CallbackTypeDef 的定义。返回应该是void,并且需要一个参数 UART_HandleTypeDef *huart。$ T( {5 t7 s( f/ m3 \* l
7 ?" w, ^5 K4 ?6 o2 t( ~9 ]/ F
typedef void (*pUART_CallbackTypeDef)(UART_HandleTypeDef *huart); // pointer to an UART callback function
. w# p% Q6 M( |. B4 U
& T6 t3 y' {- Z6 H. T4 H* s注:这里设置的是每接收一个字节就触发中断,但是HAL库本身处理串口中断标志位后,会关闭中断,所以我们就需要 HAL_UART_Receive_IT 再次开启中断。
, ] I' C% k! m0 C! a8 [
$ [! k) H* h$ }& D0 f2 T% d- #include "shell_port.h"
5 B! D; `+ h) R4 W: k - #include "usart.h"
! P, V/ n; G; w1 l6 @, U) ]0 T3 F - - q% r9 _1 l: B8 v2 k/ Z: T1 x
- Shell shell;$ q3 u( K, \' J$ u* G O2 {* o
- char shellBuffer[512];
* [6 H0 @, a& ], _# a' G
! X. O% Q/ S" x4 O( A: X- #define userShellhuart huart2 //shell 使用到的串口句柄
% ^. t% w! U9 e; [8 c - #define SHELL_UART_REC_LEN_ONCE 1 //串口单次接收的个数" [5 R, M. D$ U
- uint8_t uartRecBuffer[SHELL_UART_REC_LEN_ONCE]; //串口接收的buffer
$ j" q/ L2 D1 p) R% O4 V
{% Y$ K- a0 D, B& C% W7 w- , W0 q) o4 |8 {# R! }" t' J& C
- /**
/ p9 v6 w3 u' v- P7 m6 M `+ I - * @brief 用户shell写) [5 m# I% p) a5 u; t
- *
6 V2 m Q0 k: ?$ m! b3 Q - * @param data 数据
3 r0 H+ X$ C+ Q2 ~3 p - */7 [9 i7 m W" C! ~/ W
- void userShellWrite(char data)
/ I4 I2 F/ O1 ]. K2 F - {
& {; m1 |) [ W" d' u- W - HAL_UART_Transmit(&userShellhuart,(uint8_t *)&data, 1,1000);4 S! h4 }/ \2 _$ y, R) q$ `
- }) t4 a; ?0 @; H& p1 w* m
- 6 O. a" [1 e- R3 b1 ]
1 O0 D0 M0 e6 m) F+ X- /**" ]- s; W2 G+ e r: F( F- Q
- * @brief 用户shell读
6 y7 z# Q, j# E) |( _& C7 w - * ' ~' U* I7 p5 R4 b$ W8 b( V
- * @param data 数据 x; @! ]" a- `# {8 c- X$ {
- * @return char 状态
; Y2 h* d: y; b/ P8 s3 a! P; ] - */4 ^) F/ x! K# Y9 R7 ^8 e
- signed char userShellRead(char *data)
: c* Z k) M' R - {
" j# d/ V/ F2 D: D) i - if(HAL_UART_Receive(&userShellhuart,(uint8_t *)data, 1, 0) == HAL_OK)! p7 b. h3 K# t: O) r9 T/ S, _
- {1 P6 v$ d& M+ b( g
- return 0;* A; w/ H* V- V
- }
# c5 s8 D0 R* {& i - else2 K j9 D. ^- ?( i, O9 ?" U, S i; r
- {3 g2 `1 R4 Q% Y% c" h( R
- return -1;2 `' v5 r" z+ A$ H* u
- }
$ p( p+ C1 y4 @ - }
" x1 q; v- U" i+ M( w$ y, T
5 j3 h8 K* U/ |; C- F$ l- /**
2 n% c/ a: k0 V: z; T - * @brief 自定义函数串口接收完成中断 RxCpltCallback
7 j6 \$ R$ a, A+ y8 S% H+ Q - */; M3 x6 I! r! W, `
- void ShellRxCpltCallback(UART_HandleTypeDef *huart)
r0 G- [' T/ q9 D - {7 n4 ?- ^2 ], l" _; [. G4 |4 @
- shellHandler(&shell, uartRecBuffer[0]); //命令行处理函数) ?/ }+ @/ w3 h+ K& K9 d# P5 p9 h+ p3 y
- HAL_UART_Receive_IT(huart, (uint8_t *)uartRecBuffer, SHELL_UART_REC_LEN_ONCE);//使能串口中断:标志位UART_IT_RXNE,并且设置接收缓冲以及接收缓冲接收最大数据量
' m3 v: M* K# I* r$ N - }1 x0 N1 f# V0 f. Z F; X' N
9 |- J- P0 a1 L5 o' e- /**0 A) S8 o! W+ U5 ?( z% y
- * @brief 注册串口接收中断到自己的自定义函数$ b0 S z( X. ~% f* @+ n
- */
4 v: F3 D1 h9 ?% R1 o - void ShellReceiveCallbackRemap(void)
! ]. i ?' _) ]2 ~ - {$ ^ ]* E \9 \! a
- HAL_UART_RegisterCallback(&userShellhuart,HAL_UART_RX_COMPLETE_CB_ID,ShellRxCpltCallback); //注册串口接收中断到自己的自定义函数/ K4 ]5 \; L0 ] A7 Q4 m
- HAL_UART_Receive_IT(&userShellhuart, (uint8_t *)uartRecBuffer, SHELL_UART_REC_LEN_ONCE); //使能串口中断:标志位UART_IT_RXNE,并且设置接收缓冲以及接收缓冲接收最大数据量 r% N* z# l2 h9 r) z( ]3 q( x! v. d
- }6 C( u0 ~+ B) u0 T% C
A3 v# i8 w6 P8 I( T' m8 p1 R
\- P" }" ^7 G6 L- S% I. X- /**
* S: z) j; F- G$ R& q - * @brief 用户shell初始化
2 |' \- `7 l# u. k/ I" T( z; T% H" S, e - * & J/ b2 ^7 h4 H$ _5 M
- */! K3 W! u) u/ n1 ^1 J" i- I
- void userShellInit(void)
5 y$ N: h9 C5 ?' C* c1 I - {5 Y" y# E) S9 x3 o; I" r5 h
- shell.write = userShellWrite; //指定串口写入的函数
3 x- w `6 f; g7 a& E. Z4 p - shell.read = userShellRead; //指定串口读取的函数
2 N, [" g% b+ S/ ~% J - ShellReceiveCallbackRemap(); //注册串口接收中断到自己的自定义函数
, x% ]. O' A, p) v - shellInit(&shell, shellBuffer, 512);
6 @6 |2 X4 w- H8 |
4 V' c+ W# m1 }) f- }
复制代码 ' A, \; d) l7 J6 i3 W1 P& t/ k1 J1 P
————————————————
: ^/ I9 N* t+ e* o/ b- Y; ~转载:fafuwxm& R; w5 i2 z: _" v' a1 r
0 q' n8 r' x- a+ j
$ Y `% H2 L2 E5 ~
|