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

STM32小技巧(1) HAL自定义串口中断回调 模块化代码进行解耦

[复制链接]
STMCU小助手 发布时间:2022-8-23 16:13
前言* 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
  1. /**" i4 F, L5 W; g( {; ^, O9 z. Y
  2.   * @brief This function handles USART2 global interrupt.
    6 s+ W, H/ w% Q1 H. V4 K
  3.   */
    6 q: e# _% ?0 ~' [
  4. void USART2_IRQHandler(void)
    % Q9 Z0 Q* M: s
  5. {: j" B7 F7 x# ^
  6.   /* USER CODE BEGIN USART2_IRQn 0 */
    " u: Z8 ?) N2 u/ j  V: E2 O) {

  7.   Z( t3 a0 G' _) N: q& W- f& C, i' a
  8.   /* USER CODE END USART2_IRQn 0 */
    * G  o- W0 N% n9 e3 d, X
  9.   HAL_UART_IRQHandler(&huart2);
    , \8 Q- m- p0 q$ e' K: {9 a
  10.   /* USER CODE BEGIN USART2_IRQn 1 *// ?! H$ Z- C, w. E  R" I. h. x

  11. ! Q0 S+ \( ~5 f) ~3 h! c" j
  12.   /* USER CODE END USART2_IRQn 1 */
    ) u5 Q. G, \& Z3 m1 q, L9 y1 {" l
  13. }
复制代码

% ]. 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
  1. void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)) I% j4 B3 V" z- o: K
  2. {7 z: u" l% ^  z( G0 ^  z
  3.   uint32_t isrflags   = READ_REG(huart->Instance->SR);( Q8 _- \' x- [
  4.   uint32_t cr1its     = READ_REG(huart->Instance->CR1);
    3 b" d$ s$ m% M8 K* w2 Q
  5.   uint32_t cr3its     = READ_REG(huart->Instance->CR3);- \1 c6 p# `" i  o5 a; g, z/ a
  6.   uint32_t errorflags = 0x00U;% z) J. A+ h! d/ d
  7.   uint32_t dmarequest = 0x00U;/ c7 x8 d; j. a, w7 [0 `# g

  8. ) _6 l; v) F' y7 q5 ]$ e3 g. _; S  _
  9.   /* 如果没有错误发生 */2 ]7 ]9 T, j& l% V" D
  10.   errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));$ F' I8 d3 p; M8 T4 y8 `
  11.   if (errorflags == RESET)
    3 ]8 H' G. B0 C0 X% q
  12.   {; Q7 f- f) E* Q
  13.     /* UART处于接收模式 -------------------------------------------------*/
    0 k  ?8 c# x9 L2 J$ F3 L4 @; [: U
  14.     if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
    ; y! p; |8 f& U, C$ z* \6 q
  15.     {
    8 a6 m% c6 Y5 |4 c
  16.       UART_Receive_IT(huart);
    ( W4 O$ w5 H6 [; X
  17.       return;
    . X/ v$ g7 Q% _- E& p% o
  18.     }4 [& F4 a* N! S; w7 D+ a
  19.   }+ N% W6 B% g  Q9 R$ P8 r

  20. 5 d# h+ V7 l& s5 j6 G- L9 I# d/ T
  21.   /* 如果发生一些错误 */
    & V" O, h0 i) J- l
  22.   if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
    4 d( R, d2 S4 `, Q, v
  23.   {
    9 {3 ^" K& U" X3 B. O
  24.     /* UART parity error interrupt occurred ----------------------------------*/( G8 D& Y: ~, t
  25.     if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
    2 K/ s: |1 S, k6 S6 a0 x7 @3 L8 [
  26.     {8 v) [# U2 ]& N: s$ E
  27.       huart->ErrorCode |= HAL_UART_ERROR_PE;
    $ M9 K6 \  g6 {( {0 v/ s
  28.     }
    " U0 s' {4 K7 t/ s
  29. % M& i. f8 R) `
  30.     /* UART noise error interrupt occurred -----------------------------------*/4 w$ `3 l9 y1 s9 c8 w- a! O5 ^
  31.     if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))1 ~' F: q: E8 z! a, i
  32.     {- }/ {/ w9 H$ A2 \4 s8 K' _
  33.       huart->ErrorCode |= HAL_UART_ERROR_NE;
    0 D% J! h. {0 C# x, G4 Y, v
  34.     }* y. d" s( v. |  g1 [

  35. ! S8 ?& A* i7 I5 m5 I5 N
  36.     /* UART frame error interrupt occurred -----------------------------------*/
    8 R, \5 [* T- Z, ^2 _; O0 i
  37.     if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
    : J" O" f. C7 \) l. t3 D0 o& X4 D
  38.     {
    4 O2 g+ v- I9 T  B, O. f
  39.       huart->ErrorCode |= HAL_UART_ERROR_FE;6 O( \! Y6 q: s1 b/ g- z
  40.     }
    6 S( H/ h# l! o7 o0 d7 l8 g# t) f
  41. 3 K, o! Y( x% y+ a7 i" _& J# s, \3 L
  42.     /* UART Over-Run interrupt occurred --------------------------------------*/
    ; ^8 ?, D7 M/ B" E0 E
  43.     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
  44.     {2 {! W6 V* G) f. Z0 M
  45.       huart->ErrorCode |= HAL_UART_ERROR_ORE;# v' F& G. T: ^
  46.     }& [/ f0 n2 n( `' o  Q

  47. ( W& ?/ q( M4 N- p6 Y
  48.     /* Call UART Error Call back function if need be --------------------------*/
    8 j- x0 w0 P2 i6 i8 A! W) s
  49.     if (huart->ErrorCode != HAL_UART_ERROR_NONE)
    * o( N) D! r4 }6 Y& U! G1 v) ?. O: T
  50.     {9 s- W& Y9 M! k6 G# x' t2 q7 |+ O
  51.       /* UART in mode Receiver -----------------------------------------------*/
    . b3 G2 D. m9 t( Z
  52.       if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
    8 ~) o. m! u2 i) K
  53.       {. P  ^9 t, A- H' m6 R7 t# r  J# B
  54.         UART_Receive_IT(huart);
    ) @4 @3 d( d/ z5 P$ Z
  55.       }. x9 Y: V0 \' q2 I# |% D- f

  56. ) P4 K2 E$ W8 F/ W( V( H; f# I
  57.       /* If Overrun error occurs, or if any error occurs in DMA mode reception,3 l" M- H4 j% B; {+ v! _2 M
  58.          consider error as blocking */
    5 X. k: y9 i6 W5 T5 I0 K- G5 [0 K
  59.       dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
    6 V2 {/ b7 |2 `" i3 I: i# ]
  60.       if (((huart->ErrorCode & HAL_UART_ERROR_ORE) != RESET) || dmarequest)
    ( \1 E; s. b0 g7 ~" x1 O' S# O
  61.       {0 p1 t4 i! x, u  W* l2 |
  62.         /* Blocking error : transfer is aborted2 @5 e  u, z% K. O" S- D/ U
  63.            Set the UART state ready to be able to start again the process,
    2 x2 X4 v9 _2 ~) Z
  64.            Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
    ; E% n- k8 l/ g
  65.         UART_EndRxTransfer(huart);  u! I0 E" l# M: g; S$ o, l
  66. % E) Q# g3 k! d! {  Q2 E% e; k" P0 r
  67.         /* Disable the UART DMA Rx request if enabled */
    * O# b2 F3 P3 B6 C" M# H# L/ E) x
  68.         if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
    + ]0 f, o) G% ?! j  ]
  69.         {
    " T, V) q# |9 T8 O' B4 }% G
  70.           CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);/ x" \& O$ o+ f2 r9 O
  71. # ^3 m% C0 L5 F& m
  72.           /* Abort the UART DMA Rx channel */
    $ T4 G  i* k. W- B. O! q* G7 f
  73.           if (huart->hdmarx != NULL)- ~. f+ |# U1 D( z4 a
  74.           {, G$ }+ O+ Z9 u3 d8 b$ }
  75.             /* Set the UART DMA Abort callback :
    . A. P  x# z( J- S  u' |+ q
  76.                will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */. H) y1 T2 i4 x( e6 \- ]: o
  77.             huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;6 N" L0 V5 T; w# X. w9 Z. b  ]( p
  78.             if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)# ^- v* D* ^# m9 F
  79.             {, L: v2 I+ w5 V1 w. G# P
  80.               /* Call Directly XferAbortCallback function in case of error */7 @: G, t0 H  u  H/ l; Z4 C
  81.               huart->hdmarx->XferAbortCallback(huart->hdmarx);$ C# N2 t8 h) D% V3 ?2 N/ c
  82.             }) \  G& P7 v9 B1 t
  83.           }! |: }. B5 C! U
  84.           else
    % T9 {4 L4 F, s# }; O6 M5 b
  85.           {# G7 Y9 ?, ~7 Q0 k7 Y/ K
  86.             /* Call user error callback */2 ]6 V3 E  G' p7 O* C# P
  87. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)  ?$ \" [, }. N* l
  88.             /*Call registered error callback*/2 A/ B1 H; |, |% N6 B
  89.             huart->ErrorCallback(huart);$ Q$ ]" ~; ]$ m3 d+ \
  90. #else* @- }7 f2 V2 s9 |$ b
  91.             /*Call legacy weak error callback*// J2 V; G+ t) z8 k- s$ f# T: x' n
  92.             HAL_UART_ErrorCallback(huart);
    2 [! _7 J' [6 W" Y  U2 W1 E/ _1 f/ V
  93. #endif /* USE_HAL_UART_REGISTER_CALLBACKS */- w! `. D% E8 R( |! N1 o
  94.           }1 p8 O6 c; q: p3 V, s! Y
  95.         }
    4 M# a" W( a; c
  96.         else
    1 O) i! v% R% g9 |/ N# ^+ S9 U
  97.         {$ S8 s9 R$ T5 {0 ]
  98.           /* Call user error callback */! V+ d; b% X5 A: y& M& c$ ~/ m* U
  99. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)& o! U9 s3 b& t) \  H0 y
  100.           /*Call registered error callback*/, @6 F4 \8 ~( ?# Q+ D1 K+ F  q
  101.           huart->ErrorCallback(huart);
    ) v  w  S; C7 {
  102. #else
    - I/ T& v* M/ W$ F* S, d$ W- Q
  103.           /*Call legacy weak error callback*/% S* R0 _4 m/ o: U
  104.           HAL_UART_ErrorCallback(huart);1 O, _% W$ a6 `! `# G
  105. #endif /* USE_HAL_UART_REGISTER_CALLBACKS */2 z1 N# r+ z% W6 d
  106.         }
    * z: O3 O$ x' g4 [; c1 k
  107.       }
    0 F0 V) m2 M7 r
  108.       else1 o+ ]8 w# o1 H+ U- f  p# c  |- j/ u
  109.       {
    : t( R0 P) K6 Z" W  M4 T8 r& ?
  110.         /* Non Blocking error : transfer could go on.
    / J. i  s# Q$ N* k7 F& x4 J
  111.            Error is notified to user through user error callback */
    ! S3 i) f9 y7 p) P: [5 i
  112. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    3 H% F. k* p9 ?* H' f' r. }8 s
  113.         /*Call registered error callback*/
    9 ~) d' J) }& ?9 e8 L/ f
  114.         huart->ErrorCallback(huart);
    + D# d+ H0 k9 b  m  n' i; B# I5 M
  115. #else0 B5 d9 ]* y/ N  K7 K& |
  116.         /*Call legacy weak error callback*/
    ( W6 @4 h' y- t/ _  s& T' [1 T
  117.         HAL_UART_ErrorCallback(huart);6 Q( e* L! d1 v' B% m/ L4 x
  118. #endif /* USE_HAL_UART_REGISTER_CALLBACKS */
    7 {3 \5 w1 [; C) j" q0 i' X
  119. 6 |, E& I6 g- X/ a% j+ T- G
  120.         huart->ErrorCode = HAL_UART_ERROR_NONE;  {# }1 w' x" }9 m% N) {
  121.       }; }. A+ |' o7 ]3 G9 l, U
  122.     }
    ) Y. C' L: Y9 Z9 k
  123.     return;" u- E1 `- w3 u% t+ F) S
  124.   } /* 如果发生错误则结束 */# l2 z/ k, a5 `2 G: E
  125. 2 v9 N& ~/ W: a' U1 T
  126.   /* UART 处于发送模式,准备在非阻塞模式下发送大量数据。 ---------------------------*/
    1 h/ U7 j# ^: c+ d/ {5 N
  127.   if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))" ~2 |+ @, i. v* C1 c0 h' n
  128.   {
    % ~. ?. A* R" G) g2 F) X
  129.     UART_Transmit_IT(huart);
    & m, y% P$ |6 J/ e2 V
  130.     return;
    : v! O# s+ ~0 a' i% k0 b9 |2 [' Z
  131.   }! r& ?8 f, m" k8 g+ V; a' o( X9 u

  132. # D, Z+ n, {4 N# c" E; T: V. |1 Z
  133.   /*  UART 处于发送结束模式,在非阻塞模式下结束传输。 -------------------------------*/
    ( g* G& G0 u+ v
  134.   if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET)). z( ]9 D0 r3 n- {
  135.   {
    * Q4 d! N- Q9 ^0 m# |" l9 T
  136.     UART_EndTransmit_IT(huart);
    % E; k. n: e% k7 r3 y- P/ D
  137.     return;
    ' I& ^  ]; R$ f& `; o& Q$ c
  138.   }
    . v; j% H# y# S' t" o8 Y
  139. }
复制代码
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
  1. static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)9 J3 e; j8 p& [
  2. {- ]) u% K+ t1 M2 u7 Z
  3.   uint16_t *tmp;
    ( m1 u' x8 R" E: l& T* j
  4. 8 P# H' m8 f* D9 h  L- F: m
  5.   /* 检查接收进程是否正在进行 */
    $ j( @7 A" g" n& G  ~* F) U+ h
  6.   if (huart->RxState == HAL_UART_STATE_BUSY_RX)
      s% e/ W: a4 Y4 L4 a/ m
  7.   {
    9 W' {5 P, g7 E2 o  O* A0 C, Y
  8.     if (huart->Init.WordLength == UART_WORDLENGTH_9B)
    4 S+ W) ]  Z/ w. j
  9.     {& ?! B  M: ], E
  10.       tmp = (uint16_t *) huart->pRxBuffPtr;5 e) e: N5 G0 E
  11.       if (huart->Init.Parity == UART_PARITY_NONE)" l5 G* S% n. Q$ w0 v9 _
  12.       {
    - |) l! V; q4 a
  13.         *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x01FF);, x+ D7 x; f4 _; m8 @. w" p
  14.         huart->pRxBuffPtr += 2U;, ]# Z; l% c" a9 T/ w
  15.       }/ k0 s' v6 L4 i4 s& @
  16.       else
    " `. G$ K* U6 e# P) R4 t. E% ?
  17.       {
    ( t3 P4 ]# G  Z% `+ L6 V5 x+ `1 I9 i
  18.         *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x00FF);2 e' H" U. u# |# s3 w) H
  19.         huart->pRxBuffPtr += 1U;
    ) f4 [4 W! _8 g& G
  20.       }
    ( U' u) Q7 L* `/ {8 P2 y- Y+ p
  21.     }$ d# f3 Z8 @6 ?: p
  22.     else
    6 g& G% h! \" w' U' U" L
  23.     {' q2 t/ E3 o( K; q8 A) f/ R
  24.       if (huart->Init.Parity == UART_PARITY_NONE)4 G/ ?$ a& R: U2 G7 K
  25.       {
    2 x+ p. C/ w; R: y  ^
  26.         *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x00FF);
    ; ?+ L$ G3 q2 f0 \1 o
  27.       }
    $ P# r/ C* R, Z
  28.       else
    0 H2 A6 i) i) K# b8 d- d% |: c
  29.       {. {. E8 S5 o( S$ q2 S6 G' r( q
  30.         *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x007F);
    0 P) h# |& s8 a2 i/ h+ m9 |( ], ~& N
  31.       }2 z0 X+ `: N, H& e
  32.     }1 v/ t: y( O3 ^* J" L
  33. 1 Z  q! ?1 S8 r9 Z: c2 D
  34.     if (--huart->RxXferCount == 0U)' \: U3 x: c7 @2 m( l& I
  35.     {) X; e+ V6 R5 Z6 n
  36.       /* 禁止UART数据寄存器不为空的中断 */
    4 ]& T3 _; l& d! W# d5 r2 E
  37.       __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);1 Q$ m7 }- a) X6 g6 s

  38. 4 c1 Y; L+ z( I8 T/ U4 Y+ r
  39.       /* 禁用UART奇偶校验错误中断 */
    8 p+ _% N/ N1 V1 }6 E4 [
  40.       __HAL_UART_DISABLE_IT(huart, UART_IT_PE);9 o: G# b' ?3 ?# X

  41. ( W# L* ~" Q' p5 R* `$ R
  42.       /* 禁用UART错误中断:(帧错误,噪声错误,溢出错误) */
    7 `# j" [& N2 ]: A6 k
  43.       __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
    & Z/ y+ s% ^4 R& o- a- l

  44. ' u& N. S; ?6 h
  45.       /* Rx进程完成,将huart-> RxState还原为Ready */0 u/ J& v* X, r, w$ X) _
  46.       huart->RxState = HAL_UART_STATE_READY;
    ' ~" F; t3 V1 {3 T

  47. . Y! w2 x) S, {. B9 y5 ?
  48. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    - I& j% Q* L& h0 f
  49.       /* 调用注册的Rx完成回调函数 */) J  A: j7 L! ]! i- |) C
  50.       huart->RxCpltCallback(huart);5 y( o, g4 ?8 f7 |4 i' M
  51. #else
    1 a; {( K$ _% W+ L
  52.       /*调用旧版弱Rx完成回调函数*/
    ) b/ V. Y2 D* B
  53.       HAL_UART_RxCpltCallback(huart);
    & O9 [" Z* _# ]; U4 [; G
  54. #endif /* USE_HAL_UART_REGISTER_CALLBACKS */
    * J" G: i7 W8 z% n8 n$ ^! {( H) e

  55. 2 g. i8 J0 G6 U8 K2 I" w9 O
  56.       return HAL_OK;
    / Y& k9 x: b' @1 Y- T( e0 y# m
  57.     }
    # M1 K0 o8 N* K% d: b0 k
  58.     return HAL_OK;
    ( j) P+ h/ @7 P/ C" S
  59.   }
    . u3 M& J2 x8 v# z1 F' T
  60.   else
    1 K. n: m; P4 y( R5 C: D
  61.   {
    3 Q: c8 A5 u2 _0 e
  62.     return HAL_BUSY;
    9 I, x( Z$ I5 @
  63.   }3 l# q( r. l8 L1 f7 Y
  64. }
复制代码

) b% F  _; f5 n二、使用方法" @; ~8 w- D- E2 `/ K
原理性的代码解析已经在前面一章节解析了,这一章节就是讲要如何实现,其他的都不难,重点是要知道 USE_HAL_UART_REGISTER_CALLBACKS 这个宏,其他的不懂的地方就可以根据这个线索来一步一步的追踪了。
- A" _# S) \, T0 m& h& \; ]  H* i5 F
20210131202630176.png " 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
2021013120265496.png
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
20210131203021383.png
) 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
  1. #include "shell_port.h"
    5 B! D; `+ h) R4 W: k
  2. #include "usart.h"
    ! P, V/ n; G; w1 l6 @, U) ]0 T3 F
  3. - q% r9 _1 l: B8 v2 k/ Z: T1 x
  4. Shell shell;$ q3 u( K, \' J$ u* G  O2 {* o
  5. char shellBuffer[512];
    * [6 H0 @, a& ], _# a' G

  6. ! X. O% Q/ S" x4 O( A: X
  7. #define userShellhuart                             huart2        //shell 使用到的串口句柄
    % ^. t% w! U9 e; [8 c
  8. #define SHELL_UART_REC_LEN_ONCE         1           //串口单次接收的个数" [5 R, M. D$ U
  9. uint8_t uartRecBuffer[SHELL_UART_REC_LEN_ONCE];                //串口接收的buffer
    $ j" q/ L2 D1 p) R% O4 V

  10.   {% Y$ K- a0 D, B& C% W7 w
  11. , W0 q) o4 |8 {# R! }" t' J& C
  12. /**
    / p9 v6 w3 u' v- P7 m6 M  `+ I
  13. * @brief 用户shell写) [5 m# I% p) a5 u; t
  14. *
    6 V2 m  Q0 k: ?$ m! b3 Q
  15. * @param data 数据
    3 r0 H+ X$ C+ Q2 ~3 p
  16. */7 [9 i7 m  W" C! ~/ W
  17. void userShellWrite(char data)
    / I4 I2 F/ O1 ]. K2 F
  18. {
    & {; m1 |) [  W" d' u- W
  19.   HAL_UART_Transmit(&userShellhuart,(uint8_t *)&data, 1,1000);4 S! h4 }/ \2 _$ y, R) q$ `
  20. }) t4 a; ?0 @; H& p1 w* m
  21. 6 O. a" [1 e- R3 b1 ]

  22. 1 O0 D0 M0 e6 m) F+ X
  23. /**" ]- s; W2 G+ e  r: F( F- Q
  24. * @brief 用户shell读
    6 y7 z# Q, j# E) |( _& C7 w
  25. * ' ~' U* I7 p5 R4 b$ W8 b( V
  26. * @param data 数据  x; @! ]" a- `# {8 c- X$ {
  27. * @return char 状态
    ; Y2 h* d: y; b/ P8 s3 a! P; ]
  28. */4 ^) F/ x! K# Y9 R7 ^8 e
  29. signed char userShellRead(char *data)
    : c* Z  k) M' R
  30. {
    " j# d/ V/ F2 D: D) i
  31.   if(HAL_UART_Receive(&userShellhuart,(uint8_t *)data, 1, 0) == HAL_OK)! p7 b. h3 K# t: O) r9 T/ S, _
  32.   {1 P6 v$ d& M+ b( g
  33.       return 0;* A; w/ H* V- V
  34.   }
    # c5 s8 D0 R* {& i
  35.   else2 K  j9 D. ^- ?( i, O9 ?" U, S  i; r
  36.   {3 g2 `1 R4 Q% Y% c" h( R
  37.       return -1;2 `' v5 r" z+ A$ H* u
  38.   }
    $ p( p+ C1 y4 @
  39. }
    " x1 q; v- U" i+ M( w$ y, T

  40. 5 j3 h8 K* U/ |; C- F$ l
  41. /**
    2 n% c/ a: k0 V: z; T
  42. * @brief 自定义函数串口接收完成中断 RxCpltCallback
    7 j6 \$ R$ a, A+ y8 S% H+ Q
  43. */; M3 x6 I! r! W, `
  44. void ShellRxCpltCallback(UART_HandleTypeDef *huart)
      r0 G- [' T/ q9 D
  45. {7 n4 ?- ^2 ], l" _; [. G4 |4 @
  46.   shellHandler(&shell, uartRecBuffer[0]);   //命令行处理函数) ?/ }+ @/ w3 h+ K& K9 d# P5 p9 h+ p3 y
  47.   HAL_UART_Receive_IT(huart, (uint8_t *)uartRecBuffer, SHELL_UART_REC_LEN_ONCE);//使能串口中断:标志位UART_IT_RXNE,并且设置接收缓冲以及接收缓冲接收最大数据量
    ' m3 v: M* K# I* r$ N
  48. }1 x0 N1 f# V0 f. Z  F; X' N

  49. 9 |- J- P0 a1 L5 o' e
  50. /**0 A) S8 o! W+ U5 ?( z% y
  51. * @brief 注册串口接收中断到自己的自定义函数$ b0 S  z( X. ~% f* @+ n
  52. */
    4 v: F3 D1 h9 ?% R1 o
  53. void ShellReceiveCallbackRemap(void)
    ! ]. i  ?' _) ]2 ~
  54. {$ ^  ]* E  \9 \! a
  55.   HAL_UART_RegisterCallback(&userShellhuart,HAL_UART_RX_COMPLETE_CB_ID,ShellRxCpltCallback);    //注册串口接收中断到自己的自定义函数/ K4 ]5 \; L0 ]  A7 Q4 m
  56.   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
  57. }6 C( u0 ~+ B) u0 T% C

  58.   A3 v# i8 w6 P8 I( T' m8 p1 R

  59.   \- P" }" ^7 G6 L- S% I. X
  60. /**
    * S: z) j; F- G$ R& q
  61. * @brief 用户shell初始化
    2 |' \- `7 l# u. k/ I" T( z; T% H" S, e
  62. * & J/ b2 ^7 h4 H$ _5 M
  63. */! K3 W! u) u/ n1 ^1 J" i- I
  64. void userShellInit(void)
    5 y$ N: h9 C5 ?' C* c1 I
  65. {5 Y" y# E) S9 x3 o; I" r5 h
  66.   shell.write = userShellWrite;         //指定串口写入的函数
    3 x- w  `6 f; g7 a& E. Z4 p
  67.   shell.read = userShellRead;           //指定串口读取的函数
    2 N, [" g% b+ S/ ~% J
  68.   ShellReceiveCallbackRemap();          //注册串口接收中断到自己的自定义函数
    , x% ]. O' A, p) v
  69.   shellInit(&shell, shellBuffer, 512);
    6 @6 |2 X4 w- H8 |

  70. 4 V' c+ W# m1 }) f
  71. }
复制代码
' 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 ~
赞 收藏 评论0 发布时间:2022-8-23 16:13

举报

0个回答

所属标签

相似技术帖

官网相关资源

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