一、串口初始化过程
' R7 {0 b7 k+ O4 o& D& z1、时钟使能；
% `0 x" T* V, ]4 s) P
2、GPIO初始化；

. C$ E( u. j# L4 |' c, @( K3、串口波特率设置；
: B/ V% Q' l( B" Q! n
4、串口控制；

5、数据发送与接收


二、几个重要的串口函数
( o+ n3 z+ e: R( K  N" \2 v

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); // 串口初始化
   ! h/ l6 D; x- r# B& F! t
2. 
   
3. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口发送
   1 G1 R" j1 E( o# e) k' }
4. 
   
5. HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口接收
   3 p& T$ R2 }& t8 A( y7 ~* L* @
6. 
   - ]/ N. X$ E( f6 s: C; C; h9 y
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   6 L$ j; S7 n$ j2 M% a/ ~
8. 
   
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
   
10. 
      H, U  P- x% ^
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

: M0 c' d- w* e: H1 M- o1 O三、几个重要的结构

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   
3. typedef struct
   
4. {
   
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   2 _$ \; c& u' k/ L
6. 
   
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   + ^& K- S& j$ g5 C7 h6 Y
8. 
   
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
     e: p0 n! {; n1 q8 u& ~
10. 
    ! Q; G- T* W- u5 a
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
    
12. 
    
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    & ]4 e# Q( d: W& d' y1 n, u
14. 
    
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    ! {" V$ l" l2 `, K
16. 
    
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    
18. 
    . P0 n/ s/ F7 W' T5 i
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    
20. 
    
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    
22. 
    , D# q8 k2 O+ c  U6 h' Y$ z  ^
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    
24. 
    
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    + C! T3 J0 Q. \9 j; L$ ]
26. 
    4 S, v9 M9 s  I+ P( s6 B
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
28. 
    
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    + {8 R; d/ i- Y  ^7 Z9 u
30. 
    , ]4 J# f7 z. m
31.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    ; R" @' W# ]' ^0 }( h
32.                                                   and also related to Tx operations.
    
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.
    " [1 F) t& E8 [. r! E% L" H
36.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
37. 
      l& s) o+ @+ F( o! P1 f( t  v$ x+ n
38.   __IO uint32_t             ErrorCode;   /*!< UART Error code                    */
    + j/ r) e  ?2 w  \
39. 
    
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   9 Z8 W" f7 u" a! y0 A9 w: l) O
2. typedef struct
   
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 */
   
6.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   
7.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */                                               
   ' R6 c, v* `4 P& i$ `  @. k% j
8.   __IO uint32_t GTPR;   /*!< USART Guard time and prescaler register,  Address offset: 0x10 */
   % H! G- R  W+ x1 g7 p
9.   __IO uint32_t RTOR;   /*!< USART Receiver Time Out register,         Address offset: 0x14 */  
   / a, Q# h. }( z# g1 o) @
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 */
    
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. {
   
6.   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
   . x& E, S$ U8 v& ]1 p* b/ F
7.                                            The baud rate register is computed using the following formula:
   
8.                                            - If oversampling is 16 or in LIN mode,
   5 g8 B1 F( z$ J& Y( A: i* T' w+ l. |, l
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
   
10.                                            - If oversampling is 8,
    + C0 s4 {( w$ U' O- }( S
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    
12.                                               Baud Rate Register[3] =  0
    4 y+ n4 \* s- m* Q. m
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
    
14. 
      M: A2 C- L, ]; G* W* H
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
    & P$ M; H; X, d! k
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    
17. 
    % Q2 V- }4 {# x1 X9 B4 e7 H( t$ N
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    5 q: Y5 o; o) S+ N5 u) a9 g% y
19.                                            This parameter can be a value of @ref UART_Stop_Bits */
    
20. 
    
21.   uint32_t Parity;                    /*!< Specifies the parity mode.
    * p1 ~- }% i* Z. K- _' m/ L8 m
22.                                            This parameter can be a value of @ref UART_Parity
    
23.                                            @note When parity is enabled, the computed parity is inserted
    7 d" g7 H3 k4 s% _2 ^  @
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). */
    
27. 
    
28.   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
    8 i' G! c# m  y% x# q5 }
29.                                            This parameter can be a value of @ref UART_Mode */
    
30. 
    , h1 b( R" e( c6 }& m5 B
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    5 {+ K, F7 T( }* k8 e1 z
32.                                            or disabled.
    ' X2 j; _# u% I+ G" q
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. 
    . N1 U- q1 r8 N0 n9 x. s
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
    
40.                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling */
    
41. }UART_InitTypeDef;

复制代码

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

1. // 抽象出一个串口设备结构体
   
2. typedef struct
   
3. {
   
4.   UART_HandleTypeDef handle; // 串口句柄
   : R% g$ m, C+ y5 R+ z. S1 g7 C
5.   uart_queue_t recv;         // 接收队列
   
6.   uart_queue_t send;         // 发送队列
   
7.   uint8_t ret;               // 接收的值
   : C0 D6 K* e+ n* n
8. } uart_dev_t;
   ' p3 h# ?; k4 b. }! {
9. 
   
10. static uart_dev_t uart1_dev;
    
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
   + u+ ]" \; ?7 W: A: i* M
2. typedef enum
     E, O' w( M- b4 Y. N
3. {
   
4.   UART_CHANNEL_NONE,
   
5.   UART_CHANNEL_1,
   # S4 Y8 b3 U7 t( a
6.   UART_CHANNEL_2,
   
7.   UART_CHANNEL_NUM
   
8. } uart_channel_t;
   & s- F6 W& s* a
9. 
   - c' p! x4 g+ c
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
      X$ c  q+ L- j% x9 U
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)
    
20. #define UART1_RX_PORT             GPIOA
    
21. #define UART1_RX_PIN              GPIO_PIN_9
    ) q3 X& ?4 k4 I: [
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. 
    , u% R( G$ O/ T; i, S: Z
25. #define UART2_CHANNEL             USART2
    
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    ' a; S+ {5 T1 k" ]
27. #define UART2_IRQ                 USART2_IRQn
    + [9 c# c. p5 T, G+ O: q2 c
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    ( L. ~+ D) p; X6 k; X3 i/ ^$ f) v2 @
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    
30. #define UART2_TX_PORT             GPIOA
    2 |5 ^( z& J( a% x
31. #define UART2_TX_PIN              GPIO_PIN_2
    & C1 v- C8 F, f9 m: L1 @; V8 y
32. #define UART2_TX_AF               GPIO_AF7_USART2
    0 C8 Q5 ~. f* |* u9 a
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
    , r4 z6 m8 G: R) U4 B8 J
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. // 串口的基本操作
   
2. // 串口1
   
3. static void uart1_var_init(void)
   
4. {
   . R, C/ W" P# s: N# \8 h1 c
5.   uart1_dev.recv = uart1_queue_recv;
   ( W1 U! {) q/ f$ x7 r
6.   uart1_dev.send = uart1_queue_send;
   * E4 E4 D- J+ {. _
7. 
   - x6 ]* n5 O$ T! ^
8.   UartQueueInit(&uart1_dev.recv);
   
9.   UartQueueInit(&uart1_dev.send);
   
10. }
    
11. 
    
12. static void uart1_gpio_init(void)
    
13. {
    2 U. k1 m: z# L  a' b2 b
14.   UART1_RX_CONFIG();
    % k9 @- m2 G0 m) b# L+ d  c$ y
15.   UART1_TX_CONFIG();
    
16. }
    
17. 
    
18. static void uart1_mode_init(uint32_t bound)
    7 Y# f& s* G3 C4 i% M, J6 y9 \- B3 T
19. {
    
20.   UART1_CLK_ENABLE();
    
21. 
    
22.   uart1_dev.handle.Instance = UART1_CHANNEL;
    
23.   uart1_dev.handle.Init.BaudRate = bound;                // 波特率
    % `* \5 q- {, y9 C# P1 U
24.   uart1_dev.handle.Init.WordLength = UART_WORDLENGTH_8B; // 字长为8位数据格式
    , s. h' j3 _8 S: N1 I8 H
25.   uart1_dev.handle.Init.StopBits = UART_STOPBITS_1;      // 一个停止位
    ' K9 }& s- [: a# _# r. T) c
26.   uart1_dev.handle.Init.Parity = UART_PARITY_NONE;       // 无奇偶校验位
    , d5 C3 m4 W, c, D  u
27.   uart1_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 无硬件流控
    & h: h, l. T2 W* u% X1 h8 c' _
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    
30. }
    
31. 
    % C& R7 K& H0 l! R( m
32. static void uart1_nvic_init(void)
    
33. {
    
34.   HAL_NVIC_SetPriority(UART1_IRQ, UART1_PREEMPT_PRIO, 3);
    
35.   HAL_NVIC_EnableIRQ(UART1_IRQ);
    1 P6 K- C; V; [9 T4 S2 f
36. 
    
37.   __HAL_UART_ENABLE_IT(&uart1_dev.handle, UART_IT_RXNE);
    
38. }
    9 e7 z1 ~- _8 l3 R- z8 X! f
39. 
    ( v8 x$ x$ g2 d( H/ G0 P
40. // 串口2
    & g+ V) W, L; J, b
41. static void uart2_var_init(void)
    
42. {
    
43.   uart2_dev.recv = uart2_queue_recv;
    4 U1 ]3 h# H$ s. r# |
44.   uart2_dev.send = uart2_queue_send;
    
45. 
    7 a1 S* m% r1 U6 s) u0 k% k" k% R/ }
46.   UartQueueInit(&uart2_dev.recv);
    
47.   UartQueueInit(&uart2_dev.send);
    
48. }
    , W7 H$ K: M$ f& ]% \- b" G( a& C
49. 
    4 U2 s3 a/ T( |% [. O4 u1 w& w
50. static void uart2_gpio_init(void)
    
51. {
    
52.   UART2_RX_CONFIG();
    
53.   UART2_TX_CONFIG();
    
54. }
    9 g8 {" P2 m( u! q  g
55. 
    $ _/ q. V! @# V8 `" ~# H
56. static void uart2_mode_init(uint32_t bound)
    
57. {
    9 f3 Y/ b/ n) i" H& a: t/ C" h7 H
58.   UART2_CLK_ENABLE();
    " u2 Q; t2 S5 n! i* s  z
59. 
    
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    ) z: N* y9 q$ c, p6 m  W
61.   uart2_dev.handle.Init.BaudRate = bound;
    
62.   uart2_dev.handle.Init.WordLength = UART_WORDLENGTH_8B;
    
63.   uart2_dev.handle.Init.StopBits = UART_STOPBITS_1;
    ) `  m" u" x& R! [9 s5 y
64.   uart2_dev.handle.Init.Parity = UART_PARITY_NONE;
    ! n# U5 C4 W' c. h; H
65.   uart2_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
66.   uart2_dev.handle.Init.Mode = UART_MODE_TX_RX;
    + B- |1 Z: V: z5 }9 A" f( y9 d
67.   HAL_UART_Init(&uart2_dev.handle);
    
68. }
    / K/ D+ P1 r. w
69. 
    
70. static void uart2_nvic_init(void)
    ) ?% L7 P. z# n; ^& V
71. {
    . Q2 d! c9 W: ]% p0 ~1 J# F; E
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    8 ]9 X3 |7 \: x( _* M
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    
74. 
    2 G7 o+ U' {, k- v6 w
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    3 V1 H+ c% e$ n  N" o, Q% P2 |3 M
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
   
2. // 定义一个串口的列表
   . \- o- Q. F8 u% C
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   
4. typedef struct
   
5. {
   ) a- X9 q9 \9 g1 }
6.   uint8_t channel;
   2 d! c) g2 P% |2 \
7.   uart_dev_t *dev;
   
8.   void (* var_init_cb)(void);
   # k8 o$ i8 y! y- v0 y1 n, E
9.   void (* gpio_init_cb)(void);
   4 j' [* E- q9 ?
10.   void (* mode_init_cb)(uint32_t bound);
    # p1 r3 H5 k! {- |  N% X
11.   void (* nvic_init_cb)(void);
    
12. } uart_config_t;
    
13. 
    / x. Z& }* Q+ }, l
14. static const uart_config_t uart_configs[] =
    3 G3 u+ r% J9 u# _
15. {
    0 I9 z+ d9 J1 l+ h6 I
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. };
    2 _+ T7 j+ d2 H6 _' W6 Z
19. 
    2 a5 B  j; o, E
20. static uart_dev_t *uart_dev_get(uint8_t channel)
    ( q+ `2 \5 P, I2 ]" \" B
21. {
    
22.   uint8_t i;
    
23. 
    7 M1 j3 f- Z' ^7 y! {
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
25.   {
    7 S# Z8 f* ?1 N! m
26.     if(uart_configs<i>.channel == channel)
    ) f* U9 k, s7 b7 r# V
27.   </i>  {
    
28.       return uart_configs.dev;
    ' T  j- l: Z  W  w* ~
29.     }
    
30.   }
    
31. 
    4 Y/ q# Z& |3 `! Z( v; w
32.   return 0;
    6 U1 g( p9 p, [6 G( P, J
33. }
    ( A3 h6 T% C5 c
34. 
    + y* w# r! S2 b/ k1 M+ p
35. static void uart_var_init(uint8_t channel)
    
36. {
    * Y! H; d, V3 g. p" x) W/ }
37.   uint8_t i;
    , ]8 Q" G: w; J( a- J
38. 
    
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    2 R% d  r& d2 e6 c0 |& u, Q
40.   {
    
41.     if(uart_configs.channel == channel)
      C' _* J, f( V5 [$ Z* z: `
42.     {
    
43.       uart_configs.var_init_cb();
    2 t% _  ~/ `# E" d2 W6 j
44.       break;
    
45.     }
    
46.   }
    9 ^, a9 _' K3 e. b4 A3 |5 w
47. }
    9 z7 V# d2 Z% Y2 T: {/ N" c/ g- N
48. 
    - i/ T; q7 t$ G2 x5 g
49. static void uart_gpio_init(uint8_t channel)
    
50. {
    $ O! v7 ^# o, l
51.   uint8_t i;
    
52. 
    6 P; D, M1 y1 D0 m
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    7 C3 `* h% ?- ~) S7 K0 y" T- Z. j0 I
54.   {
    ' n0 w$ U) d3 H
55.     if(uart_configs.channel == channel)
    
56.     {
    " @% Y0 Y: [5 U3 x+ W7 Y8 \* b: s+ U
57.       uart_configs.gpio_init_cb();
    8 y% `$ ~& X, e* w
58.       break;
    
59.     }
    
60.   }
    / R  f* k( z: n5 m: i. v  @
61. }
    
62. 
    
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    3 e2 u/ H6 @2 b6 b. y
64. {
    
65.   uint8_t i;
    
66. 
    , _/ w. H$ V; y, `% j0 ]: z( J2 d
67.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
68.   {
    
69.     if(uart_configs.channel == channel)
    
70.     {
    
71.       uart_configs.mode_init_cb(bound);
    
72.       break;
    
73.     }
    6 r, S" W3 Y$ r. L6 T8 ?
74.   }
    
75. }
    
76. 
    
77. static void uart_nvic_init(uint8_t channel)
    
78. {
    5 L" Q% O# K9 J) S& F
79.   uint8_t i;
    2 C8 c$ r9 d" T  Q! V
80. 
    . g* R+ ]" @3 r
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
82.   {
    
83.     if(uart_configs.channel == channel)
    ( C' U: t) L% q$ O
84.     {
    3 C3 n7 @4 o  ^, n7 u# o3 }) t
85.       uart_configs.nvic_init_cb();
      b9 {$ P0 W8 ?9 W% P
86.       break;
    
87.     }
    / T0 y! Q/ y2 G2 o  s4 y3 n5 f0 ~
88.   }
    
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   
2. // 初始化函数，同步发送 异步发送 接收处理
   
3. void UartInit(uint8_t channel, uint32_t bound)
   
4. {
   8 }$ v4 T( }7 [" _, k2 Q' |
5.   uart_var_init(channel);
   
6.   uart_gpio_init(channel);
   
7.   uart_mode_init(channel, bound);
   0 m; H( G$ i7 x, E; G- f
8.   uart_nvic_init(channel);
   ) |. v" J9 I5 X6 Y0 o( w2 b
9. }
   
10. 
    
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
      C/ Y+ Q$ e, A' H7 ~
12. {
    
13.   uart_dev_t *dev = uart_dev_get(channel);
    
14. 
    $ W6 P9 ]" T) r! a' `
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    
16. }
    ) H3 ~, p8 x0 l8 @/ W4 K$ g
17. 
    - t* _+ [/ d  D3 E
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    
19. {
    6 L8 K) O0 \, i/ _) Z
20.   uint16_t i;
    ( y- |. u7 e/ f9 `
21.   uart_dev_t *dev = uart_dev_get(channel);
    
22. 
    
23.   if(0 == dev)
    
24.   {
    
25.     return;
    
26.   }
    ( t6 t8 w$ M% x
27. 
    
28.   for(i = 0; i < length; ++i)
    
29.   {
    
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    
31.   }
    : e0 ?( Q, ]: l3 f1 x
32. }
    
33. 
    
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    & p) }/ _0 W2 s' Z2 u* m9 h# `6 I
35. {
    % S- L2 l2 R& n) T
36.   uart_dev_t *dev = uart_dev_get(channel);
    
37. 
    7 v$ j, D4 V( g: Q, P3 N& m/ ]
38.   if(0 == dev)
    
39.   {
    & r7 ]! ]5 [0 F1 [7 Y
40.     return 0;
    
41.   }
    
42. 
    & C$ k! v) x* j
43.   return UartQueuePop(&dev->send, c);
    
44. }
    
45. 
    
46. uint8_t UartRecv(uint8_t channel, uint8_t *c)
    
47. {
    7 B: Y  b! D- G8 O6 c/ a
48.   uart_dev_t *dev = uart_dev_get(channel);
    2 D6 r4 B" N$ C: S
49. 
    
50.   return UartQueuePop(&dev->recv, c);
    5 d  F, Y& t4 Z  L2 t) A8 G
51. }
    , g1 w9 v0 K( d
52. // 这里我没有使用串口的回调函数。
    
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    " `. H* f+ Z  j: z: @5 w0 L
54. void UART1_IRQ_FUNC(void)
    # b3 |6 O9 `/ r& H
55. {
    ! `4 K- C* t; h: Y6 N4 ^) Q# J
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);
      p- _) Q3 B$ ~% p- B# y
59.     UartQueuePush(&uart1_dev.recv, uart1_dev.ret);
    
60.   }
    # x$ _4 o2 s2 n/ V1 i( T4 Y
61. 
    
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    
63. }
    
64. 
    9 s1 e. i8 U* \7 a4 u1 Z. u
65. void UART2_IRQ_FUNC(void)
    7 b7 e' i  Y- G; X  b
66. {
    
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    6 I2 }, {, O1 u3 |) R
68.   {
      N& U$ S* O# L9 F+ `
69.     HAL_UART_Receive(&uart2_dev.handle, (uint8_t *)&uart2_dev.ret, 1, 1000);
    
70.     UartQueuePush(&uart2_dev.recv, uart2_dev.ret);
    
71.   }
    
72. 
    
73.   HAL_UART_IRQHandler(&uart2_dev.handle);
    5 ]- I+ T: ~3 V- B
74. }</span></span>

复制代码

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

裸机：裸机就在while(1)中调用UartRecv扫描数据；
; c9 ~  P3 ^. e( l+ J- q" X
系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）

4 c* \: M& e- V- V2 b8 F串口队列可参考：串口队列
9 l- S6 |) `+ A" Q1 C' y1 T" r6 q
6 n% w) h/ G' [6 x9 {/ b( X

7 g" m, M) B1 Q8 v$ E5 i# U5 Y" y
- h2 R+ E* o* m" O! F5 q; j. |
1 s3 b- H& K/ Z" X, u, A