一、串口初始化过程
1、时钟使能；
% `  v- l" i# G8 |. p, _+ _3 a
' d& j! J$ }  K$ u2、GPIO初始化；
' n9 J' ~/ j. o; A" j  c
3、串口波特率设置；
! J, S9 j% S" p: r6 w
4、串口控制；

5、数据发送与接收
& G6 v8 n- M0 j6 \. N+ F4 Z
5 D1 D9 T. n) s# h2 ]
二、几个重要的串口函数
7 @: O" U# u% w

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); // 串口初始化
   
2. 
   ) M' ^! b9 R$ }6 J4 o3 f1 p! K4 v( M7 f
3. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口发送
   7 Q/ e5 ]! l% t6 q2 C! d
4. 
   & f- j  p5 }( T# g0 L  `
5. HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口接收
   7 O1 H! `" m! {3 A$ j
6. 
   ( B1 I( ~8 \0 E' e! C& z6 @
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   
8. 
   
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
   
10. 
    
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

- M4 F0 f9 u$ L; K2 W. y. Y三、几个重要的结构

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   4 G; q/ H; {: @3 h) n6 m
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   ) @9 E5 V2 J+ X9 Y/ w
3. typedef struct
   
4. {
     s4 P" X9 L9 l) M+ F) z% A$ g
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   
6. 
   4 Y- f& m( ]7 C3 A' K& V
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   
8. 
   , A, Q! a. I3 z. `, p4 N+ Y; a
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   
10. 
    
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
    ; `5 I3 U1 P! t
12. 
    
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    # }- a# N1 S, _  R2 C
14. 
    - a9 A0 w# _7 [1 C5 @
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    * i4 f- P; l8 A! k6 G
16. 
    ! u1 R9 J5 H2 g: O5 E) I
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    1 w' |0 ]1 q% N# v% N' V
18. 
    
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    
20. 
    3 i4 j' e9 n; N  m* Q/ R2 ]1 T
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    
22. 
    
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    ! D5 Z/ U( v7 r7 |& g+ G
24. 
    
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    
26. 
    
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
28. 
    
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    2 |* }5 V2 D0 T
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. 
    $ u* [8 w' t3 p& K( E3 ?
35.   __IO HAL_UART_StateTypeDef    RxState;     /*!< UART state information related to Rx operations.
    + ]: N  l. I9 H1 _6 O1 S4 Q8 h
36.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
37. 
    . \7 Z: p& ]0 s- k6 Q2 ~
38.   __IO uint32_t             ErrorCode;   /*!< UART Error code                    */
    
39. 
    . n) S0 i) ]; A
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   
2. typedef struct
   
3. {
   & ^2 z  ~% H* f
4.   __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
   ; m. |4 ?1 S7 t2 q% {5 k: c
5.   __IO uint32_t CR2;    /*!< USART Control register 2,                 Address offset: 0x04 */
   % N( \( |8 }2 E6 O
6.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   
7.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */                                               
     J0 c5 x6 v) q0 I1 E
8.   __IO uint32_t GTPR;   /*!< USART Guard time and prescaler register,  Address offset: 0x10 */
   7 c- n. o( X) s. k
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 */
    
12.   __IO uint32_t ICR;    /*!< USART Interrupt flag Clear register,      Address offset: 0x20 */
    * z' b+ Y# P9 z+ P: M* d/ ~
13.   __IO uint32_t RDR;    /*!< USART Receive Data register,              Address offset: 0x24 */
    ! `" M6 c' a, |, `) S! v7 V; E
14.   __IO uint32_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    
15. } USART_TypeDef;

复制代码

1. // 设置串口的各个参数 波特率 字长 停止位 奇偶校验 收发模式 硬件流 过采样
   , o* U! T1 I8 d! x
2. // 字长：8位/9位
   
3. // 停止位：1位/2位
   4 x& _8 q( H4 p0 L7 _5 U. T
4. typedef struct
   
5. {
   
6.   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
   * N5 c9 L' h, x% B. C
7.                                            The baud rate register is computed using the following formula:
   
8.                                            - If oversampling is 16 or in LIN mode,
   8 b' P% d3 V. }) G1 ]
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
   
10.                                            - If oversampling is 8,
    ; w- s; a  b% G% [1 G
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    7 |2 y+ m& P0 r5 S. {: ?9 K# }* G
12.                                               Baud Rate Register[3] =  0
    
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
    ! k) N; t4 _5 q) ?4 S( j# A
14. 
      P! U) B0 c8 b' }/ Z7 [3 B
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
    8 Q7 {5 R- E0 ^
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    / m/ t2 e) ^% K) Z5 N$ {! V" O5 m
17. 
    
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    
19.                                            This parameter can be a value of @ref UART_Stop_Bits */
    . m) L4 @7 n5 e
20. 
    / z, r. P. B, X9 c
21.   uint32_t Parity;                    /*!< Specifies the parity mode.
    
22.                                            This parameter can be a value of @ref UART_Parity
    ' G5 H" Z1 M  b- w
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
    . ?; h5 a: u# K3 Z+ L$ W
26.                                                  word length is set to 8 data bits). */
    6 R' t2 I1 }# Z$ t
27. 
    
28.   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
      t4 |# j* k  e. s- Z% \
29.                                            This parameter can be a value of @ref UART_Mode */
    . u+ U, A  s1 y5 Y. i
30. 
    
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    ! I  D& A7 T5 h- a
32.                                            or disabled.
    1 Z( C9 S3 n  t/ {# D2 W& Q
33.                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
    
34. 
    8 @" ?' m6 r' W, r- w5 H) @- A
35.   uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8).
    " o! A; @5 A0 B4 z0 Y
36.                                            This parameter can be a value of @ref UART_Over_Sampling */
    
37. 
    3 B' }- L4 r. J1 |
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
    1 P( Y8 k) }# h( M' X( m  R+ Z
40.                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling */
    9 u9 O  B( H2 N* k3 B0 ]% _% O
41. }UART_InitTypeDef;

复制代码

四、基本接口设计
7 B# j/ `5 U5 g9 x: T( m我们使用中断接收，普通发送。中断接收到的数据放入队列中，在外部可配置每路串口的功能。

+ N% g* |8 m' F6 Q) Q

1. // 抽象出一个串口设备结构体
   
2. typedef struct
   4 }% l: h5 ]. m& ?- F3 M7 ^
3. {
   
4.   UART_HandleTypeDef handle; // 串口句柄
   9 _. }1 a. w" g# O" Z- Y7 q
5.   uart_queue_t recv;         // 接收队列
   7 w. b. g* K5 N- x: G
6.   uart_queue_t send;         // 发送队列
   - V' G, @  T8 n( L
7.   uint8_t ret;               // 接收的值
   
8. } uart_dev_t;
   
9. 
   7 ?" @# s2 L2 _. L% r! w
10. static uart_dev_t uart1_dev;
    
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
   7 t6 K" I8 e, L4 G' g
2. typedef enum
   
3. {
   
4.   UART_CHANNEL_NONE,
   3 P* P1 T% O" }+ N5 O6 J( {' ^
5.   UART_CHANNEL_1,
   
6.   UART_CHANNEL_2,
   
7.   UART_CHANNEL_NUM
   . G, {$ V3 H) a) l( `3 Q# ?
8. } uart_channel_t;
   6 R7 E6 s& }9 \* y% t
9. 
   
10. // 宏定义串口的基本信息 之所以这样写，方便移植修改
    
11. #define UART1_CHANNEL             USART1
    " E  k; x+ T' ]" k3 _
12. #define UART1_PREEMPT_PRIO        UART1_PRIORITY
    $ R, ~  r+ O$ B! t9 C5 U6 Z% ]8 T
13. #define UART1_IRQ                 USART1_IRQn
    
14. #define UART1_IRQ_FUNC            USART1_IRQHandler
    ! @4 W0 f9 W  y1 g- x: C
15. #define UART1_CLK_ENABLE()        __HAL_RCC_USART1_CLK_ENABLE()
    & ?& K( `9 e9 h' ?( q
16. #define UART1_TX_PORT             GPIOA
    
17. #define UART1_TX_PIN              GPIO_PIN_10
    # D; g% Y9 s) j7 g6 v
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)
    . O+ q, _& Y5 |5 k8 g
20. #define UART1_RX_PORT             GPIOA
    
21. #define UART1_RX_PIN              GPIO_PIN_9
    
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)
    ; c  P) l' j+ I0 M1 i8 x/ m
24. 
    ; o: h2 I1 O; H! H. q" |
25. #define UART2_CHANNEL             USART2
    7 X- Y: V; z( z/ v- ~
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    ' E! w0 Z- D) C
27. #define UART2_IRQ                 USART2_IRQn
    , T9 W8 D# q. v' }" \- H5 F& z
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    . ?8 j' c# ^: b8 B0 G
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    5 _, S4 p* s# B9 n3 g
30. #define UART2_TX_PORT             GPIOA
    4 q: b. {& v, l, w8 m3 f
31. #define UART2_TX_PIN              GPIO_PIN_2
    , _1 W4 ^* Z* n, z
32. #define UART2_TX_AF               GPIO_AF7_USART2
    - V+ I3 V5 D6 b! w: f8 G4 z
33. #define UART2_TX_CONFIG()         GPIOConfigExt(UART2_TX_PORT, UART2_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_TX_AF)
    0 a7 r5 z! b/ q
34. #define UART2_RX_PORT             GPIOA
    
35. #define UART2_RX_PIN              GPIO_PIN_3
    
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. // 串口的基本操作
     u5 e! F9 S, D
2. // 串口1
   2 U5 V  J3 f- w1 W% q7 o8 m
3. static void uart1_var_init(void)
   
4. {
   6 Z7 B) H5 u/ L3 K! t. z" i: L
5.   uart1_dev.recv = uart1_queue_recv;
   2 K4 r/ l! J. V; O  Q+ |: ?
6.   uart1_dev.send = uart1_queue_send;
   
7. 
   2 _0 G" ?  c) \1 P( h, q1 s
8.   UartQueueInit(&uart1_dev.recv);
   ) p* K' d1 @, ]' X( ?
9.   UartQueueInit(&uart1_dev.send);
   + |& j; q6 U1 @5 s( W1 E6 k+ m
10. }
    . p: i" `' r6 T: g
11. 
    * n% F/ _: m$ ^) ~
12. static void uart1_gpio_init(void)
    & M; O. D- v9 `' z! ?6 e
13. {
    
14.   UART1_RX_CONFIG();
    ' {) D3 P/ i% F- Y& n$ |
15.   UART1_TX_CONFIG();
    4 o* {+ U8 j3 f$ W  g! j+ ~  N
16. }
    
17. 
    
18. static void uart1_mode_init(uint32_t bound)
    $ x# V: e2 |, c  v0 E  E* S! d
19. {
    ) ^( S! V+ g7 \& x  j
20.   UART1_CLK_ENABLE();
    
21. 
    
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;      // 一个停止位
    
26.   uart1_dev.handle.Init.Parity = UART_PARITY_NONE;       // 无奇偶校验位
    & s" c' j  x( Z, r; m  M
27.   uart1_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 无硬件流控
    ' v7 F4 S2 I! p- ~* I. x
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    9 m# L: m% B: Q, T5 _8 b
30. }
    
31. 
    & a& N5 Y: _+ @% ^
32. static void uart1_nvic_init(void)
    
33. {
    7 l2 I7 e% r- _. G( O
34.   HAL_NVIC_SetPriority(UART1_IRQ, UART1_PREEMPT_PRIO, 3);
    
35.   HAL_NVIC_EnableIRQ(UART1_IRQ);
    * U( W. r& R! ~$ ~, X2 w" s) n0 z- D
36. 
    
37.   __HAL_UART_ENABLE_IT(&uart1_dev.handle, UART_IT_RXNE);
    " }4 _( H% g; v6 J
38. }
    ' X: N, d# }1 B/ C. ^! f
39. 
    0 v0 l5 H( J1 I7 D# D# }
40. // 串口2
    
41. static void uart2_var_init(void)
    
42. {
    - s4 r& y3 T# O& ~9 D
43.   uart2_dev.recv = uart2_queue_recv;
    1 {3 P* k4 L5 Z- x0 P3 ]  W
44.   uart2_dev.send = uart2_queue_send;
    4 s0 Y" i/ r: x$ B  g  z2 Q
45. 
    1 ?3 i! T4 W) o6 V
46.   UartQueueInit(&uart2_dev.recv);
    
47.   UartQueueInit(&uart2_dev.send);
    3 o" }2 B$ @( B
48. }
    7 H' K  z; B+ m, K; f# d) g
49. 
    
50. static void uart2_gpio_init(void)
    4 E, a$ u' a; b- x
51. {
    , E+ @3 e1 P! G$ ]5 M7 _0 y# q
52.   UART2_RX_CONFIG();
    
53.   UART2_TX_CONFIG();
    
54. }
    
55. 
    
56. static void uart2_mode_init(uint32_t bound)
    : b2 p5 }, ^$ n& Q) s$ }4 ^9 K0 C/ n
57. {
    # z) I! ^9 m4 w! e- s
58.   UART2_CLK_ENABLE();
    
59. 
    ( a2 Z  `2 s; f! A* C
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    
61.   uart2_dev.handle.Init.BaudRate = bound;
    
62.   uart2_dev.handle.Init.WordLength = UART_WORDLENGTH_8B;
    * j/ g% I% K3 s
63.   uart2_dev.handle.Init.StopBits = UART_STOPBITS_1;
    
64.   uart2_dev.handle.Init.Parity = UART_PARITY_NONE;
    0 u8 X3 y5 H8 f& A4 `: z- I, u
65.   uart2_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    . e- o5 f: F* K) u2 t' @! @
66.   uart2_dev.handle.Init.Mode = UART_MODE_TX_RX;
    
67.   HAL_UART_Init(&uart2_dev.handle);
    1 K- u' d2 _9 ~1 N4 u9 m
68. }
    
69. 
    ; _0 h( C# _% {  j$ L( K$ M
70. static void uart2_nvic_init(void)
    
71. {
    
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    2 Q4 X6 \" m! n
74. 
    
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    6 \0 ^+ M8 |# y$ m& ?7 i
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
   
2. // 定义一个串口的列表
   
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   
4. typedef struct
   
5. {
   
6.   uint8_t channel;
   
7.   uart_dev_t *dev;
   * w  x' r2 W, @4 Z
8.   void (* var_init_cb)(void);
   
9.   void (* gpio_init_cb)(void);
   
10.   void (* mode_init_cb)(uint32_t bound);
    : [) i+ x& q, I5 p! C2 s! `, }( O
11.   void (* nvic_init_cb)(void);
    
12. } uart_config_t;
    / l' f. k$ W3 S. z
13. 
    , ^2 @0 x. D- g3 |' c
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},
    
17.   {UART_CHANNEL_2, &uart2_dev, uart2_var_init, uart2_gpio_init, uart2_mode_init, uart2_nvic_init},
    5 Q; u6 l( h# G% ~( g- }; L
18. };
    
19. 
    
20. static uart_dev_t *uart_dev_get(uint8_t channel)
    
21. {
    3 e' V) v! W. D; |  V6 R2 d
22.   uint8_t i;
    
23. 
    
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    : X2 q( F2 y/ u3 P3 h* ]
25.   {
    6 D; j! }& v5 {- l; o9 Y# v" f
26.     if(uart_configs<i>.channel == channel)
      L- r% }' i6 \1 p! I- B
27.   </i>  {
    0 P& C- Q* r9 [) D" Q+ Y* V
28.       return uart_configs.dev;
    
29.     }
    9 `2 \- V" K1 [" V) B2 c4 i2 w! F
30.   }
    9 f: C$ `3 B6 ^, q: L
31. 
    ; m; }( a% y4 w7 a# W2 ~
32.   return 0;
      K, J( O# F7 p$ L" ]* S6 Y
33. }
    
34. 
    ! |6 u& O0 k. `
35. static void uart_var_init(uint8_t channel)
    & @# Y. N2 b! `* N8 W9 u3 l
36. {
    
37.   uint8_t i;
    
38. 
    / J3 g) G% ~: Y
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    4 e. r0 U, v2 z
40.   {
    
41.     if(uart_configs.channel == channel)
    2 ^: @, |% c0 k0 U% z" _
42.     {
    
43.       uart_configs.var_init_cb();
    
44.       break;
    
45.     }
    . z* J5 f8 i$ `1 A
46.   }
    " ~2 K& @% Q. ]) {% a5 R8 _
47. }
    
48. 
    
49. static void uart_gpio_init(uint8_t channel)
    ) c* z. }0 G3 `# d' F
50. {
    1 Z  g: ?& x$ y
51.   uint8_t i;
    
52. 
    
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
54.   {
    1 W5 H0 _9 q7 m' y2 \; E1 `! A
55.     if(uart_configs.channel == channel)
    9 d4 x- g! p3 T( [$ l- N; X2 ?
56.     {
    
57.       uart_configs.gpio_init_cb();
    - G( H4 v/ ~: ^
58.       break;
    / @- u$ Z# ~, s, A7 ^8 s
59.     }
    : U- J+ M9 v( {. r+ F8 x
60.   }
    7 |% e3 {) h' _0 M
61. }
    
62. 
    / |8 J3 y" V$ _, y" W! E
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    
64. {
    7 @& T* ^# F7 C+ Q8 a* l  g, D: N! d+ E
65.   uint8_t i;
    
66. 
    & \8 I6 @0 a- x3 P  ?$ o
67.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    % @6 N5 x1 S) p5 v- l4 [5 [
68.   {
    
69.     if(uart_configs.channel == channel)
    * b& _7 P, c8 a5 N7 b' @
70.     {
    4 W0 ^* r2 P9 b+ ^$ w* W1 G
71.       uart_configs.mode_init_cb(bound);
    7 U1 U( Y( T; m  c" p
72.       break;
    / g4 `7 r- a3 q3 [* g" T. D
73.     }
    
74.   }
    
75. }
    
76. 
    + t2 @, j4 V5 H& H9 x/ O
77. static void uart_nvic_init(uint8_t channel)
    
78. {
    . T* K- D+ o4 Z. Q5 r( `+ ^! O
79.   uint8_t i;
    
80. 
    
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
82.   {
    
83.     if(uart_configs.channel == channel)
    : s2 W2 M' k6 }
84.     {
    ' N- u$ U: n6 [/ R6 P7 [
85.       uart_configs.nvic_init_cb();
    , O2 [0 V8 k* F. K5 d4 v
86.       break;
    
87.     }
    
88.   }
    , e9 M  o9 V( R3 Q+ G
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   
2. // 初始化函数，同步发送 异步发送 接收处理
   : q1 S8 P: d3 Y/ A5 F( W
3. void UartInit(uint8_t channel, uint32_t bound)
   ) i$ t7 C! V. }* X. ]/ d
4. {
   2 `9 r, J' u  n! s/ H. [
5.   uart_var_init(channel);
   
6.   uart_gpio_init(channel);
   4 X" {+ [; t' F# U6 m- G; @. W& }
7.   uart_mode_init(channel, bound);
   
8.   uart_nvic_init(channel);
   
9. }
   
10. 
    : B8 `& x7 {2 R& n- L6 Y4 L
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
    
12. {
    7 s" _' `/ o8 v+ K8 O: M
13.   uart_dev_t *dev = uart_dev_get(channel);
    0 D4 E# W8 f; X2 L  Q5 Q
14. 
    ' ~9 S. J) u% ^' N" N1 N+ O3 [$ R2 y
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    
16. }
    
17. 
    ( R" @: |; f7 [- o8 j5 X
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    
19. {
    ! F9 P% E* l  ?$ E2 Z* o3 a
20.   uint16_t i;
    4 J- U0 x( a" D4 R0 `0 e
21.   uart_dev_t *dev = uart_dev_get(channel);
    
22. 
    0 C: B/ o- p& q% W; z
23.   if(0 == dev)
    % p9 l/ ?8 u& H
24.   {
    
25.     return;
    * T/ O- g; H: o4 z/ \* c
26.   }
    
27. 
    ( `7 I! L- k( I3 h" {1 D, E* X
28.   for(i = 0; i < length; ++i)
    
29.   {
    ) m7 }, |  G# m! X: D5 ~- i6 m$ {
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    ! F5 Z. v; W' P6 @- d) u
31.   }
    
32. }
    2 S9 O+ o3 t. p+ l$ _! @; _
33. 
    8 A' V7 Z; S* R" n$ E
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    / P' _3 i+ z( {$ }
35. {
    
36.   uart_dev_t *dev = uart_dev_get(channel);
    , G7 q" `4 J5 x) u1 ^& t+ u! t- b& J
37. 
    
38.   if(0 == dev)
    
39.   {
    
40.     return 0;
    $ T+ i7 j# ~2 ?: h0 C  R
41.   }
    ( V8 h2 `; E0 a) B
42. 
    
43.   return UartQueuePop(&dev->send, c);
    
44. }
    * _4 V8 m( F8 A) m$ }
45. 
    
46. uint8_t UartRecv(uint8_t channel, uint8_t *c)
    
47. {
    
48.   uart_dev_t *dev = uart_dev_get(channel);
    
49. 
    
50.   return UartQueuePop(&dev->recv, c);
    & c( w& G* k5 p% N" o, x  }& N+ L8 x
51. }
    ! d8 y3 h3 o/ q* v0 Y$ Y' A
52. // 这里我没有使用串口的回调函数。
    
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    2 ]& L5 q- I4 |
54. void UART1_IRQ_FUNC(void)
    
55. {
    ' l. X1 L7 c/ g# j7 f3 e7 z
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);
    # [) W& M) k( l  Y2 ~$ h- m
60.   }
    
61. 
    
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    
63. }
    
64. 
    1 |' X- d) t& U; x' q& J
65. void UART2_IRQ_FUNC(void)
    ( A- _# m/ o+ ]5 H4 |8 v' m
66. {
    6 O/ C9 n4 T4 S4 t0 w
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    9 Y+ m* v, @$ K( {/ k6 @- H4 p* k, n
68.   {
    " o- ]5 i9 ]# G1 T; \2 V
69.     HAL_UART_Receive(&uart2_dev.handle, (uint8_t *)&uart2_dev.ret, 1, 1000);
    $ n$ z& p4 @8 H- a" H/ E" `
70.     UartQueuePush(&uart2_dev.recv, uart2_dev.ret);
    
71.   }
    
72. 
    
73.   HAL_UART_IRQHandler(&uart2_dev.handle);
    & m0 U0 W" k2 F8 s& Q" e
74. }</span></span>

复制代码

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

( ]/ n$ B0 R$ {/ q1 v- j裸机：裸机就在while(1)中调用UartRecv扫描数据；
, o! ~$ K  I2 k8 n6 C
系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）

7 l& V; F- M1 S( U6 ?串口队列可参考：串口队列



# G+ F% }* x) f0 ]2 {

$ u8 H8 a- K3 p+ h