一、串口初始化过程
1、时钟使能；

6 ?- @. R- k; N; O2、GPIO初始化；
8 G' o( c* V9 }/ p  n
+ N- |+ @/ Q, h& k/ X. `" A3、串口波特率设置；

: n, L5 Z6 {9 |. F4、串口控制；
0 j* G7 T6 t( Z1 F, g
4 I( d$ f5 H: B! `4 V$ ?5、数据发送与接收
) P# s) ]! Q. v4 A2 X' l
( r: T* Z# c4 p: a+ @
7 M/ I' W: ]* ^3 d二、几个重要的串口函数
) X0 m8 T5 ?- U$ z3 Q% P

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 N6 A( }0 k6 M1 A/ ?6 B1 f) ?
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   
8. 
   / V3 ?; r( Q# A$ T( ?& H
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
   
10. 
    
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

! v. q) @1 H' j  N; a. L三、几个重要的结构

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   7 _' K+ E5 Q4 [$ I% t% {
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   
3. typedef struct
   
4. {
   
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   . ?1 W3 [# f" b- y; W' a
6. 
   * B9 ~" {, v% k
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   
8. 
   
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   ' f$ E6 P( ]% _; {* U
10. 
    
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
    ' }: j  O% l2 r& R
12. 
    ! j' i+ ]# V" e
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    & M0 R5 [. ^# w% T
14. 
    
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    $ j8 g2 A8 E, P
16. 
    ) c6 [8 ~7 ]; t
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    
18. 
    
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    6 e0 S0 B4 N+ \6 t7 q2 o
20. 
    + L& F! H  S( e- C. N# s% _" h6 p
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    4 U. [1 G# s9 m( a1 F  ?6 k5 g6 w6 n
22. 
    9 `/ `( m2 _, a" Y, l1 z2 ^
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    + I$ S# F8 E! S, \+ m
24. 
    
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    
26. 
    
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
28. 
      t& d' n" x3 [8 |4 ^4 g7 X; P
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    
30. 
    ( ]7 V- K) P( I' s
31.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    ; T: K, p4 c/ B
32.                                                   and also related to Tx operations.
    : X* |) z* c3 P8 k' u
33.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
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                    */
    
39. 
    * Z! Y2 h% e" p1 K- i" P) ?
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   
2. typedef struct
   2 N2 N7 b" O: L
3. {
   
4.   __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
   
5.   __IO uint32_t CR2;    /*!< USART Control register 2,                 Address offset: 0x04 */
   : m7 ?0 g! `/ i
6.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   6 Q8 X9 L; v& p; P
7.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */                                               
   2 ]  A$ M1 [8 b, k! l2 u" d4 Y
8.   __IO uint32_t GTPR;   /*!< USART Guard time and prescaler register,  Address offset: 0x10 */
   ; h% `: S7 y, a  }, s& c- U
9.   __IO uint32_t RTOR;   /*!< USART Receiver Time Out register,         Address offset: 0x14 */  
   
10.   __IO uint32_t RQR;    /*!< USART Request register,                   Address offset: 0x18 */
    
11.   __IO uint32_t ISR;    /*!< USART Interrupt and status register,      Address offset: 0x1C */
    6 M- [+ b; Z& ?! z1 ]' c
12.   __IO uint32_t ICR;    /*!< USART Interrupt flag Clear register,      Address offset: 0x20 */
    ; Y$ f4 q0 x. i
13.   __IO uint32_t RDR;    /*!< USART Receive Data register,              Address offset: 0x24 */
    
14.   __IO uint32_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    ! k8 j0 K" p& w7 J* \0 w: I
15. } USART_TypeDef;

复制代码

1. // 设置串口的各个参数 波特率 字长 停止位 奇偶校验 收发模式 硬件流 过采样
   
2. // 字长：8位/9位
   3 R* R4 }$ e: ~' c
3. // 停止位：1位/2位
   0 J6 w+ m3 Q6 |0 O5 Q
4. typedef struct
   
5. {
   ( f- `+ N* x* ^( d  n0 }
6.   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
   
7.                                            The baud rate register is computed using the following formula:
   " u# O* h$ V1 k  c% H
8.                                            - If oversampling is 16 or in LIN mode,
   
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
   ; t9 Y, h: m( ~
10.                                            - If oversampling is 8,
    
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    0 u" \: A3 @4 p8 B# C
12.                                               Baud Rate Register[3] =  0
    
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
    
14. 
    5 x% g9 n1 O0 r
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
    9 F0 I5 p3 C3 l& d6 n
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    + e( Q0 W, ~. Z0 z& V2 o
17. 
    5 J1 t  q+ p) \
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    
19.                                            This parameter can be a value of @ref UART_Stop_Bits */
    
20. 
    ; K$ I8 c& e" F, a
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
    ) _7 K4 H! r5 k" R
24.                                                  at the MSB position of the transmitted data (9th bit when
    + k) K/ l4 b1 X& R
25.                                                  the word length is set to 9 data bits; 8th bit when the
    0 l4 m3 @" |3 F, `2 S5 u
26.                                                  word length is set to 8 data bits). */
    3 C4 u/ k& ]# _" i
27. 
    
28.   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
      C$ n4 v( A$ b% z: K/ i
29.                                            This parameter can be a value of @ref UART_Mode */
    " ?- ^# c. ]# J9 ?, y! V
30. 
    & V! \( r2 D6 w1 f) l* T3 Y
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    
32.                                            or disabled.
    / @- ~9 q. y+ k
33.                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
    1 N3 o9 f+ \3 A* r
34. 
    
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 */
    1 p2 a- y) k5 w
37. 
    
38.   uint32_t OneBitSampling;            /*!< Specifies whether a single sample or three samples' majority vote is selected.
    # s. W7 v) H7 n$ A  h* {
39.                                            Selecting the single sample method increases the receiver tolerance to clock
    
40.                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling */
    
41. }UART_InitTypeDef;

复制代码

四、基本接口设计
我们使用中断接收，普通发送。中断接收到的数据放入队列中，在外部可配置每路串口的功能。
( p6 @* |/ V) {. C/ U9 Y

1. // 抽象出一个串口设备结构体
   ) ?, \" ?" L/ ~
2. typedef struct
   
3. {
   . Z1 z/ |2 k: `; `
4.   UART_HandleTypeDef handle; // 串口句柄
   2 j; C' ]$ G" y; s% T
5.   uart_queue_t recv;         // 接收队列
   ' P+ i+ x6 U$ C2 d& |/ v
6.   uart_queue_t send;         // 发送队列
   7 n& m( k  H. i, q+ a8 A/ C
7.   uint8_t ret;               // 接收的值
   
8. } uart_dev_t;
   & O6 D# ~$ W2 C
9. 
   
10. static uart_dev_t uart1_dev;
    
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
   $ @+ W; F# f  n0 J0 S$ Y4 S( N
2. typedef enum
   / D* a; P/ ^6 C7 R
3. {
   8 |0 L$ a3 T# D6 c/ |
4.   UART_CHANNEL_NONE,
   3 b' ^) O) }3 t% C8 i
5.   UART_CHANNEL_1,
   
6.   UART_CHANNEL_2,
   0 b. K9 ^: s; D
7.   UART_CHANNEL_NUM
   # U2 m# ?0 f- V; P  Y
8. } uart_channel_t;
   
9. 
   : f+ O9 u: K. ~. i! k% K
10. // 宏定义串口的基本信息 之所以这样写，方便移植修改
    6 W$ z* i/ g/ t! x. J
11. #define UART1_CHANNEL             USART1
    
12. #define UART1_PREEMPT_PRIO        UART1_PRIORITY
    
13. #define UART1_IRQ                 USART1_IRQn
    6 d6 z7 z# G0 j4 r! l" q% t
14. #define UART1_IRQ_FUNC            USART1_IRQHandler
    / p6 a) E6 ?4 z* i$ P) W6 r
15. #define UART1_CLK_ENABLE()        __HAL_RCC_USART1_CLK_ENABLE()
    
16. #define UART1_TX_PORT             GPIOA
    9 h, h/ z! o/ P. ]
17. #define UART1_TX_PIN              GPIO_PIN_10
    
18. #define UART1_TX_AF               GPIO_AF7_USART1
      U( O  Q2 V; `4 Z
19. #define UART1_TX_CONFIG()         GPIOConfigExt(UART1_TX_PORT, UART1_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_TX_AF)
    7 t0 h' w/ G/ [( u( V* L
20. #define UART1_RX_PORT             GPIOA
      A5 t  e4 a6 i$ r
21. #define UART1_RX_PIN              GPIO_PIN_9
    
22. #define UART1_RX_AF               GPIO_AF7_USART1
    ' ^# Y- H! G% t2 V9 R2 i' c. r
23. #define UART1_RX_CONFIG()         GPIOConfigExt(UART1_RX_PORT, UART1_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_RX_AF)
    # T# `4 s4 @( @! B
24. 
    / P3 t( [1 [5 W$ o1 Y) q% l
25. #define UART2_CHANNEL             USART2
    8 ~1 M/ n1 G, F
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    3 i0 m- U# R3 k& ?
27. #define UART2_IRQ                 USART2_IRQn
    - O. m5 k1 g( p# _1 @: M" g/ r
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    
30. #define UART2_TX_PORT             GPIOA
    
31. #define UART2_TX_PIN              GPIO_PIN_2
    # f% n2 I/ b  M
32. #define UART2_TX_AF               GPIO_AF7_USART2
    
33. #define UART2_TX_CONFIG()         GPIOConfigExt(UART2_TX_PORT, UART2_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_TX_AF)
    , f# Z6 q. t, J4 T1 c1 ^# o
34. #define UART2_RX_PORT             GPIOA
    : a' X! o2 @+ K8 f5 E6 u  D
35. #define UART2_RX_PIN              GPIO_PIN_3
    3 [. g" ]) D: D4 `+ z
36. #define UART2_RX_AF               GPIO_AF7_USART2
    6 c! A0 ^: H- v2 z% x
37. #define UART2_RX_CONFIG()         GPIOConfigExt(UART2_RX_PORT, UART2_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_RX_AF)

复制代码

1. // 串口的基本操作
   $ C9 R. i& A0 F3 z
2. // 串口1
   
3. static void uart1_var_init(void)
   
4. {
   ( i$ ?6 O9 U; A3 O, ^1 e8 Z8 w
5.   uart1_dev.recv = uart1_queue_recv;
   ' p1 C1 U$ V4 _. a- F* v
6.   uart1_dev.send = uart1_queue_send;
   3 W  b  `/ |) i, i# A
7. 
   8 J9 K, @8 c6 Q; G7 O* p
8.   UartQueueInit(&uart1_dev.recv);
   
9.   UartQueueInit(&uart1_dev.send);
   
10. }
    
11. 
    ( N+ O, ]2 `( H& r: U: q
12. static void uart1_gpio_init(void)
    , h# M" H" G4 h5 i0 ]/ b* ]- m9 [
13. {
    ) t. W+ h9 k: d7 j, g4 K; }4 L# p
14.   UART1_RX_CONFIG();
    
15.   UART1_TX_CONFIG();
    
16. }
      A. {/ C" I2 d: ?; N
17. 
      y7 ^' C- \& j5 k
18. static void uart1_mode_init(uint32_t bound)
      l( A7 {3 y6 w7 Q4 ~! ~  Y2 s
19. {
    % w9 o& ^; e3 n& t( [3 |
20.   UART1_CLK_ENABLE();
    : Z# z5 k( }% @5 m: @+ [7 l
21. 
    
22.   uart1_dev.handle.Instance = UART1_CHANNEL;
    ) \0 Z) p/ F1 k- p2 H
23.   uart1_dev.handle.Init.BaudRate = bound;                // 波特率
    
24.   uart1_dev.handle.Init.WordLength = UART_WORDLENGTH_8B; // 字长为8位数据格式
    : D* x6 G" g  G0 Y2 k3 `, K
25.   uart1_dev.handle.Init.StopBits = UART_STOPBITS_1;      // 一个停止位
    
26.   uart1_dev.handle.Init.Parity = UART_PARITY_NONE;       // 无奇偶校验位
    
27.   uart1_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 无硬件流控
    % n( [& T+ t0 c) i" U" ?
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    8 ?1 \0 b$ Z8 `  i4 b
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    4 m) T, ^, l/ ]8 i& x
30. }
    
31. 
    
32. static void uart1_nvic_init(void)
    
33. {
    ; \$ R# }7 k5 j) o. D6 d
34.   HAL_NVIC_SetPriority(UART1_IRQ, UART1_PREEMPT_PRIO, 3);
    
35.   HAL_NVIC_EnableIRQ(UART1_IRQ);
    
36. 
    
37.   __HAL_UART_ENABLE_IT(&uart1_dev.handle, UART_IT_RXNE);
    
38. }
    
39. 
    
40. // 串口2
    * V& V5 p- r' V; G: R1 E
41. static void uart2_var_init(void)
    % g2 Y, r6 B7 v$ ]/ {) W7 L% u( E
42. {
    
43.   uart2_dev.recv = uart2_queue_recv;
    $ d. k9 @* G5 X- M
44.   uart2_dev.send = uart2_queue_send;
    
45. 
    
46.   UartQueueInit(&uart2_dev.recv);
    
47.   UartQueueInit(&uart2_dev.send);
    - a. U0 D8 F, {2 n
48. }
    % X8 d% S% h  \) o
49. 
    
50. static void uart2_gpio_init(void)
    
51. {
    2 y1 N2 ]! C0 X' H) ~/ H
52.   UART2_RX_CONFIG();
    
53.   UART2_TX_CONFIG();
    
54. }
    4 o" u* R0 A2 x2 ~; a# ^* P
55. 
    4 x# B7 Y0 F3 p0 e0 Q
56. static void uart2_mode_init(uint32_t bound)
    
57. {
    
58.   UART2_CLK_ENABLE();
    
59. 
    ; ~4 J, x! G% d, O' B0 O2 ?+ K
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    
61.   uart2_dev.handle.Init.BaudRate = bound;
    
62.   uart2_dev.handle.Init.WordLength = UART_WORDLENGTH_8B;
    ; ]- C  [& X5 {) z
63.   uart2_dev.handle.Init.StopBits = UART_STOPBITS_1;
    ) g9 _& `8 L1 P  [7 ^- \* w4 [
64.   uart2_dev.handle.Init.Parity = UART_PARITY_NONE;
    , r0 e" |* Z: d( p8 a
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);
    4 U: }6 Z& o2 h: t( L- L) @
68. }
    * a0 d+ q" s6 s
69. 
    0 s6 Y: K8 F1 F3 c: G
70. static void uart2_nvic_init(void)
    4 u- Y! a" r2 V/ S3 q1 Q, U$ \
71. {
    8 l+ b+ s! s3 k
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    ' B$ `! y  N  M: B
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    5 K0 G3 K4 }, y: ^
74. 
    
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
   
2. // 定义一个串口的列表
   7 W& t# T& L$ e3 o8 c1 }
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   * x6 }7 R3 `6 v$ G, f6 f0 A" c
4. typedef struct
   
5. {
   . J, n! ~# C( l9 p
6.   uint8_t channel;
   
7.   uart_dev_t *dev;
   3 R. X; d9 p/ L# L
8.   void (* var_init_cb)(void);
   7 g# j( A6 m( o# r( f/ p0 q2 b+ T
9.   void (* gpio_init_cb)(void);
   - o7 \4 m( x- [8 Q' Y
10.   void (* mode_init_cb)(uint32_t bound);
    
11.   void (* nvic_init_cb)(void);
    
12. } uart_config_t;
    6 {! I: D$ B- c' L# P0 k% x& Q
13. 
      u) Y6 A0 r1 U) @2 C' ~2 M& H& ~
14. static const uart_config_t uart_configs[] =
    
15. {
    , I& I1 A- K! \& n
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},
    " a  d& G: v! }) z' P/ G2 t
18. };
    
19. 
    * B3 o9 l# A( x: K
20. static uart_dev_t *uart_dev_get(uint8_t channel)
    
21. {
    . M( X' @+ q7 a2 L4 x4 s- ]9 T
22.   uint8_t i;
    
23. 
    9 V0 z$ r2 X: W0 G
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
25.   {
    
26.     if(uart_configs<i>.channel == channel)
    
27.   </i>  {
    
28.       return uart_configs.dev;
    
29.     }
    
30.   }
    / w+ ~& r' }4 E- \, L
31. 
    ) _+ {9 u8 Z) r0 K  ]+ i0 w
32.   return 0;
    $ ]4 N5 k" q/ i! L3 t
33. }
    
34. 
    , }: _! F' S5 G* S
35. static void uart_var_init(uint8_t channel)
    
36. {
    . k) _* b: O1 O8 ^: e
37.   uint8_t i;
    8 b; a3 ~! u" x; K! B9 |$ M! B
38. 
    
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    7 f, [4 c/ d& w4 [" J. F
40.   {
    & x  B$ F4 ?: g' r) y4 v2 n. A
41.     if(uart_configs.channel == channel)
    
42.     {
    
43.       uart_configs.var_init_cb();
    : N" s7 Y5 h  F; P
44.       break;
    
45.     }
    
46.   }
    2 w* z& {. k: ]8 O
47. }
    
48. 
    
49. static void uart_gpio_init(uint8_t channel)
    
50. {
    
51.   uint8_t i;
    
52. 
    
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    7 {7 T# P2 N1 G0 q8 j
54.   {
    
55.     if(uart_configs.channel == channel)
    - b) ^' r' A0 N" f* T
56.     {
    ! E) |; u2 ^0 \1 q
57.       uart_configs.gpio_init_cb();
    
58.       break;
    
59.     }
    . W& H& F$ J: c2 t& ^. y
60.   }
    - h. \$ c# P. N" v! j& r& J" Q
61. }
    / i  O4 |/ C% l; g* B
62. 
    & f& ~8 W) [. C% v( p/ W& q0 @, m
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    
64. {
    
65.   uint8_t i;
    
66. 
    1 z+ K, J! D  I+ ~5 Z; L9 W* V
67.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    * b2 R3 G* ]8 v4 b, {2 Q0 Q
68.   {
    # l, d3 s$ O/ D
69.     if(uart_configs.channel == channel)
    
70.     {
    # @& |0 ~9 k# k2 _
71.       uart_configs.mode_init_cb(bound);
    8 R3 a0 k; P) |8 P" H% G
72.       break;
    
73.     }
    0 H) U3 T: i' S4 p4 C/ H& ]
74.   }
    
75. }
    
76. 
    
77. static void uart_nvic_init(uint8_t channel)
    * @7 o# E0 C( u
78. {
    % z" ]  @% G6 P9 I) Q
79.   uint8_t i;
    
80. 
    
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
82.   {
    7 G5 `" X9 i! y& `
83.     if(uart_configs.channel == channel)
    9 b+ o2 s6 \) a. ]& w! O0 G4 \
84.     {
    
85.       uart_configs.nvic_init_cb();
    
86.       break;
    
87.     }
    8 W, t8 Y  }9 x4 k9 B( J
88.   }
    
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   5 x/ c5 M+ C4 z& s, M
2. // 初始化函数，同步发送 异步发送 接收处理
   
3. void UartInit(uint8_t channel, uint32_t bound)
   ' h4 j- O) x( y; J/ N4 K
4. {
   ) F* q' I- y1 F( u6 f& P) S! `0 H& l
5.   uart_var_init(channel);
   9 p! R+ ~* D. H1 E8 ^/ B
6.   uart_gpio_init(channel);
   ( l- y. x' }/ `0 ^! P: s
7.   uart_mode_init(channel, bound);
   ; c. q0 R5 `9 r% F. n4 G
8.   uart_nvic_init(channel);
   $ X; y5 I4 K2 D) Q+ C2 Y
9. }
   0 N. p2 G, q& i8 H" q# W
10. 
    + p; ^5 Z: h5 h5 k/ _4 ^
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
    4 E" R% T+ c) l* a6 e8 X: Z! s- J$ K
12. {
    
13.   uart_dev_t *dev = uart_dev_get(channel);
    7 l' l* x9 \$ r8 B. q
14. 
    
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    
16. }
    ; S: v8 l: W% z5 S; q, y7 {* z6 @6 j! N
17. 
    0 v7 t  M7 h0 m' D( e/ b0 h
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    
19. {
    3 t0 s+ _6 T3 T7 [: L6 _
20.   uint16_t i;
    
21.   uart_dev_t *dev = uart_dev_get(channel);
    
22. 
    
23.   if(0 == dev)
    
24.   {
    : `( d. P2 n7 M" m3 \
25.     return;
    
26.   }
    
27. 
    
28.   for(i = 0; i < length; ++i)
    
29.   {
    
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    3 v$ `! K7 B$ V7 o, ]2 [/ Q
31.   }
    9 p# K8 t3 o' v; n2 X  m
32. }
    . s* \* @* {; v5 N$ q, k1 F
33. 
    , B; ]7 a, y& q; D$ n0 F
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    
35. {
    # _! Z% n5 M4 A
36.   uart_dev_t *dev = uart_dev_get(channel);
    4 r9 g' ?  A; U& A+ l/ U& h, O5 o2 q
37. 
    
38.   if(0 == dev)
    $ X" x8 v& w0 O9 A# q7 O' L
39.   {
    7 H0 H" i3 m. Z/ Z& H
40.     return 0;
    0 k% a) C! s6 c$ A7 Y. c
41.   }
    + Z" c9 M  @( a0 j: O; F! }0 g
42. 
    ) Y2 ?, g/ Z' T& y' Y
43.   return UartQueuePop(&dev->send, c);
    
44. }
    $ H: p4 ^4 i5 a& ]8 x: O
45. 
    
46. uint8_t UartRecv(uint8_t channel, uint8_t *c)
    * L) U; X7 c8 o  h# P( Z- ^/ J* [
47. {
    
48.   uart_dev_t *dev = uart_dev_get(channel);
    
49. 
    
50.   return UartQueuePop(&dev->recv, c);
    # _0 H) X0 B1 y
51. }
    
52. // 这里我没有使用串口的回调函数。
    
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    ( i- v2 T. r0 u# u4 c  S/ R6 W% U
54. void UART1_IRQ_FUNC(void)
    & w% s; M, m- n3 a% h' i
55. {
    & f* t# ?6 {9 \8 S# s' A0 t, J4 G
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);
    - {5 S# z# h( s
60.   }
    % J0 Q1 h$ X0 \
61. 
    
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    
63. }
    1 e8 l2 D4 l4 j" j. b$ ^
64. 
    
65. void UART2_IRQ_FUNC(void)
    
66. {
    
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    2 w; D: t$ J& p; p( Y
68.   {
    
69.     HAL_UART_Receive(&uart2_dev.handle, (uint8_t *)&uart2_dev.ret, 1, 1000);
    ( r1 M* }% ]) ~
70.     UartQueuePush(&uart2_dev.recv, uart2_dev.ret);
    ' Z3 _0 @3 n1 j* f$ \+ J
71.   }
    
72. 
    ( R4 N4 a+ t7 h# t6 i& H  K
73.   HAL_UART_IRQHandler(&uart2_dev.handle);
    + z' k! t) G9 ]+ ^: X) w6 K
74. }</span></span>

复制代码

到这里，串口的初始化，发送，接收的接口就封装好了。
5 X0 ^- P) c+ b/ }8 z
裸机：裸机就在while(1)中调用UartRecv扫描数据；
- ]0 f& _1 L* ~7 ~
# I9 U* a2 _" ^" n系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）

串口队列可参考：串口队列
, C' w4 L8 v+ ^

' L( ^! O5 t6 A4 ~
/ @9 \/ }7 M8 v3 j" D

! |- v) i) ]- b$ s; ?