一、串口初始化过程
0 g9 j' A2 G7 e  n; S1、时钟使能；
9 g1 p8 p9 b$ A0 b
& G9 d" `" p! j$ o$ E2、GPIO初始化；

3、串口波特率设置；

2 G; Q: d% q' q& B( b* G8 N4、串口控制；
$ a% M4 @% f( \  }% M
  \- ~3 M  E: S1 o) a5、数据发送与接收


# e& M4 _5 h3 l! p0 J二、几个重要的串口函数
5 Q$ H6 {& p* E1 j

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); // 串口初始化
   
2. 
   . V- D; p7 ^: e0 E
3. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口发送
   - p* V8 `3 j; b
4. 
   
5. HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口接收
   " S1 a# r, H& L/ C! J7 R
6. 
   - e" U2 Z- G/ ^; T8 X. i/ l4 f0 @
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   
8. 
   - r0 J. y3 Z# V* e; r4 W
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
   3 E! b! O, Z  B, p  U* I$ z
10. 
    . I, f6 a+ O& w3 b" E# W
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

7 Y5 Q4 y& \* r( L/ c+ v. o三、几个重要的结构

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   
3. typedef struct
   ! M3 _' ]- P2 `5 N  C* w1 m+ o
4. {
   
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   
6. 
   
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   
8. 
   9 f# h' N# A' c! E# y( E! z. G8 k
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   / `  T4 {& P4 F. Z
10. 
    " t5 L! p3 f+ x- c+ T
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
    
12. 
    % h% _3 K/ l. B8 L2 }. w
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    , [" I* I+ x4 q4 `0 N- Z/ w
14. 
    
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    3 V' b# T' R  H! A
16. 
    
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    * N7 _/ }- D2 ~& B* k
18. 
    
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    / l# p+ z3 c0 o7 m' s
20. 
    
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    & r& M9 h% J7 v) w" f) I( i
22. 
    % H, f& P' ]/ e5 F- L. Y
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    ! Q; z* F: I, Z" ~1 d4 @
24. 
    
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    ' P7 ~, m( t, n/ w8 g* {9 Z
26. 
    
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
28. 
    
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    9 Z  Y  m; H/ F0 @  R- W
30. 
    
31.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    
32.                                                   and also related to Tx operations.
    
33.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
34. 
    . K$ g" R. o0 |* |- Y
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. 
    , g4 A" j0 k% R* [* ?8 f+ A0 y/ ^( c* c
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   1 N% A! f2 D/ D+ o& W! r9 H
2. typedef struct
   ; p# _0 Q. G, K% ~  b; V9 x
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 */
   , p5 n, `0 z/ N1 C% j. `
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 */
   ' z" {2 k, ^1 g# G% z" F
9.   __IO uint32_t RTOR;   /*!< USART Receiver Time Out register,         Address offset: 0x14 */  
   
10.   __IO uint32_t RQR;    /*!< USART Request register,                   Address offset: 0x18 */
    & Y2 Y' l! M4 `) U0 B6 u
11.   __IO uint32_t ISR;    /*!< USART Interrupt and status register,      Address offset: 0x1C */
    : F, s% i( v/ p% A) {& u& Q
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 */
    
14.   __IO uint32_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    
15. } USART_TypeDef;

复制代码

1. // 设置串口的各个参数 波特率 字长 停止位 奇偶校验 收发模式 硬件流 过采样
   4 O0 _- H- k" f3 I% N. n1 V
2. // 字长：8位/9位
   $ z5 n/ o) Y6 g. l6 v. {
3. // 停止位：1位/2位
   
4. typedef struct
   
5. {
   3 e: k! h; T# v' G
6.   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
   
7.                                            The baud rate register is computed using the following formula:
   , e9 z. }! e1 k* @' S
8.                                            - If oversampling is 16 or in LIN mode,
   ; W% _+ a0 f" \
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
   
10.                                            - If oversampling is 8,
    ' d# K) Q6 e. B8 b
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    1 n/ E) A2 }5 k$ K5 i% L$ o
12.                                               Baud Rate Register[3] =  0
    ! ~0 I5 A% m# U2 h) G
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
    0 t0 Z" v& z$ m' X/ t
14. 
    
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
    0 u% ]) R( `/ n) ]
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    8 k; F4 K# L+ _7 `7 Y
17. 
    
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    - l8 n8 ?. m& m( v9 C+ h
19.                                            This parameter can be a value of @ref UART_Stop_Bits */
    
20. 
    
21.   uint32_t Parity;                    /*!< Specifies the parity mode.
    
22.                                            This parameter can be a value of @ref UART_Parity
    3 y$ `$ k8 }; f: ]- L
23.                                            @note When parity is enabled, the computed parity is inserted
    7 Q: V& E7 U0 C+ U
24.                                                  at the MSB position of the transmitted data (9th bit when
    % ~: Z. j9 W% u# o5 b
25.                                                  the word length is set to 9 data bits; 8th bit when the
    
26.                                                  word length is set to 8 data bits). */
    " _% `0 \  D+ G8 D) y; x. e0 t
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 */
    . p, q9 z  O0 Y7 k: J
30. 
    
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    + ~& |: V7 @" R8 b8 u5 _* O8 F
32.                                            or disabled.
    $ O! u3 j- ^* k3 M
33.                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
    
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 */
    
37. 
    
38.   uint32_t OneBitSampling;            /*!< Specifies whether a single sample or three samples' majority vote is selected.
    # K8 c( W8 x) j2 U/ }& {7 ~7 b7 \
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;

复制代码

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

  K1 D) j; o9 Z+ E# {8 t4 u) b; O

1. // 抽象出一个串口设备结构体
   . I8 F6 A, \' i; }( @
2. typedef struct
   
3. {
   " f' y, A1 ^; T! q4 S( N
4.   UART_HandleTypeDef handle; // 串口句柄
     p' i6 M# ]3 e
5.   uart_queue_t recv;         // 接收队列
   ' W6 O; |+ B$ e: O. s
6.   uart_queue_t send;         // 发送队列
   
7.   uint8_t ret;               // 接收的值
   6 u  r+ v. M5 y8 O$ h* X9 {
8. } uart_dev_t;
   5 ~$ q( n& b' g6 X+ j9 d/ e; S2 W. S9 t" w
9. 
   
10. static uart_dev_t uart1_dev;
    % @# T8 o6 [( o
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
   / f' K( A2 V2 o) @$ s
2. typedef enum
   
3. {
   3 N, s% p( i, w' n' |% ]% P$ }8 a
4.   UART_CHANNEL_NONE,
   * ~1 j8 t' N; ^9 Z# `7 ?
5.   UART_CHANNEL_1,
   
6.   UART_CHANNEL_2,
   # n5 [4 O4 F- ~- c, G% t  U
7.   UART_CHANNEL_NUM
   ( U; a; N* q$ Z' U5 ~' O
8. } uart_channel_t;
   - V) h; U' Z! ~1 g6 E# _
9. 
   - r" t* A( b% T. K4 ~& @+ H
10. // 宏定义串口的基本信息 之所以这样写，方便移植修改
    
11. #define UART1_CHANNEL             USART1
    
12. #define UART1_PREEMPT_PRIO        UART1_PRIORITY
    
13. #define UART1_IRQ                 USART1_IRQn
    
14. #define UART1_IRQ_FUNC            USART1_IRQHandler
    " N' D# w6 U5 {/ T* y' b, B" M8 i
15. #define UART1_CLK_ENABLE()        __HAL_RCC_USART1_CLK_ENABLE()
    * b9 h- y2 s. |/ X) |) N) L
16. #define UART1_TX_PORT             GPIOA
    " @5 k2 H* I. M9 p8 n6 i9 K
17. #define UART1_TX_PIN              GPIO_PIN_10
    
18. #define UART1_TX_AF               GPIO_AF7_USART1
    3 z; C. e) P+ e- x& n
19. #define UART1_TX_CONFIG()         GPIOConfigExt(UART1_TX_PORT, UART1_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_TX_AF)
    4 L* D0 ?3 w3 S4 M$ p' n) f
20. #define UART1_RX_PORT             GPIOA
    
21. #define UART1_RX_PIN              GPIO_PIN_9
    
22. #define UART1_RX_AF               GPIO_AF7_USART1
    1 U7 d- c. O' j6 M$ s( l
23. #define UART1_RX_CONFIG()         GPIOConfigExt(UART1_RX_PORT, UART1_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_RX_AF)
    
24. 
    ! r9 f; @% G7 z
25. #define UART2_CHANNEL             USART2
    
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    + x3 R& H; C0 `" W  i/ R7 d" n
27. #define UART2_IRQ                 USART2_IRQn
    
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    ) J& b: Z% b3 Q* r
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    , R3 Z% X! t7 m6 z; ?% X
30. #define UART2_TX_PORT             GPIOA
    4 x4 {; c4 j$ a3 C. L
31. #define UART2_TX_PIN              GPIO_PIN_2
    
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)
    - o% G) C' \0 n$ t6 O# ^6 _3 Y3 k( j+ ^
34. #define UART2_RX_PORT             GPIOA
    
35. #define UART2_RX_PIN              GPIO_PIN_3
    ' A9 a/ ~' k4 l) c1 |& c2 @
36. #define UART2_RX_AF               GPIO_AF7_USART2
    
37. #define UART2_RX_CONFIG()         GPIOConfigExt(UART2_RX_PORT, UART2_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_RX_AF)

复制代码

1. // 串口的基本操作
   % z) V" F5 }9 Q  Y
2. // 串口1
   ! W, T% g3 ]! ~8 J. e( n
3. static void uart1_var_init(void)
   , y3 `6 k; a' R* W% l2 _% W
4. {
   
5.   uart1_dev.recv = uart1_queue_recv;
   7 @8 c1 _* L, V9 [3 ?
6.   uart1_dev.send = uart1_queue_send;
   
7. 
   + V! O! P0 y+ X8 D" B6 w1 L
8.   UartQueueInit(&uart1_dev.recv);
   
9.   UartQueueInit(&uart1_dev.send);
   
10. }
    7 G, c3 m, d1 ^" m1 H$ w
11. 
    
12. static void uart1_gpio_init(void)
    0 |3 F0 X7 }( L5 t9 v$ C
13. {
    ' ]* ?2 t5 p- f
14.   UART1_RX_CONFIG();
    
15.   UART1_TX_CONFIG();
    : n4 B: R  p+ t- q0 Q1 R( }
16. }
    6 r/ y3 o% l% g6 u. D, f
17. 
    
18. static void uart1_mode_init(uint32_t bound)
    1 n6 H, |9 G6 N5 G5 i6 K
19. {
    + w$ ^# n; g' ]
20.   UART1_CLK_ENABLE();
    ; M) W' e7 ~8 D
21. 
    - W/ B8 i7 s2 q
22.   uart1_dev.handle.Instance = UART1_CHANNEL;
    
23.   uart1_dev.handle.Init.BaudRate = bound;                // 波特率
    
24.   uart1_dev.handle.Init.WordLength = UART_WORDLENGTH_8B; // 字长为8位数据格式
    8 ], a  k/ s3 ]) ?1 _( _/ S
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; // 无硬件流控
    - e, ^6 o6 Y9 _9 ]
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    
30. }
    
31. 
    & `) I% q! D! t9 E4 n
32. static void uart1_nvic_init(void)
    
33. {
    7 I$ V+ \* T; Q# f7 |+ N6 s
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
    
41. static void uart2_var_init(void)
    9 ^, ^! Y& j: ^8 Y' D9 N& ^! ]; {
42. {
    ' O' ^9 G8 t$ a4 s" a! _
43.   uart2_dev.recv = uart2_queue_recv;
    ; Z+ K; Z+ f) d& _1 A( g. h
44.   uart2_dev.send = uart2_queue_send;
    
45. 
    
46.   UartQueueInit(&uart2_dev.recv);
    : |+ d4 K( {( @4 W3 i
47.   UartQueueInit(&uart2_dev.send);
    
48. }
    
49. 
    
50. static void uart2_gpio_init(void)
    
51. {
    + V4 w. R, z; v) D
52.   UART2_RX_CONFIG();
    
53.   UART2_TX_CONFIG();
    ; {5 }3 p2 X& J! R. |, O& Q
54. }
    # Y4 [, r0 L5 f$ y" w
55. 
    ! |  s( ?. H* M! R8 g
56. static void uart2_mode_init(uint32_t bound)
    4 d* ~* o2 b$ n& V3 I: u) `
57. {
    
58.   UART2_CLK_ENABLE();
    
59. 
    5 N) A8 F& }. Q9 i  \
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    " I( E, X! [% P) J
61.   uart2_dev.handle.Init.BaudRate = bound;
    
62.   uart2_dev.handle.Init.WordLength = UART_WORDLENGTH_8B;
    ' J' J" X& h* X9 I( Z, x
63.   uart2_dev.handle.Init.StopBits = UART_STOPBITS_1;
    ' ]# x) ]( l( z3 y
64.   uart2_dev.handle.Init.Parity = UART_PARITY_NONE;
    3 `! H$ ?  y! _1 w2 Y3 V
65.   uart2_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    * z9 v0 l% ~, F# d- O, s" d9 E
66.   uart2_dev.handle.Init.Mode = UART_MODE_TX_RX;
    . A9 @" G  b6 u
67.   HAL_UART_Init(&uart2_dev.handle);
    4 E5 g! q( B' X& y# v$ k0 Z
68. }
    + H' p4 e1 i( i; x
69. 
    
70. static void uart2_nvic_init(void)
    ' p) j7 f+ ~; y0 p- b) F
71. {
    
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    ( i( }& o, C$ @! P8 N9 q0 y
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    # H" Y1 D7 P$ U8 K. e  L" W
74. 
    
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
   
2. // 定义一个串口的列表
   ! Q5 O7 c) y* u1 T
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   
4. typedef struct
   $ B4 _, [/ N1 s) p
5. {
   
6.   uint8_t channel;
   8 e4 U& h% l5 A* ~
7.   uart_dev_t *dev;
   
8.   void (* var_init_cb)(void);
   ! z, B# K7 o$ \7 B
9.   void (* gpio_init_cb)(void);
   6 u4 f* A5 X6 |0 p) }3 k6 A& h6 o8 g- e
10.   void (* mode_init_cb)(uint32_t bound);
    
11.   void (* nvic_init_cb)(void);
    
12. } uart_config_t;
    6 N* y, G9 J# E3 d1 q. s
13. 
    
14. static const uart_config_t uart_configs[] =
    
15. {
    
16.   {UART_CHANNEL_1, &uart1_dev, uart1_var_init, uart1_gpio_init, uart1_mode_init, uart1_nvic_init},
    % k  o- k. C+ I* b
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)
    ( o0 ]3 [) u7 V9 f' s
21. {
    2 R3 d' _0 T: z; D! e
22.   uint8_t i;
    # q: }  z& ], Y
23. 
    
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
25.   {
    
26.     if(uart_configs<i>.channel == channel)
    
27.   </i>  {
    " D* P3 t% @# n' l# h1 `
28.       return uart_configs.dev;
    
29.     }
    
30.   }
    
31. 
    
32.   return 0;
    
33. }
    
34. 
    . f( Z# h2 H* f0 H, E8 v% Q7 c  g
35. static void uart_var_init(uint8_t channel)
    
36. {
    " H5 `7 Z. i# K3 M
37.   uint8_t i;
    
38. 
    6 x+ V" i8 J7 v& C2 J
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
40.   {
    
41.     if(uart_configs.channel == channel)
    
42.     {
    5 ~6 L$ K4 M2 ^" m6 z% d, c
43.       uart_configs.var_init_cb();
    * j3 U. r' C# U5 {/ _. H
44.       break;
    % R& @+ b1 W! o) Z% [, c) Z# r+ N
45.     }
    
46.   }
    7 _# M% [# V! a
47. }
    ) U* p3 [/ q6 ^5 l6 z
48. 
    
49. static void uart_gpio_init(uint8_t channel)
    
50. {
    ( b8 v: m+ W% d7 p2 i& p) L
51.   uint8_t i;
    & g& O3 y' p5 {" d( X8 G, A
52. 
    6 w$ @" \" U3 f3 H
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    6 x7 j/ h" }* P! ~2 g
54.   {
    
55.     if(uart_configs.channel == channel)
    
56.     {
    ( n- C; [; J' K" ~
57.       uart_configs.gpio_init_cb();
    / q5 g$ W3 X; U5 g
58.       break;
    : K4 m9 J5 Z3 c  S) m( S8 b
59.     }
    - W9 V, }; B% l+ L0 x
60.   }
    
61. }
    : X! P" j1 ?4 r8 ^
62. 
    
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    
64. {
    
65.   uint8_t i;
    
66. 
    
67.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
68.   {
    + ~" G$ y' S$ m; ?2 O% H+ I0 j7 d
69.     if(uart_configs.channel == channel)
    
70.     {
    
71.       uart_configs.mode_init_cb(bound);
    
72.       break;
    8 i- ?: z& w+ J! C
73.     }
    ! M1 i  `2 h0 I. z; a+ Y5 E" @/ }
74.   }
    $ R# \0 Q# V( y0 q5 k: N: u- X/ d& V
75. }
    
76. 
    
77. static void uart_nvic_init(uint8_t channel)
    - ]# G, T/ _% i$ @0 n& s
78. {
    3 I# P3 x7 D$ N, ?; [% B# L, {
79.   uint8_t i;
    7 C. y$ L: P# Y4 S3 c8 \8 k
80. 
    
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    ) D% R. |/ k* H  G/ ~3 _
82.   {
    
83.     if(uart_configs.channel == channel)
      A" g% K5 h; k# T
84.     {
    8 p# K* S/ @4 D6 Z- w' r4 ]
85.       uart_configs.nvic_init_cb();
    
86.       break;
    
87.     }
    6 T, k% b7 [2 K7 Z5 c0 R; N! T/ H
88.   }
    5 x5 E% Q. M0 L3 w5 \
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   # I1 B% s/ m. H3 ]- L1 p5 F6 f5 A
2. // 初始化函数，同步发送 异步发送 接收处理
   
3. void UartInit(uint8_t channel, uint32_t bound)
   
4. {
   
5.   uart_var_init(channel);
   
6.   uart_gpio_init(channel);
   
7.   uart_mode_init(channel, bound);
   
8.   uart_nvic_init(channel);
   
9. }
   8 G( @  ^/ O& Q( B8 u1 ?
10. 
    9 \1 ?- D  b$ e  E3 q
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
    & w/ N1 y+ }- d  g
12. {
    * B8 V* y: C- ^+ Z- P9 t
13.   uart_dev_t *dev = uart_dev_get(channel);
    
14. 
    0 T6 u: \6 l8 Y' ]' w
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    
16. }
    
17. 
    
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    ) b9 ?# J3 S/ ~+ K& Y
19. {
    
20.   uint16_t i;
    
21.   uart_dev_t *dev = uart_dev_get(channel);
    & `6 T: N9 f0 w
22. 
    4 S  M6 x, T2 u) y4 e
23.   if(0 == dev)
    
24.   {
    
25.     return;
    8 ?/ V1 c5 f4 S. ~
26.   }
    . ]- y- x% x+ X4 s! P4 B3 _
27. 
    1 P+ n9 {/ A7 l1 ]5 d% O' h8 Z
28.   for(i = 0; i < length; ++i)
    5 Z7 X1 H3 A8 j# [' M% s1 f
29.   {
    
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    , }7 O2 G5 S+ l  e* C- k0 C  \
31.   }
    - q/ U- H" n" b; s! t
32. }
    : x, v8 R8 D# i5 e! ^  [; N) C
33. 
    
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    
35. {
    
36.   uart_dev_t *dev = uart_dev_get(channel);
    
37. 
    ) Q( W/ O( a6 Y& y1 I% v
38.   if(0 == dev)
    
39.   {
    
40.     return 0;
    7 h; X' K! ^7 }* `3 B
41.   }
    . s% d$ D& k. y3 h$ p  U! N3 w8 f
42. 
    
43.   return UartQueuePop(&dev->send, c);
    6 O( v2 {9 w( T1 m, F7 s; k4 y, l
44. }
    
45. 
    
46. uint8_t UartRecv(uint8_t channel, uint8_t *c)
    
47. {
      q+ h: k# g# {9 @( U/ ?
48.   uart_dev_t *dev = uart_dev_get(channel);
    
49. 
    
50.   return UartQueuePop(&dev->recv, c);
    
51. }
    
52. // 这里我没有使用串口的回调函数。
    ; A: S8 y0 a/ e9 K
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    + K# t, j% i" _" y
54. void UART1_IRQ_FUNC(void)
    
55. {
    4 `7 u. {# j$ F% `/ z% B6 ]
56.   if(__HAL_UART_GET_IT(&uart1_dev.handle, UART_IT_RXNE) != RESET)
    9 @: r6 |. `4 T0 F$ L
57.   {
    1 |4 V. b- l5 `- M4 S' n
58.     HAL_UART_Receive(&uart1_dev.handle, (uint8_t *)&uart1_dev.ret, 1, 1000);
    
59.     UartQueuePush(&uart1_dev.recv, uart1_dev.ret);
    : {0 |5 J, @0 b( z. M7 H' }$ l
60.   }
    
61. 
    " z2 ?& S- `0 C, e* t
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    
63. }
    
64. 
    
65. void UART2_IRQ_FUNC(void)
    
66. {
    ; K9 r+ f9 I: q+ K
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    
68.   {
    
69.     HAL_UART_Receive(&uart2_dev.handle, (uint8_t *)&uart2_dev.ret, 1, 1000);
    ; \7 D. ^' f; B+ [6 [  U
70.     UartQueuePush(&uart2_dev.recv, uart2_dev.ret);
    - E. b! X1 D( `$ M* ?
71.   }
    3 o) y9 ?. Z  o1 V! @& k3 [
72. 
    " j- a/ U2 l( G* n* V* F) C
73.   HAL_UART_IRQHandler(&uart2_dev.handle);
    
74. }</span></span>

复制代码

到这里，串口的初始化，发送，接收的接口就封装好了。

裸机：裸机就在while(1)中调用UartRecv扫描数据；
! h# p; M# @. c/ v9 P1 E8 Y" k
系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）
4 N  q5 C5 m! {: s
串口队列可参考：串口队列
- K9 E% s/ S; I8 C4 b8 z! r5 F# q' v; k

* y( W* L3 W* s$ v0 t* l8 N: E8 |( ^