一、串口初始化过程
1、时钟使能；
$ m7 M: x! A( k$ p2 F/ n
2、GPIO初始化；
, y9 |; S9 i( a) X
1 C' }, t0 T" o  ]  |5 H( ^, K3、串口波特率设置；
3 Y  c$ z" o; P6 J
4、串口控制；
- _  X+ I3 _6 _7 ]3 m
5、数据发送与接收
2 U# `' m6 E# l
$ @0 u6 d+ F7 R
二、几个重要的串口函数
5 ?& V) W4 ?* m4 S, X0 h

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); // 串口初始化
     e" n( _$ G+ a3 i
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); // 串口接收
   / d6 F7 Z# W% a) P- c1 G
6. 
   ' c- F* Y) ^2 D
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   
8. 
   
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
   6 {2 C9 d7 h) h! c7 P9 P9 S
10. 
    ) k2 N. v6 f  F& G! v' c
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

9 i( `8 o2 P+ k% @: r三、几个重要的结构

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   , i. t' l) F4 Q
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   
3. typedef struct
   + i7 w. A8 Y6 j5 D" S- V7 W" i
4. {
   , ~* G+ W7 l  N4 m" o/ D
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   
6. 
   ( B/ U  `# n/ d9 o7 x2 n1 r
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   
8. 
   / a- s9 g6 u3 e* V6 B
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   
10. 
    6 ^) {2 p7 @) J( Q- \! P
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
    ( C3 X% w6 M4 v6 Q
12. 
    
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    + z) r) v( \% U( H" C6 R, U
14. 
    & r9 ^/ S' {# A) h: e% i) f6 |6 {3 {( B
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    
16. 
    
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    ( S- C* s7 }* R% ?+ q9 W" V! _5 L
18. 
    
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    ) I, q# V/ x, V) \" h' N  F# M' A7 p
20. 
    0 G$ o0 o) ~  S0 l
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    
22. 
    + d# ?9 ?5 A& _: E* ]
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    ' |$ I8 ~$ u% k/ C( O5 |7 n
24. 
    
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    + b% G- n5 V# P9 J: C
26. 
    
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
28. 
    % g3 J$ p1 h* n& D+ G
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    0 O5 X5 s! y" S: x8 A8 m
30. 
    % S5 v7 l6 A6 M% X8 ?
31.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    
32.                                                   and also related to Tx operations.
    ( s& |, y9 E+ P* u7 }1 ~5 Y! @" q
33.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
34. 
    % l/ e  p9 g! z8 ~$ I; l
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 */
    0 r; N2 H1 S" O/ ]8 O/ Z+ f4 s* ~
37. 
    7 y/ |3 ^" |+ @- z. @
38.   __IO uint32_t             ErrorCode;   /*!< UART Error code                    */
    
39. 
    
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   2 ], j! N$ \& |1 Z0 \) L
2. typedef struct
   
3. {
   
4.   __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
   " Y3 v: z# t( D# o, Z
5.   __IO uint32_t CR2;    /*!< USART Control register 2,                 Address offset: 0x04 */
   % G) ^& @& D7 r6 o4 W
6.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   - ?+ [+ e+ E9 l! `* x
7.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */                                               
   & H6 o9 c/ Y9 a# r! i) I+ t! G! ^+ S
8.   __IO uint32_t GTPR;   /*!< USART Guard time and prescaler register,  Address offset: 0x10 */
   
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 */
    + U  Z- p+ g; O3 h2 R9 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 */
    : ^! H# Y1 k# M- L$ A4 n! d) `
14.   __IO uint32_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    ; _- S9 j1 b# C( j4 y# f
15. } USART_TypeDef;

复制代码

1. // 设置串口的各个参数 波特率 字长 停止位 奇偶校验 收发模式 硬件流 过采样
   
2. // 字长：8位/9位
   3 L. ~7 o2 ?0 m$ p
3. // 停止位：1位/2位
   8 G  E% m( R7 E
4. typedef struct
   
5. {
   ' e$ A# M5 Q' K# w
6.   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
   
7.                                            The baud rate register is computed using the following formula:
   1 w& ^! [6 K; c, H+ K, I# i5 ]( ~6 m
8.                                            - If oversampling is 16 or in LIN mode,
   
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
   
10.                                            - If oversampling is 8,
    6 y" P% [( r, {
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    . w. N) @) h& @5 K1 a
12.                                               Baud Rate Register[3] =  0
    
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
    
14. 
    
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
    8 s2 \8 B3 R: V4 q$ L. f6 z+ U
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    ( m+ a1 `8 v) c: ?+ E! z
17. 
    0 R$ s. g0 B+ \8 T0 T$ W  c8 c
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    
19.                                            This parameter can be a value of @ref UART_Stop_Bits */
    
20. 
      S  u3 L5 ~2 L
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
    " N  G* |$ a& g$ i, @  z& Q
24.                                                  at the MSB position of the transmitted data (9th bit when
    4 r$ d- n' Y6 o, ^; e
25.                                                  the word length is set to 9 data bits; 8th bit when the
    
26.                                                  word length is set to 8 data bits). */
    0 i- y+ S: f; r% K. c% \! p. G1 X6 W
27. 
    
28.   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
    4 u; g/ q, J. H$ g: i* Q) L% F
29.                                            This parameter can be a value of @ref UART_Mode */
    : E! J# U( v1 s- a1 A
30. 
    % y% w$ o; l  ^( T
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    3 J' K, \- z. N/ U! ]" L; L) r0 Y
32.                                            or disabled.
    " Z+ K" Q+ j# R
33.                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
    % L1 J) \; Z) ?" ^7 I
34. 
    
35.   uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8).
    . b- V& M3 V2 j8 X* n& c# C5 {; K
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.
    
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;

复制代码

四、基本接口设计
4 u1 K+ i  Y! d: t/ j& j我们使用中断接收，普通发送。中断接收到的数据放入队列中，在外部可配置每路串口的功能。

0 G. o# F! x) d( U) Y7 O  W% \, V  g

1. // 抽象出一个串口设备结构体
   
2. typedef struct
   
3. {
   % S) T1 u5 t; v8 h
4.   UART_HandleTypeDef handle; // 串口句柄
   0 x  m$ K7 g! b9 g( g
5.   uart_queue_t recv;         // 接收队列
   + _) o( J- I) B3 ~# x) j
6.   uart_queue_t send;         // 发送队列
   4 L) A6 p  e& w$ }, Q" j3 l
7.   uint8_t ret;               // 接收的值
   
8. } uart_dev_t;
   ' v  I& Y& h& l" k$ \. O# G; C
9. 
   1 t) A. B- t" U) X
10. static uart_dev_t uart1_dev;
    - r7 K% w2 K: o( Q: O" b* c6 E5 W
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
   4 q1 [8 i  k% J- Y7 j9 X& U7 a
2. typedef enum
   1 [0 ^) j0 c; `7 V
3. {
   : {$ @( W6 M% z( W6 b' c
4.   UART_CHANNEL_NONE,
   . Q3 C; ?( ~' Y3 }
5.   UART_CHANNEL_1,
   
6.   UART_CHANNEL_2,
   & V  P( J# D# y! E' A8 O
7.   UART_CHANNEL_NUM
   
8. } uart_channel_t;
   
9. 
   ( k( K, u2 O# ~4 |  v. R/ w/ ]  h
10. // 宏定义串口的基本信息 之所以这样写，方便移植修改
    ( m' R. w+ ^( s. j' s
11. #define UART1_CHANNEL             USART1
    6 n3 K" H& X9 ]# u: Y
12. #define UART1_PREEMPT_PRIO        UART1_PRIORITY
    + a' |) S/ X, l3 o# I
13. #define UART1_IRQ                 USART1_IRQn
    
14. #define UART1_IRQ_FUNC            USART1_IRQHandler
    9 d5 p  }  H4 A! J
15. #define UART1_CLK_ENABLE()        __HAL_RCC_USART1_CLK_ENABLE()
    
16. #define UART1_TX_PORT             GPIOA
    
17. #define UART1_TX_PIN              GPIO_PIN_10
    / L8 _+ Q- d5 }% a
18. #define UART1_TX_AF               GPIO_AF7_USART1
    0 J0 H# W! y* u  |
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
    - m& I# e! m7 @/ V7 D
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)
    
24. 
    
25. #define UART2_CHANNEL             USART2
    6 l) T* a; {% E# P; B
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    
27. #define UART2_IRQ                 USART2_IRQn
    . y: }5 O; ^! E: D& Z# L
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    7 Z: t! A# U% ]" `
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    - P" t& ~- @; C$ P9 ^" x
30. #define UART2_TX_PORT             GPIOA
    
31. #define UART2_TX_PIN              GPIO_PIN_2
    : Z  p* P4 T2 y! s- u- P
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)
    
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. // 串口的基本操作
   
2. // 串口1
   
3. static void uart1_var_init(void)
   9 Q6 Y  ]" S" n8 {# \' {2 ?3 P
4. {
   
5.   uart1_dev.recv = uart1_queue_recv;
   
6.   uart1_dev.send = uart1_queue_send;
   
7. 
   
8.   UartQueueInit(&uart1_dev.recv);
   
9.   UartQueueInit(&uart1_dev.send);
   ) x$ W; q% `) Q' m
10. }
    3 \% N, w' d7 \0 z1 @2 q
11. 
    / [% k0 p8 Z2 E" y8 ]4 Y
12. static void uart1_gpio_init(void)
    % r+ D+ o; o9 m' w; N0 e
13. {
    , w1 z- @" b- L3 J
14.   UART1_RX_CONFIG();
    3 v! ^$ D. A3 o
15.   UART1_TX_CONFIG();
    
16. }
    
17. 
    / Y- z, Y! H1 {
18. static void uart1_mode_init(uint32_t bound)
    # f3 e+ R5 E2 t; x) P( x% e
19. {
    " z* f. B  e2 E# ?! i2 T9 U- W
20.   UART1_CLK_ENABLE();
    ) N# y/ T2 X; @* F) i
21. 
    / p0 N, l4 D) Y: h0 ^' N
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;      // 一个停止位
    " L. A1 ~* f5 L- l, K9 }9 ^' N
26.   uart1_dev.handle.Init.Parity = UART_PARITY_NONE;       // 无奇偶校验位
    ) @3 Y" _; B' u$ s0 ]( U4 a
27.   uart1_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 无硬件流控
    
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    
30. }
    
31. 
    
32. static void uart1_nvic_init(void)
    ( Y" W7 G2 b0 z: y
33. {
    
34.   HAL_NVIC_SetPriority(UART1_IRQ, UART1_PREEMPT_PRIO, 3);
    7 O. N# N8 O3 g( ?: x
35.   HAL_NVIC_EnableIRQ(UART1_IRQ);
    
36. 
    ) S: P$ n, k( A. h
37.   __HAL_UART_ENABLE_IT(&uart1_dev.handle, UART_IT_RXNE);
    : f. J" S8 ~' M" D  k
38. }
    
39. 
    % A4 s$ Y# y( F( p( A
40. // 串口2
    
41. static void uart2_var_init(void)
    
42. {
    
43.   uart2_dev.recv = uart2_queue_recv;
    
44.   uart2_dev.send = uart2_queue_send;
    
45. 
    + {4 b$ L! f' A6 c$ A6 O, \
46.   UartQueueInit(&uart2_dev.recv);
    
47.   UartQueueInit(&uart2_dev.send);
    8 a6 d6 O4 U9 n  u% E
48. }
    % B, q4 o( E: r. A; y3 Z
49. 
    1 p9 R/ E. O& [9 f5 |
50. static void uart2_gpio_init(void)
    3 y$ o- Y/ E# g* b: I
51. {
    
52.   UART2_RX_CONFIG();
    
53.   UART2_TX_CONFIG();
    
54. }
    0 h# c# d6 u+ Z! H% X! `  B
55. 
    
56. static void uart2_mode_init(uint32_t bound)
    8 U' U1 ]% E( ?
57. {
    
58.   UART2_CLK_ENABLE();
    8 K( Q6 g7 s7 \' ^% w
59. 
    
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    % I% F/ P! l7 w4 u: E4 Y9 c
61.   uart2_dev.handle.Init.BaudRate = bound;
    * t# G5 e: e6 n/ I# Q* y. U3 S- V
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;
      l4 u2 m2 U, j, z3 i: g
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);
    3 @$ H6 }4 A4 u  g" ]. X) q
68. }
    1 h. g% I: O! m  t! V1 }
69. 
    * g/ w  n4 y7 L/ H+ A' |  s+ w! a
70. static void uart2_nvic_init(void)
    1 d* Q' u; p7 f, k8 Z
71. {
    
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    3 k* f+ A1 ?3 P, U% G" ~
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    : B# E+ Z. @4 l0 a1 z1 h
74. 
    
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    ( Y! j; b* i: ~
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
   
2. // 定义一个串口的列表
   $ [& ?8 ?( [- G8 M7 V: Y
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   + ]( B, n: e6 V' f
4. typedef struct
   
5. {
   ! h  D) r4 Q0 k5 o3 f: T
6.   uint8_t channel;
   
7.   uart_dev_t *dev;
   0 j1 O+ p+ s" M  Q, U
8.   void (* var_init_cb)(void);
   4 Z/ Y+ G7 `7 E: s# q( q" m
9.   void (* gpio_init_cb)(void);
     n0 g) r/ Y$ U
10.   void (* mode_init_cb)(uint32_t bound);
    & d  c4 t9 A5 A0 u
11.   void (* nvic_init_cb)(void);
    
12. } uart_config_t;
    
13. 
    9 A6 \) w1 ~, c7 r1 f) V# {% Z$ k
14. static const uart_config_t uart_configs[] =
    4 }' l- i' e4 w  E
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},
    3 m; @1 I1 L0 c6 v; K" Q% o& B, @
18. };
    
19. 
    0 G+ I- O/ B5 j( \9 |7 E- V
20. static uart_dev_t *uart_dev_get(uint8_t channel)
    
21. {
    
22.   uint8_t i;
    3 g$ B! S5 n9 I* t8 L
23. 
    
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
25.   {
    
26.     if(uart_configs<i>.channel == channel)
    
27.   </i>  {
    6 L. t) r6 }+ e9 s
28.       return uart_configs.dev;
    
29.     }
    6 h1 f2 W9 j9 q+ W- n& c( h
30.   }
    
31. 
    ) n1 j/ _4 n2 m9 s# K$ `8 t& N, j- a
32.   return 0;
    
33. }
    
34. 
    9 I- J9 C5 q& V( L4 S
35. static void uart_var_init(uint8_t channel)
    & G2 h5 X& E  R: C% g6 T! s
36. {
    
37.   uint8_t i;
    " D, M  J+ z$ B, a3 ]. @
38. 
    * ]3 T/ \" E7 ?, b! Z5 q+ k
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
40.   {
    
41.     if(uart_configs.channel == channel)
    " f" }) G/ E( n  Z( c
42.     {
    
43.       uart_configs.var_init_cb();
    / j0 C) K+ |) i
44.       break;
    
45.     }
    3 `2 u1 ]& |! f) `
46.   }
    
47. }
    " Z3 ~1 g: k2 n" A) l
48. 
    ; a+ U4 Q2 i! l' g
49. static void uart_gpio_init(uint8_t channel)
    % k0 X- D2 M( Z& n1 r7 D% Y- I
50. {
    ! _& ]3 C4 {6 @
51.   uint8_t i;
    + c/ ^- V/ M7 `1 W
52. 
    ' S. x/ U3 r( J
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
54.   {
    
55.     if(uart_configs.channel == channel)
    
56.     {
    3 D8 H- A; m. N5 q9 @0 Q
57.       uart_configs.gpio_init_cb();
    9 I# R: L) J/ k- P" n
58.       break;
    $ P$ U( O, f' T5 g6 ?1 m6 t# ?
59.     }
    
60.   }
    ' A- @& T& N) f# W# h& m
61. }
    
62. 
    3 O6 \3 W0 \. X" ~" _; ^9 D  T6 ?
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    
64. {
    
65.   uint8_t i;
    
66. 
    , Z( _- Y8 c7 }+ o- n' v' b6 e
67.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    8 S  o2 e6 g: J
68.   {
    
69.     if(uart_configs.channel == channel)
    % n6 S3 y2 F3 n2 u) P/ z! f  o2 j
70.     {
    ( t# N6 C# k3 ]
71.       uart_configs.mode_init_cb(bound);
    8 b9 c, q  i% n7 [
72.       break;
    2 n: |! t) _$ J6 q2 ]: n
73.     }
    7 S0 ^8 z  X/ J- E+ O9 s
74.   }
    4 G1 g: V$ H4 B
75. }
    
76. 
    5 G: T) ]3 C. t: ?1 D- T9 G
77. static void uart_nvic_init(uint8_t channel)
    
78. {
    
79.   uint8_t i;
    3 o5 m% t: l6 G$ F* L1 y, Y3 g  M
80. 
    . {3 A; F- }' {( z3 ]. E
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
82.   {
    
83.     if(uart_configs.channel == channel)
    0 r, I  m5 ^- P8 p1 L
84.     {
    8 n! Q" u' S; u
85.       uart_configs.nvic_init_cb();
    : i8 Q1 _, B9 `9 R3 ?9 l
86.       break;
    / \( G5 b6 V  M2 c7 c" S
87.     }
    
88.   }
    
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   % B2 L' S/ u% Y, Y, F' F% ^
2. // 初始化函数，同步发送 异步发送 接收处理
   1 o4 q5 N9 a1 N; D
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);
   8 X& Y5 M& @2 {2 J0 K0 o3 y. N
9. }
   4 `2 ^9 M' Y, @' n, P
10. 
    ! j+ D( {4 D9 o$ i8 k* [
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
    
12. {
    
13.   uart_dev_t *dev = uart_dev_get(channel);
    
14. 
    # k% n" _8 L# p6 W* |+ J4 O6 Z
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    ' g9 n, D3 l, t& b( R  m. G
16. }
    1 N4 z1 l7 g6 K5 F
17. 
    4 C( x4 `. p" k4 U/ Z9 |2 [
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    $ K" Q. S  f) n; A) t* F
19. {
    - N- U+ w4 o, K% a$ F0 \# ?
20.   uint16_t i;
    
21.   uart_dev_t *dev = uart_dev_get(channel);
    
22. 
    
23.   if(0 == dev)
    1 B& D; k; C* q. C5 J: }/ V& x
24.   {
    
25.     return;
    
26.   }
    . q* e9 \/ K( g! V' I( r0 F
27. 
    % j  X/ w' k/ {7 T
28.   for(i = 0; i < length; ++i)
    8 X) S( L6 M% S1 R9 y
29.   {
    
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    + K5 |( J6 u$ X
31.   }
    
32. }
    - ]; r$ b0 @; f0 {, |9 G3 Z. _0 e, a
33. 
    ) H" D2 D; Z* q% S5 e8 x$ i
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    
35. {
    1 j7 k0 n0 }8 v
36.   uart_dev_t *dev = uart_dev_get(channel);
    + O( ?& h" |/ [4 o& h8 D
37. 
    8 {( Z! H, x( A+ w4 X% q1 j
38.   if(0 == dev)
    
39.   {
    
40.     return 0;
      H1 e1 Y0 o9 t+ C7 O4 U
41.   }
    $ N$ a/ `' ~& p! Z( h
42. 
    . E. b4 k5 J& m1 Z& C( c) E
43.   return UartQueuePop(&dev->send, c);
    
44. }
    ) h7 y0 S! @; s1 l6 |
45. 
    8 Y6 e; y2 r3 Q. X( }# r7 W
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);
    
51. }
    
52. // 这里我没有使用串口的回调函数。
    6 T& b( O8 Z! L: E; x3 e3 T( T+ q
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    
54. void UART1_IRQ_FUNC(void)
    
55. {
    
56.   if(__HAL_UART_GET_IT(&uart1_dev.handle, UART_IT_RXNE) != RESET)
    0 x% r! U+ c8 g* b* V
57.   {
    
58.     HAL_UART_Receive(&uart1_dev.handle, (uint8_t *)&uart1_dev.ret, 1, 1000);
    
59.     UartQueuePush(&uart1_dev.recv, uart1_dev.ret);
    
60.   }
    - ^9 D* Q# Z+ E! _- `+ L$ D8 m
61. 
      \6 g* r) V( q1 E
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    - V/ \, I! p9 l7 y/ Z: P1 p+ A
63. }
    1 a% k3 K7 M2 ]
64. 
    
65. void UART2_IRQ_FUNC(void)
    
66. {
    ) w3 M0 f4 g9 o
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    * r% B, E; z5 E! h
68.   {
    
69.     HAL_UART_Receive(&uart2_dev.handle, (uint8_t *)&uart2_dev.ret, 1, 1000);
    + z7 w+ z. p2 b) o' \
70.     UartQueuePush(&uart2_dev.recv, uart2_dev.ret);
    4 `) p  [& C: ]# q1 g
71.   }
    6 |& }4 C$ k+ {# h& U; p; F
72. 
    
73.   HAL_UART_IRQHandler(&uart2_dev.handle);
    ) N6 w5 e9 p4 V0 d1 e: B
74. }</span></span>

复制代码

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

裸机：裸机就在while(1)中调用UartRecv扫描数据；

# [9 z6 P, Q; y& E系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）

  n% ^$ r+ E% H$ x串口队列可参考：串口队列

( c0 {" S) T: k+ O+ ^2 M/ B


7 v1 G7 y+ O2 m. g
" \* ]3 D- r8 `* o# a: c