一、串口初始化过程
1、时钟使能；
- J# ~: W& j4 j
" W# b* K7 m' x9 @2、GPIO初始化；

3、串口波特率设置；

4、串口控制；
  K# i, R: {6 {- ^! L
5 \$ B. f+ N- L! X% P5 a2 v( b5、数据发送与接收

! L7 @! e% C( w( U8 g0 y' D- I
. }. S: j5 K2 u. e' s1 L二、几个重要的串口函数

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); // 串口初始化
   , F+ \/ t' ?+ l9 p) q
2. 
   
3. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口发送
   
4. 
   
5. HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口接收
   - @- ^2 x4 d# M7 c. b
6. 
   : _* Y, S& Y* Q5 g
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   
8. 
   / A; w2 g+ F3 z" _9 l5 E
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
   
10. 
    3 T% z' }: d3 C, y, ?
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

5 P2 |1 `/ M- Y# f6 A' w三、几个重要的结构

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   1 O4 X; M$ q* x  J8 s9 p# D8 }% H
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   
3. typedef struct
   4 R- q) E: Q( J. e. P+ h7 s
4. {
   ) {1 p9 d+ ~5 [2 [! J$ Z. k
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   
6. 
   
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   : v# q' \7 ]0 I3 G8 ]. i
8. 
   ) Y3 h  u1 K/ ^. R, g- F* i
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   
10. 
    
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
      J" H# J1 C8 I& I, D+ _, q
12. 
    
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    ( n! [2 h3 N! K) s! \" N
14. 
    
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    
16. 
      Q& q+ @3 [2 `% n+ N& f
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    
18. 
    
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    5 R. `2 k+ u3 U- u, A# q/ H$ `
20. 
    7 u2 Q; |" `. s$ v
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    
22. 
    
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    ' f3 z: {+ A! J/ {7 r  u( B
24. 
    
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    
26. 
    $ m& @' w* d. }6 p+ J7 N; n7 _9 i
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
28. 
    ! u4 x  V6 \0 t2 [  E( H6 _
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    
30. 
    % P/ A3 ?1 E# X
31.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    
32.                                                   and also related to Tx operations.
    , `" g, k1 Y8 Z" t: Q8 w
33.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    5 j$ U  b! l% F, q" [& c# J$ w, S3 E
34. 
    
35.   __IO HAL_UART_StateTypeDef    RxState;     /*!< UART state information related to Rx operations.
    
36.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
37. 
    
38.   __IO uint32_t             ErrorCode;   /*!< UART Error code                    */
    . z1 D& I  I8 ]( @
39. 
    
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   * J& }6 c+ p: H. R( C1 j
2. typedef struct
   ' J* Y- Q, y0 B, D  D
3. {
   7 z4 c# E! K% o+ k6 K- k7 B9 A9 `
4.   __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
   4 B  Q. [2 G( b0 d
5.   __IO uint32_t CR2;    /*!< USART Control register 2,                 Address offset: 0x04 */
   
6.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   7 |+ D- `4 G: |+ a3 h- H
7.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */                                               
   . Y5 U; p9 Z5 P  m  c; |) d
8.   __IO uint32_t GTPR;   /*!< USART Guard time and prescaler register,  Address offset: 0x10 */
     M* q2 \) O( J# j9 Y5 L/ B4 r
9.   __IO uint32_t RTOR;   /*!< USART Receiver Time Out register,         Address offset: 0x14 */  
   
10.   __IO uint32_t RQR;    /*!< USART Request register,                   Address offset: 0x18 */
    % j  ?0 T4 p4 D( {
11.   __IO uint32_t ISR;    /*!< USART Interrupt and status register,      Address offset: 0x1C */
    
12.   __IO uint32_t ICR;    /*!< USART Interrupt flag Clear register,      Address offset: 0x20 */
    
13.   __IO uint32_t RDR;    /*!< USART Receive Data register,              Address offset: 0x24 */
    ) P9 c$ c& l& `3 L. e
14.   __IO uint32_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    
15. } USART_TypeDef;

复制代码

1. // 设置串口的各个参数 波特率 字长 停止位 奇偶校验 收发模式 硬件流 过采样
   
2. // 字长：8位/9位
   
3. // 停止位：1位/2位
   " d. Y3 m2 w4 A  e
4. typedef struct
   
5. {
   % V" `* b! s' I
6.   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
   8 x. Q1 y. t$ V$ X' n
7.                                            The baud rate register is computed using the following formula:
   
8.                                            - If oversampling is 16 or in LIN mode,
   9 f5 g: s5 Z( [/ e8 s0 I
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
   
10.                                            - If oversampling is 8,
    
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    4 j: B6 C, T3 p* k) c5 w8 g" F. \5 Q% C
12.                                               Baud Rate Register[3] =  0
    . F3 \- R$ Q& r/ ~' c! B4 K3 J
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
      k6 ?! W5 l) N4 i& R: ~
14. 
    
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
    / P9 B: g- n3 j+ u. c
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    
17. 
    
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    
19.                                            This parameter can be a value of @ref UART_Stop_Bits */
    
20. 
    8 M, G& n3 \9 J6 W8 M. v
21.   uint32_t Parity;                    /*!< Specifies the parity mode.
    
22.                                            This parameter can be a value of @ref UART_Parity
    
23.                                            @note When parity is enabled, the computed parity is inserted
    1 j* S* k1 q' l8 T
24.                                                  at the MSB position of the transmitted data (9th bit when
    
25.                                                  the word length is set to 9 data bits; 8th bit when the
    
26.                                                  word length is set to 8 data bits). */
    8 Y( I' J- g0 k$ U4 K- f
27. 
    
28.   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
    ( z. ^# W9 B" n% s" m
29.                                            This parameter can be a value of @ref UART_Mode */
    . X4 `. I5 J7 b" k+ _( i
30. 
    6 t( ?; c  ^2 g# O0 |8 D
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    ! G/ s  R- ^0 a
32.                                            or disabled.
    # L& [  v  ]- w# X( M
33.                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
    ) g- T2 Z0 b7 j) B- C
34. 
    - X+ x5 Y' R; g: {
35.   uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8).
    
36.                                            This parameter can be a value of @ref UART_Over_Sampling */
    ! O$ A* C  k+ b9 n
37. 
    
38.   uint32_t OneBitSampling;            /*!< Specifies whether a single sample or three samples' majority vote is selected.
    
39.                                            Selecting the single sample method increases the receiver tolerance to clock
    0 O# T# D4 G# ~% V0 Q
40.                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling */
    
41. }UART_InitTypeDef;

复制代码

四、基本接口设计
我们使用中断接收，普通发送。中断接收到的数据放入队列中，在外部可配置每路串口的功能。

1. // 抽象出一个串口设备结构体
   # K+ m+ ?: Q- Q, i) u/ r
2. typedef struct
   0 e  D. e6 f) G. \! B& W, x, ]9 i
3. {
   
4.   UART_HandleTypeDef handle; // 串口句柄
   
5.   uart_queue_t recv;         // 接收队列
   
6.   uart_queue_t send;         // 发送队列
   , U: A- q$ I+ ~4 w& F
7.   uint8_t ret;               // 接收的值
   + N( Q/ R8 w, h' n
8. } uart_dev_t;
   
9. 
   $ D! p$ }; C. G$ M. o  a
10. static uart_dev_t uart1_dev;
    8 Z) p: X/ ?) O# [
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
     o" P% y) u7 ?+ s3 Y
2. typedef enum
   
3. {
   
4.   UART_CHANNEL_NONE,
   - n" m2 `+ B, T7 a
5.   UART_CHANNEL_1,
   % R" o) e" s7 }- [9 [# I0 f
6.   UART_CHANNEL_2,
   
7.   UART_CHANNEL_NUM
   
8. } uart_channel_t;
   + p( q- `1 ?) B9 M
9. 
   2 t. F1 v- z' a0 D
10. // 宏定义串口的基本信息 之所以这样写，方便移植修改
    
11. #define UART1_CHANNEL             USART1
    5 y$ d& Z' J$ Q7 C4 m) Q
12. #define UART1_PREEMPT_PRIO        UART1_PRIORITY
    , u6 c  ]6 b0 }/ h" w
13. #define UART1_IRQ                 USART1_IRQn
    ! S. w5 J6 L% p9 _$ v# x, X
14. #define UART1_IRQ_FUNC            USART1_IRQHandler
    
15. #define UART1_CLK_ENABLE()        __HAL_RCC_USART1_CLK_ENABLE()
    
16. #define UART1_TX_PORT             GPIOA
    
17. #define UART1_TX_PIN              GPIO_PIN_10
    
18. #define UART1_TX_AF               GPIO_AF7_USART1
    
19. #define UART1_TX_CONFIG()         GPIOConfigExt(UART1_TX_PORT, UART1_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_TX_AF)
    6 I4 `7 g$ k6 d$ X$ w+ J0 S5 F# p
20. #define UART1_RX_PORT             GPIOA
    
21. #define UART1_RX_PIN              GPIO_PIN_9
    2 j3 F* r% R+ ]- n/ H8 @' F
22. #define UART1_RX_AF               GPIO_AF7_USART1
    
23. #define UART1_RX_CONFIG()         GPIOConfigExt(UART1_RX_PORT, UART1_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_RX_AF)
    
24. 
    , A! x# @3 s7 G
25. #define UART2_CHANNEL             USART2
    
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    & X& v; R" X& r7 Q" ?- J
27. #define UART2_IRQ                 USART2_IRQn
    + i/ D* G$ b3 @
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    : C$ g7 E! ?0 r) \" i
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    " k3 H) ?  k* J6 f& o5 |; F- L( T  o# o
30. #define UART2_TX_PORT             GPIOA
    4 n; ]+ H0 m4 X0 W: Z; y& X6 _
31. #define UART2_TX_PIN              GPIO_PIN_2
    ) e/ G2 B3 c4 g" y
32. #define UART2_TX_AF               GPIO_AF7_USART2
    * l6 F0 T4 S& q) Z
33. #define UART2_TX_CONFIG()         GPIOConfigExt(UART2_TX_PORT, UART2_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_TX_AF)
    ) U0 o) s' Z6 L6 o: l
34. #define UART2_RX_PORT             GPIOA
    # r$ y: M) g& _- v$ t
35. #define UART2_RX_PIN              GPIO_PIN_3
    1 G! f7 G% A" s# ^
36. #define UART2_RX_AF               GPIO_AF7_USART2
    5 M2 g' a! `& k, Y! N
37. #define UART2_RX_CONFIG()         GPIOConfigExt(UART2_RX_PORT, UART2_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_RX_AF)

复制代码

1. // 串口的基本操作
   7 Y  [8 I; p( s
2. // 串口1
   
3. static void uart1_var_init(void)
   
4. {
   
5.   uart1_dev.recv = uart1_queue_recv;
   
6.   uart1_dev.send = uart1_queue_send;
   9 s- U! h7 ^" v9 T6 N" t
7. 
   
8.   UartQueueInit(&uart1_dev.recv);
   
9.   UartQueueInit(&uart1_dev.send);
   - }& \. i1 Z- Y3 [& P" s; z
10. }
    0 M' t6 w6 A0 f: V, ?+ A; Q9 F
11. 
    
12. static void uart1_gpio_init(void)
    
13. {
    
14.   UART1_RX_CONFIG();
    * ^1 n+ k& ~! z4 [( f) t
15.   UART1_TX_CONFIG();
    " }$ @( S/ W; y
16. }
    
17. 
    
18. static void uart1_mode_init(uint32_t bound)
    # c  V- ^  |% R' _
19. {
    ! a2 j& \/ ^$ T2 X* N& n6 T  [
20.   UART1_CLK_ENABLE();
      ]3 Y8 o" S- l; d$ N8 `& }
21. 
    ; a) D% S8 T) ~+ y! l7 S
22.   uart1_dev.handle.Instance = UART1_CHANNEL;
    
23.   uart1_dev.handle.Init.BaudRate = bound;                // 波特率
    
24.   uart1_dev.handle.Init.WordLength = UART_WORDLENGTH_8B; // 字长为8位数据格式
    
25.   uart1_dev.handle.Init.StopBits = UART_STOPBITS_1;      // 一个停止位
    ( |  }4 s# y" {* S5 u% K
26.   uart1_dev.handle.Init.Parity = UART_PARITY_NONE;       // 无奇偶校验位
    
27.   uart1_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 无硬件流控
    . [- H' X! z8 l# T3 P8 U& N0 V
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    7 t  ]7 a; b! {
30. }
    , e/ `( b% O9 x, k
31. 
    
32. static void uart1_nvic_init(void)
    
33. {
    
34.   HAL_NVIC_SetPriority(UART1_IRQ, UART1_PREEMPT_PRIO, 3);
    
35.   HAL_NVIC_EnableIRQ(UART1_IRQ);
    " A' _0 g0 z0 g$ u  R4 C" C
36. 
    
37.   __HAL_UART_ENABLE_IT(&uart1_dev.handle, UART_IT_RXNE);
    
38. }
    : K0 @8 ^; f: l8 N8 ~( {! s
39. 
    : _/ h% T5 c$ u% W% b
40. // 串口2
    4 e0 F6 b* Y3 o
41. static void uart2_var_init(void)
    
42. {
    
43.   uart2_dev.recv = uart2_queue_recv;
    
44.   uart2_dev.send = uart2_queue_send;
    
45. 
    ! O7 T1 M, B6 N! V
46.   UartQueueInit(&uart2_dev.recv);
    / z1 V, t& Y. S9 G( A
47.   UartQueueInit(&uart2_dev.send);
    $ q$ ?7 e4 ?) s2 f4 q
48. }
    
49. 
    . J/ D9 U) ?0 L
50. static void uart2_gpio_init(void)
      @) u- \9 @: k8 z5 f4 c0 L
51. {
    & z* R1 ?! K2 a+ @, N8 n% ?
52.   UART2_RX_CONFIG();
    : ?1 ?% [, v" N+ `/ [' j; V' H  a! R
53.   UART2_TX_CONFIG();
    
54. }
    
55. 
    * H: s8 @5 j! c, k3 Q
56. static void uart2_mode_init(uint32_t bound)
    ( u7 ^$ s' B6 y
57. {
    
58.   UART2_CLK_ENABLE();
    
59. 
    : x  V, y& ~, S  g. L' |% U
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    
61.   uart2_dev.handle.Init.BaudRate = bound;
    " t  t3 j+ ~& {
62.   uart2_dev.handle.Init.WordLength = UART_WORDLENGTH_8B;
    ; V, F* w* ]  i+ S
63.   uart2_dev.handle.Init.StopBits = UART_STOPBITS_1;
    0 x6 L( ^2 X* [8 ?" F
64.   uart2_dev.handle.Init.Parity = UART_PARITY_NONE;
    
65.   uart2_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
66.   uart2_dev.handle.Init.Mode = UART_MODE_TX_RX;
    
67.   HAL_UART_Init(&uart2_dev.handle);
    
68. }
    
69. 
    , B: D6 ~0 L' p  Q' A+ E( M: u
70. static void uart2_nvic_init(void)
    , }: I( c0 o5 ], `7 F3 D7 z4 G
71. {
    
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    0 e: Z: e  o* `% j
74. 
    ) t2 Q! p9 E6 J" Z. U: w" V& K" W
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    1 R' j) N: o- f% ?7 y1 L8 H% F; J& D
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
     A( s% n% @1 |+ ]3 z, U5 z" t
2. // 定义一个串口的列表
   
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   2 |& {) y' X( H" G+ q6 H5 v" a9 c
4. typedef struct
   7 R, H& }) r5 E
5. {
   
6.   uint8_t channel;
   
7.   uart_dev_t *dev;
   + z* A" U6 r) M' C
8.   void (* var_init_cb)(void);
   9 e( Q/ a& @& \
9.   void (* gpio_init_cb)(void);
   " I7 J3 _6 A# a9 q$ M
10.   void (* mode_init_cb)(uint32_t bound);
    
11.   void (* nvic_init_cb)(void);
    4 h5 e! V( I7 a" J! @5 d
12. } uart_config_t;
    
13. 
    
14. static const uart_config_t uart_configs[] =
    * j7 \! h) y8 s# d: }( t
15. {
    
16.   {UART_CHANNEL_1, &uart1_dev, uart1_var_init, uart1_gpio_init, uart1_mode_init, uart1_nvic_init},
    
17.   {UART_CHANNEL_2, &uart2_dev, uart2_var_init, uart2_gpio_init, uart2_mode_init, uart2_nvic_init},
    / |" D! I0 W$ x& Z6 V3 Z& p7 B
18. };
    & x& ?7 v% h  e
19. 
    * t" m( g5 v6 c9 ^. {
20. static uart_dev_t *uart_dev_get(uint8_t channel)
    
21. {
    , Q9 N! m8 D( l. P2 }
22.   uint8_t i;
    
23. 
    
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    ! O! w9 S- x- M/ C3 u3 Y
25.   {
    
26.     if(uart_configs<i>.channel == channel)
    * M% {! [# U9 r' |$ T' ?
27.   </i>  {
    , Q: P2 B# G! k" e$ f
28.       return uart_configs.dev;
    6 l% r/ N7 G; j; \$ l* H) i# ^, N
29.     }
    % K5 r3 b8 ~: u8 t- w2 o& b
30.   }
    
31. 
    
32.   return 0;
    " ?/ ~3 z( O' n0 t2 L
33. }
    
34. 
    
35. static void uart_var_init(uint8_t channel)
    
36. {
    3 p8 f4 Y3 L8 |3 X7 S2 w
37.   uint8_t i;
    2 O, w1 R2 @: x5 G
38. 
    3 D. `& @4 A/ ~
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
40.   {
    
41.     if(uart_configs.channel == channel)
    2 L0 P6 U* b3 H: F7 D
42.     {
    - f* F, H0 v# F4 x
43.       uart_configs.var_init_cb();
    
44.       break;
    
45.     }
    
46.   }
    
47. }
    - N0 `6 W; i( W3 f  ^
48. 
    9 D9 p" r# C7 U+ E- I* M
49. static void uart_gpio_init(uint8_t channel)
    2 Z" }; y3 P; L
50. {
    * j  L  @5 B6 B/ h( s- k
51.   uint8_t i;
    . a! q6 l0 @7 l9 G" P  w
52. 
    % E, j% _1 H8 d
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
54.   {
    2 t9 @* |/ J! n' F
55.     if(uart_configs.channel == channel)
    
56.     {
    
57.       uart_configs.gpio_init_cb();
    ( A7 c8 [5 T, f* g6 C
58.       break;
    . {+ E3 c/ b2 B8 T5 ^& p; w
59.     }
    
60.   }
    ( Z7 A, ^; v- `
61. }
    
62. 
    & Q: p( a6 |7 ]" V# `
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    
64. {
    . P& x8 N; e/ [0 H+ l$ L
65.   uint8_t i;
    & y4 Q' q1 U$ O2 G0 [5 ?
66. 
    
67.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    & C( i. u* m+ H) @1 u( H" v; Q% ^
68.   {
    
69.     if(uart_configs.channel == channel)
    
70.     {
    
71.       uart_configs.mode_init_cb(bound);
    5 g& S; }% ^, f8 d6 k" i
72.       break;
    # _  k. Z4 x! W$ B/ [# b+ ?3 U
73.     }
    " b! j( a. ^: W# }! h; ]
74.   }
    
75. }
      G+ E9 f1 d7 T" H
76. 
    
77. static void uart_nvic_init(uint8_t channel)
      p/ w4 c9 ]( }% C
78. {
    & K- ?3 Q+ Z- K. y- V9 Q( i
79.   uint8_t i;
      ?' C8 d% `& c9 r
80. 
    
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
82.   {
    2 o6 d* e0 _' R1 A( [( Z
83.     if(uart_configs.channel == channel)
    
84.     {
    
85.       uart_configs.nvic_init_cb();
      Q! H$ _- C% J* j
86.       break;
    
87.     }
    8 H" R! o5 x# T4 B
88.   }
    * y  X% U3 a) O, n
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   
2. // 初始化函数，同步发送 异步发送 接收处理
   
3. void UartInit(uint8_t channel, uint32_t bound)
   - ^' M  a7 h: U6 _3 o" S
4. {
   
5.   uart_var_init(channel);
   
6.   uart_gpio_init(channel);
   
7.   uart_mode_init(channel, bound);
   6 s7 Y. n) `1 {3 S7 ^2 O
8.   uart_nvic_init(channel);
   % O# E& H+ o8 k4 G: r0 g& k
9. }
   
10. 
    
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
    % ?: q# B5 b1 P+ t. R
12. {
    . G: V9 p# O- p' a9 ?
13.   uart_dev_t *dev = uart_dev_get(channel);
    # a$ M& p7 k$ _( ^1 }! k8 e
14. 
    
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    % o6 Z7 @& {( x! `' D
16. }
    % Y' j$ U) P4 J) }" _
17. 
    1 F) Z# c& O" d5 b% m9 E7 ]- {
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    
19. {
    . A( s* d- [! |1 m5 V/ u+ T
20.   uint16_t i;
    
21.   uart_dev_t *dev = uart_dev_get(channel);
    " w( l- g+ o9 t3 A5 |# Y
22. 
    
23.   if(0 == dev)
    
24.   {
    
25.     return;
    
26.   }
    / g  R+ \8 Z$ ^
27. 
    
28.   for(i = 0; i < length; ++i)
    
29.   {
    * D! R1 w  u# @& |; z
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    
31.   }
    
32. }
    6 f1 g/ Y9 }: Y
33. 
    . s: t  m3 g4 u. }
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    , z( J+ ~' _7 l/ ?. b
35. {
    
36.   uart_dev_t *dev = uart_dev_get(channel);
    3 X# s, g7 r3 I* k6 P5 K
37. 
    4 y/ I, [5 x& o! C! T5 o# }: f
38.   if(0 == dev)
    $ u; K- a9 B% Y0 _) L2 v8 w
39.   {
    
40.     return 0;
    
41.   }
    
42. 
    
43.   return UartQueuePop(&dev->send, c);
    
44. }
    
45. 
    
46. uint8_t UartRecv(uint8_t channel, uint8_t *c)
    ; C2 V3 a2 T8 q- X% u
47. {
    ; T1 Y  f. j( j3 r5 a0 E( \/ `
48.   uart_dev_t *dev = uart_dev_get(channel);
    / Q  g7 O' k' _
49. 
    
50.   return UartQueuePop(&dev->recv, c);
    . w9 @: R" g, c3 V9 B- M9 e7 D
51. }
    ; K( l7 Z$ E" c4 o
52. // 这里我没有使用串口的回调函数。
    $ E8 v3 a& A! [+ \% ~% _+ F
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    
54. void UART1_IRQ_FUNC(void)
    ( G( @' [; @4 f' i0 w! a
55. {
    1 Q0 _) G+ {' }& B  \
56.   if(__HAL_UART_GET_IT(&uart1_dev.handle, UART_IT_RXNE) != RESET)
    
57.   {
    
58.     HAL_UART_Receive(&uart1_dev.handle, (uint8_t *)&uart1_dev.ret, 1, 1000);
    
59.     UartQueuePush(&uart1_dev.recv, uart1_dev.ret);
    
60.   }
    + F$ R) V" a. s
61. 
    8 R+ V* ]# [4 k6 Q3 i! z7 o# Y
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    
63. }
    
64. 
    
65. void UART2_IRQ_FUNC(void)
    
66. {
    ; s! A4 j9 ]$ _3 x
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    , {; x9 |" _1 ~; t3 a" X& L. x
68.   {
    8 u& W" _& j' Q" A' s0 J$ g0 b
69.     HAL_UART_Receive(&uart2_dev.handle, (uint8_t *)&uart2_dev.ret, 1, 1000);
    
70.     UartQueuePush(&uart2_dev.recv, uart2_dev.ret);
    ' e, U8 z/ q9 X2 V8 @
71.   }
    5 s# S8 A% G% Q4 j3 U! m6 ?) M+ k
72. 
    6 e& `7 y& {. X7 y! c& R. F
73.   HAL_UART_IRQHandler(&uart2_dev.handle);
    " C; J* J# ]3 v/ i$ w
74. }</span></span>

复制代码

/ l. M: V) ^, e! x9 J7 D' z到这里，串口的初始化，发送，接收的接口就封装好了。

裸机：裸机就在while(1)中调用UartRecv扫描数据；
2 p: o4 i4 A8 R2 q4 l
系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）

串口队列可参考：串口队列

. E4 L1 r8 }! {9 _: X5 Z

$ @( a8 q/ ?8 T+ j% A# N% o

# W) C& O$ S2 \# @* W' W# Q