一、串口初始化过程
8 u% k0 Y# D! L5 a2 L2 l  O1、时钟使能；
. ?, T2 m' k- i. c
9 y0 @$ g# _/ O( m2、GPIO初始化；
, S  ~4 h2 i/ ]2 R- _
3、串口波特率设置；

4、串口控制；

5、数据发送与接收
; M- i; r8 V( Z, _; y: t
6 |/ ^9 w/ q6 G2 q7 \' W  s( D
二、几个重要的串口函数

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); // 串口初始化
   
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); // 串口接收
   
6. 
   
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   8 Y# {, j8 H& M& g
8. 
   ; B0 h* L3 L6 k5 T4 ^, o; N
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
     S* q* k, ~4 F6 v
10. 
    & `2 D. ?  h; \0 Y
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

# s. Q$ N7 D; Z( |# w8 h1 [三、几个重要的结构
2 t; M! h# {6 \/ B

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   7 c, r; l0 O/ v
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   9 u" W9 H. j) l: t* b% e* F7 K# k) ^
3. typedef struct
   2 K; j+ a! y. |# V/ L( G! }
4. {
   % m  f. b$ `/ ?
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   " y5 B+ c2 e7 E% H( N( K" K" W" O
6. 
   1 y! M3 @5 F+ D2 [- B4 T
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   
8. 
   - [  [3 z3 ^( }5 `! b6 }
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   ' t$ S6 D/ O" [  \5 a
10. 
    + P, g! [- c0 c) R* }2 N4 M
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
    " }  X- v, w; L- y) Z& }
12. 
    
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
      P/ _! N* ^8 }
14. 
    
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    
16. 
    3 B' x1 q- E6 \' {" I0 `: j% k+ }2 S$ E
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    # l, R# F3 a' u: R1 M
18. 
    2 g4 F& B, ]6 H9 m8 f2 |- M
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    
20. 
    
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    " |. K$ ^0 k9 Y' s* O6 |. z# _
22. 
    4 K; m5 I2 u5 U7 \2 y
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    
24. 
    
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    ' o! |7 ]5 p- L( m2 o
26. 
    9 g, K0 k) Y) [+ o" \
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
28. 
    
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    . d$ @' y: E( e* t/ Z
30. 
    2 E! A: V% k/ v4 R. Y7 Q: Z
31.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    
32.                                                   and also related to Tx operations.
    9 C3 M+ {9 o; {3 g" ]: w6 \
33.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
34. 
      H& t6 x& j- q3 ?& m& u5 m+ Q) D
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                    */
    4 H7 ]# g" ]: b% v  U
39. 
    
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   
2. typedef struct
   ! v9 A+ I5 X" ^7 ]  \9 U
3. {
   * V! n* E8 ^; \9 E$ \6 m
4.   __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
   / D6 V6 N: i* c# j8 Q+ f' f
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.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */                                               
   
8.   __IO uint32_t GTPR;   /*!< USART Guard time and prescaler register,  Address offset: 0x10 */
   / J, q2 R" P) t, i  M
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* h: `3 ^: A" n1 v/ V- J" }8 a
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 */
    3 T' y. h/ x, q/ |
13.   __IO uint32_t RDR;    /*!< USART Receive Data register,              Address offset: 0x24 */
    
14.   __IO uint32_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    
15. } USART_TypeDef;

复制代码

1. // 设置串口的各个参数 波特率 字长 停止位 奇偶校验 收发模式 硬件流 过采样
   
2. // 字长：8位/9位
   
3. // 停止位：1位/2位
   
4. typedef struct
   5 z  H" s0 D% r7 I
5. {
   " ^. N1 N. w- D3 z9 d( |7 r; \" m
6.   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
   & O2 h# j; v' q) ]8 X/ ?+ a
7.                                            The baud rate register is computed using the following formula:
   
8.                                            - If oversampling is 16 or in LIN mode,
   
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
     K7 f2 s9 {6 q+ R7 N
10.                                            - If oversampling is 8,
    : R5 E0 w1 N( _$ F2 p7 X  x
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    
12.                                               Baud Rate Register[3] =  0
    4 {+ n% j# l9 e/ V: f5 V
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
    : P$ w) |# g$ V8 d* [
14. 
    / O8 {* `  D- f0 H
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
      s. y! g8 Y9 ^* T
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    , \7 |# a5 Q8 _6 I) d. C
17. 
    
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    
19.                                            This parameter can be a value of @ref UART_Stop_Bits */
    5 Z2 }" E5 C& s6 A' e: q* G" ^3 f
20. 
    
21.   uint32_t Parity;                    /*!< Specifies the parity mode.
    2 a& F8 }8 L) L
22.                                            This parameter can be a value of @ref UART_Parity
    
23.                                            @note When parity is enabled, the computed parity is inserted
    
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). */
    ( E' q, ~- ]& r( _2 E' @
27. 
    
28.   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
    
29.                                            This parameter can be a value of @ref UART_Mode */
    
30. 
    
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    
32.                                            or disabled.
    ' d1 `& M  y3 @3 W- h. t6 \
33.                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
      Z5 @% G" {6 F( _, H2 Q5 M
34. 
    
35.   uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8).
    $ g1 [* b2 y  q! i
36.                                            This parameter can be a value of @ref UART_Over_Sampling */
    & W( o) \5 {  R
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
    ! Q. p- q8 X# f1 `- `: f. w" S# b
40.                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling */
    - m6 l. B; [" u
41. }UART_InitTypeDef;

复制代码

四、基本接口设计
: T* n5 Y; T% e& T6 q( c8 V我们使用中断接收，普通发送。中断接收到的数据放入队列中，在外部可配置每路串口的功能。

: U$ q" }4 T7 F+ ?9 b5 L

1. // 抽象出一个串口设备结构体
   + ]! h1 E+ h) s; c+ c* u6 W3 _- ?
2. typedef struct
   # Q2 V9 g# J2 M0 t6 G9 Q: T
3. {
   
4.   UART_HandleTypeDef handle; // 串口句柄
   
5.   uart_queue_t recv;         // 接收队列
   
6.   uart_queue_t send;         // 发送队列
   
7.   uint8_t ret;               // 接收的值
   
8. } uart_dev_t;
     o" V# Z% D6 q
9. 
   $ c) x+ N9 l" \4 |
10. static uart_dev_t uart1_dev;
    ( }/ o" U" W  x3 t2 E: f$ m
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
   
2. typedef enum
   7 Y* K: L! Q1 d8 y% X0 D6 a/ y& K
3. {
   
4.   UART_CHANNEL_NONE,
   2 h9 {5 A+ C, t4 |1 t+ X
5.   UART_CHANNEL_1,
   - r4 h2 N* b: [
6.   UART_CHANNEL_2,
   
7.   UART_CHANNEL_NUM
   
8. } uart_channel_t;
   ( b& Y# f2 |: z" T$ Z
9. 
   ' @8 O$ T! I1 c; M
10. // 宏定义串口的基本信息 之所以这样写，方便移植修改
    
11. #define UART1_CHANNEL             USART1
    8 {2 y- ?& B! J4 R1 g( i) C" S) |
12. #define UART1_PREEMPT_PRIO        UART1_PRIORITY
    8 r6 _; Q- x' x8 v& b
13. #define UART1_IRQ                 USART1_IRQn
    5 t/ G' w4 l7 r1 b. ~) w
14. #define UART1_IRQ_FUNC            USART1_IRQHandler
    $ b7 l  q: R- u. }4 G7 j* ]7 u2 |
15. #define UART1_CLK_ENABLE()        __HAL_RCC_USART1_CLK_ENABLE()
    
16. #define UART1_TX_PORT             GPIOA
    # g; _5 G& M0 ?# ^/ {
17. #define UART1_TX_PIN              GPIO_PIN_10
    6 c9 J' T7 U0 `6 f# N
18. #define UART1_TX_AF               GPIO_AF7_USART1
    7 n$ Q' \' I1 A6 k2 p8 b/ _+ B. z
19. #define UART1_TX_CONFIG()         GPIOConfigExt(UART1_TX_PORT, UART1_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_TX_AF)
    - O; v4 w/ Q# H+ E- K6 g8 [
20. #define UART1_RX_PORT             GPIOA
    + \( b- d; g$ w5 D: F" y/ w
21. #define UART1_RX_PIN              GPIO_PIN_9
    
22. #define UART1_RX_AF               GPIO_AF7_USART1
    4 X5 r0 [' A3 d- ?9 s
23. #define UART1_RX_CONFIG()         GPIOConfigExt(UART1_RX_PORT, UART1_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_RX_AF)
    
24. 
    ( X0 q+ j/ Y, a4 Y
25. #define UART2_CHANNEL             USART2
    7 ~$ @- S( Z" w) E2 z# l. R6 o+ _
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    
27. #define UART2_IRQ                 USART2_IRQn
    
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    / }" t. d  g/ l( p- g6 D% X
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    
30. #define UART2_TX_PORT             GPIOA
    
31. #define UART2_TX_PIN              GPIO_PIN_2
    4 ^' [7 a1 B3 ?. l& ?2 V: p
32. #define UART2_TX_AF               GPIO_AF7_USART2
    3 S8 C: ~8 ?& H) s5 m- A/ m. X
33. #define UART2_TX_CONFIG()         GPIOConfigExt(UART2_TX_PORT, UART2_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_TX_AF)
    
34. #define UART2_RX_PORT             GPIOA
    
35. #define UART2_RX_PIN              GPIO_PIN_3
    
36. #define UART2_RX_AF               GPIO_AF7_USART2
    # c# a9 M% k% z+ q1 t4 k5 l/ Z
37. #define UART2_RX_CONFIG()         GPIOConfigExt(UART2_RX_PORT, UART2_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_RX_AF)

复制代码

1. // 串口的基本操作
   * `+ s& ?3 g! ]! l% a, E# d
2. // 串口1
   
3. static void uart1_var_init(void)
   4 q7 p7 u- Z5 l$ s
4. {
   
5.   uart1_dev.recv = uart1_queue_recv;
   ; p2 U6 i+ W: v9 [6 w
6.   uart1_dev.send = uart1_queue_send;
   
7. 
   
8.   UartQueueInit(&uart1_dev.recv);
   
9.   UartQueueInit(&uart1_dev.send);
   1 Y5 l; d4 ]/ H+ r
10. }
    
11. 
    # @) m: u$ Y$ H4 \8 |9 E  t! a
12. static void uart1_gpio_init(void)
    / u8 H' }, [; j3 C
13. {
    0 m1 U) p$ Q) {1 [5 |
14.   UART1_RX_CONFIG();
    ! R) R7 c0 U9 n; r
15.   UART1_TX_CONFIG();
    2 B4 b) a( s7 l) b
16. }
    
17. 
    6 n# P  K& Y% x% U% \2 Q
18. static void uart1_mode_init(uint32_t bound)
    0 _" M+ Q! F) ^3 Z  z: i
19. {
    
20.   UART1_CLK_ENABLE();
    
21. 
    
22.   uart1_dev.handle.Instance = UART1_CHANNEL;
    
23.   uart1_dev.handle.Init.BaudRate = bound;                // 波特率
    + Z) f( g7 o% h0 ?9 w& \7 I
24.   uart1_dev.handle.Init.WordLength = UART_WORDLENGTH_8B; // 字长为8位数据格式
    
25.   uart1_dev.handle.Init.StopBits = UART_STOPBITS_1;      // 一个停止位
    9 R( J. ~) R- ?
26.   uart1_dev.handle.Init.Parity = UART_PARITY_NONE;       // 无奇偶校验位
    2 z& w3 ?) T6 U9 O/ k: X$ `/ O
27.   uart1_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 无硬件流控
    ; F# }9 J+ G- f# N+ e
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    6 n) R) s, e0 u: T/ z) A6 a
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    ! j' b3 a& O2 k  d2 n. ?7 l4 z
30. }
    
31. 
    5 k7 `7 R: S6 Q+ u
32. static void uart1_nvic_init(void)
    
33. {
    
34.   HAL_NVIC_SetPriority(UART1_IRQ, UART1_PREEMPT_PRIO, 3);
    # [; c/ N$ B6 [" a; G7 G- V9 K
35.   HAL_NVIC_EnableIRQ(UART1_IRQ);
    
36. 
    
37.   __HAL_UART_ENABLE_IT(&uart1_dev.handle, UART_IT_RXNE);
    
38. }
    . F6 r% `; \. H; H* h' t8 ]
39. 
    
40. // 串口2
    
41. static void uart2_var_init(void)
    % H( O( m# {+ K( `8 L7 S; L% ?+ c
42. {
    
43.   uart2_dev.recv = uart2_queue_recv;
    
44.   uart2_dev.send = uart2_queue_send;
    " k: q$ e) E6 M) A7 y' K0 j8 j% K
45. 
    1 I# u3 m! C! t0 D
46.   UartQueueInit(&uart2_dev.recv);
    
47.   UartQueueInit(&uart2_dev.send);
    
48. }
    
49. 
    
50. static void uart2_gpio_init(void)
    ; d2 Y" B, X' l, k. H; P( c
51. {
    0 b. b8 {3 F& o/ O8 T# ~6 I0 P
52.   UART2_RX_CONFIG();
    6 V! q# V$ t2 s& {/ v9 j
53.   UART2_TX_CONFIG();
    6 s" J4 R$ P8 T0 R7 w
54. }
    : f8 d  Q/ k0 U  j4 z
55. 
    
56. static void uart2_mode_init(uint32_t bound)
    " }( s) \, d1 m( S3 h
57. {
    5 S1 `$ r5 o6 m# g9 U/ P% X' A
58.   UART2_CLK_ENABLE();
    : X1 `, p9 o' ~! r# A& P
59. 
    5 b% ~; g+ Y/ L9 r/ Y) M0 x' B
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    
61.   uart2_dev.handle.Init.BaudRate = bound;
    ! n" R& g7 q5 u
62.   uart2_dev.handle.Init.WordLength = UART_WORDLENGTH_8B;
    
63.   uart2_dev.handle.Init.StopBits = UART_STOPBITS_1;
    
64.   uart2_dev.handle.Init.Parity = UART_PARITY_NONE;
    ( J% s. E% G! L5 k* m, I
65.   uart2_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    . w  F9 O4 N" \
66.   uart2_dev.handle.Init.Mode = UART_MODE_TX_RX;
    
67.   HAL_UART_Init(&uart2_dev.handle);
    
68. }
    
69. 
    ' u( g, E/ ?" F; D# v0 ?2 n
70. static void uart2_nvic_init(void)
    
71. {
    
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    $ W' |/ E+ b: E
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    
74. 
    
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
   5 w- g  Q  F0 L7 Q* g
2. // 定义一个串口的列表
   9 \/ W; G7 B! `/ w$ U% c- V
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   
4. typedef struct
   
5. {
   ( N5 J( K1 [; o, |* a5 P
6.   uint8_t channel;
   
7.   uart_dev_t *dev;
   
8.   void (* var_init_cb)(void);
   ) m1 [0 m0 a3 L# b2 u4 n' F6 a
9.   void (* gpio_init_cb)(void);
   
10.   void (* mode_init_cb)(uint32_t bound);
    & |9 d0 f% {5 Z  n8 _: @* c% O
11.   void (* nvic_init_cb)(void);
    / R% E, s9 H* P" P
12. } uart_config_t;
    # w# ^( e( D3 f! k$ N& Z' O" k
13. 
    
14. static const uart_config_t uart_configs[] =
    
15. {
    ; c8 R9 a) G2 g" R
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},
    
18. };
    
19. 
    
20. static uart_dev_t *uart_dev_get(uint8_t channel)
    
21. {
    
22.   uint8_t i;
    & B/ I' I1 R1 W( l% d  T
23. 
    & d. s0 M3 L3 k3 D2 o* i; @% A
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    8 v1 A/ u, N3 l9 G" W: w$ ^- m% Y
25.   {
    4 v4 g6 e8 w2 o
26.     if(uart_configs<i>.channel == channel)
    
27.   </i>  {
    + [8 I. C4 Q: @7 ?$ i
28.       return uart_configs.dev;
    
29.     }
    
30.   }
    ( `6 [, L$ |" m  ~+ h: C4 \# `7 @* C
31. 
    
32.   return 0;
    
33. }
    
34. 
    3 K( R+ X. m  s: R8 Y
35. static void uart_var_init(uint8_t channel)
    ! j) u/ g& f( r0 B
36. {
    ) j7 t2 L2 O9 ~* S# y; l5 d
37.   uint8_t i;
    - Q: R) s9 c/ `
38. 
    ) o7 d( }0 j' q* T
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    6 [( j4 d! x6 j* z( e; S6 \
40.   {
    
41.     if(uart_configs.channel == channel)
    8 x5 _- x! C0 T' O
42.     {
    
43.       uart_configs.var_init_cb();
    
44.       break;
    
45.     }
    $ Y2 Q$ u$ q6 e
46.   }
    - H; A  c( e' r7 S# d1 z
47. }
    * W4 I2 S0 q  J5 I
48. 
    # d3 R* ^, A! w# @" ]& m; W2 K/ _
49. static void uart_gpio_init(uint8_t channel)
    7 r* L7 `4 V) g
50. {
    
51.   uint8_t i;
    : E% z/ b3 [& C8 f7 e' G2 \+ e
52. 
    
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
54.   {
    : U/ ~) H) m4 ~: w# v7 _) r
55.     if(uart_configs.channel == channel)
    
56.     {
    
57.       uart_configs.gpio_init_cb();
    + p4 o3 i# x2 Y% j
58.       break;
    - S7 p# G# H' p5 ?1 M
59.     }
    2 ]2 v& e; Q# g5 Q
60.   }
    
61. }
    
62. 
    
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    
64. {
    
65.   uint8_t i;
    : U  p/ E9 v. U, N+ d7 Q
66. 
    , u! N$ L0 \. _7 J, r
67.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
68.   {
    . ~6 h" B8 W$ A1 v( O
69.     if(uart_configs.channel == channel)
    : J3 v: L  B: }6 W: J2 m4 q9 W
70.     {
    
71.       uart_configs.mode_init_cb(bound);
    , n; W; D+ G& }3 @8 o! J5 }
72.       break;
    4 {! i' h6 R& W# s5 g9 C4 ~7 ^5 ]* ]% m
73.     }
    + ^7 Q: X) N: b- L
74.   }
    
75. }
    
76. 
    2 y# }% Y7 g% ^- I8 @! e
77. static void uart_nvic_init(uint8_t channel)
    , U, _# T. m/ K4 E
78. {
    & ~9 ?; N* u" R2 y! C6 o* L; d
79.   uint8_t i;
    3 g9 g. f" s7 G% i0 m+ {
80. 
    - D. A! e4 n" u$ F/ Q. c
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    " t. `2 p4 A0 Q. P
82.   {
    * d6 `7 ]; f$ V3 E  R
83.     if(uart_configs.channel == channel)
    
84.     {
    
85.       uart_configs.nvic_init_cb();
    
86.       break;
    3 L! C6 a! E& N& n) T: f
87.     }
    6 g4 W2 I, n' d! L( h
88.   }
    . g# u4 ]7 s5 o' ^4 k8 v- J  J# c
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   / t4 H6 |) R7 B: N) [  s
2. // 初始化函数，同步发送 异步发送 接收处理
   1 x6 y+ g* p- u7 }
3. void UartInit(uint8_t channel, uint32_t bound)
   1 r# D. v  ?* T
4. {
   ) b2 `; P2 {  y0 ?+ p$ x
5.   uart_var_init(channel);
   
6.   uart_gpio_init(channel);
   
7.   uart_mode_init(channel, bound);
   
8.   uart_nvic_init(channel);
   
9. }
   
10. 
    
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
    - ~: u) o* A- D1 g; Q. \' C
12. {
    : e% }8 E0 t7 [+ B/ w3 l
13.   uart_dev_t *dev = uart_dev_get(channel);
    
14. 
    
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    # }6 c8 g/ V  H" t6 {# s- A
16. }
    " C2 A8 R: A! _
17. 
    
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    ; e. c( e) ]9 p# n
19. {
    
20.   uint16_t i;
    / }; Q+ Z2 h) g3 y, l3 Y, d- |
21.   uart_dev_t *dev = uart_dev_get(channel);
    
22. 
    
23.   if(0 == dev)
    
24.   {
    ! ^2 u& p8 \8 J! S% H5 }) }5 J
25.     return;
    
26.   }
    " M( v; Y1 R/ O' G& U$ T2 X
27. 
    : D2 q6 F6 e. |7 W" m. Y
28.   for(i = 0; i < length; ++i)
    , P2 \" s# [/ `
29.   {
    # |8 ~2 u  \; l0 r* F" b7 x
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    3 u# t. ?4 V# Q+ T
31.   }
    
32. }
    
33. 
    0 S' C. d- X& G) ~" C  i( I
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    
35. {
    $ j4 {) X1 a+ [3 \4 h9 f
36.   uart_dev_t *dev = uart_dev_get(channel);
    
37. 
    * r# w& l( h; k" }6 S) R- ^
38.   if(0 == dev)
    ) K: L' E& B) q* p& V( _5 d
39.   {
    
40.     return 0;
    1 P! x. e3 ~5 {3 P$ v
41.   }
    
42. 
    
43.   return UartQueuePop(&dev->send, c);
    
44. }
    3 n! j# T( F* K5 a. S+ @
45. 
    1 d! h+ B7 h& N: l  i( T0 \, R
46. uint8_t UartRecv(uint8_t channel, uint8_t *c)
    1 i1 r- f" O8 Q( m' J  f
47. {
    
48.   uart_dev_t *dev = uart_dev_get(channel);
    
49. 
    
50.   return UartQueuePop(&dev->recv, c);
    
51. }
    7 F% }3 |0 b3 ?( @8 m
52. // 这里我没有使用串口的回调函数。
    ! P7 v2 }. T8 P3 h; f
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    
54. void UART1_IRQ_FUNC(void)
    
55. {
    
56.   if(__HAL_UART_GET_IT(&uart1_dev.handle, UART_IT_RXNE) != RESET)
    5 t# q- p) z  z% d& |; W8 F
57.   {
    ! l5 }+ o6 r2 T6 ~4 W. r
58.     HAL_UART_Receive(&uart1_dev.handle, (uint8_t *)&uart1_dev.ret, 1, 1000);
    
59.     UartQueuePush(&uart1_dev.recv, uart1_dev.ret);
    
60.   }
    
61. 
    
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    ) p1 M. P0 D& L- |3 g
63. }
    
64. 
    
65. void UART2_IRQ_FUNC(void)
    4 ]7 j+ A( H6 x" E9 ^6 H6 G3 [/ z
66. {
    - o% f# `7 k# X$ C. }7 q) V' j
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    5 E1 e, J  T9 ~
68.   {
    
69.     HAL_UART_Receive(&uart2_dev.handle, (uint8_t *)&uart2_dev.ret, 1, 1000);
    ' R" N' X7 f1 v1 I
70.     UartQueuePush(&uart2_dev.recv, uart2_dev.ret);
    # b9 }7 x5 {1 {. K" w
71.   }
    
72. 
    
73.   HAL_UART_IRQHandler(&uart2_dev.handle);
    
74. }</span></span>

复制代码

$ s% ]- ~5 n6 r( n) O到这里，串口的初始化，发送，接收的接口就封装好了。

裸机：裸机就在while(1)中调用UartRecv扫描数据；
. b! F# J" F4 X% T" E: l
# Q0 N. e/ W7 P2 X0 q系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）
3 E. ?% I$ ^+ }
串口队列可参考：串口队列

7 {* w, _( M( ~* F- u
# t- X# `! F/ Z; i# B
" C! }* B& Q, w$ r
0 R5 z5 t# {$ h1 L
( L8 ?4 q3 e0 ~