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

' u+ w: A  f8 x3 W* n/ ^  T6 V2、GPIO初始化；

& C% m4 b0 n$ y, ?3、串口波特率设置；

8 ~  w+ L8 J: e7 }4、串口控制；

5、数据发送与接收


6 ?, I- Q5 n5 {/ p5 t3 n; j! N8 N二、几个重要的串口函数

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); // 串口初始化
   
2. 
   # J7 o: T+ l$ Y+ Z5 O+ v1 k" t
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); // 串口接收
     n1 R4 v# [7 J# x" `8 T- [# {
6. 
   / d/ K8 j9 I" d+ y4 @& Q0 I
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   ! u( i5 R4 t8 u- k/ e7 b, p
8. 
   2 \; O$ X" G  ?( [  {: j9 n) a7 u' I( i
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
   
10. 
    $ |" Z& C, y+ G* y) N+ X8 `) Y/ m
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

三、几个重要的结构

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   7 g( w6 n1 l- o$ D) Z# ^
3. typedef struct
   
4. {
   8 s5 X& u: @8 `
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   , e5 {. I; ?8 y* }& e- T
6. 
   
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   
8. 
   & z8 B' I* e9 H2 P7 ~5 x! {
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   
10. 
    
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
    7 O) F  z1 u' E% }
12. 
    7 E: @( t" o  ]: U1 e
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    : S) m0 P/ t) a  \3 U9 p
14. 
    ; x; S" q8 e/ O  d5 ]
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    8 t3 g3 }7 L' p, \
16. 
    
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    
18. 
    4 {/ }) {* L" D: B
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    
20. 
    
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    5 }! x  r+ G2 K' R4 V1 z
22. 
    
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
      |1 L6 m" G" q
24. 
    7 y: M+ ^7 l3 R& v
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    5 B0 F( b. M9 ~4 m1 P6 y/ K
26. 
    
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    . U& j1 v/ N. e  w
28. 
    
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
      R8 a! |( Q) _) P8 P4 w. h
30. 
    
31.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    9 |6 f) f8 W- g
32.                                                   and also related to Tx operations.
    
33.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
34. 
    9 l8 \8 F3 v* {
35.   __IO HAL_UART_StateTypeDef    RxState;     /*!< UART state information related to Rx operations.
    % d* C; i: ?+ @' o7 ?8 p
36.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
37. 
    7 |% q' Z% f8 U+ ?1 h* I0 y' L
38.   __IO uint32_t             ErrorCode;   /*!< UART Error code                    */
    0 P0 r3 j. ~# S+ h" j: D4 D8 a
39. 
    + |* J3 \: s  C6 N
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   , d. @/ e% z  n0 ^
2. typedef struct
   
3. {
   
4.   __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
   4 x7 i+ Z# L7 n( V+ D: M
5.   __IO uint32_t CR2;    /*!< USART Control register 2,                 Address offset: 0x04 */
   7 g! }& Y; ~2 U/ M2 j
6.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   0 _8 L' [; T& q- t
7.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */                                               
   1 s& i3 |/ }5 y
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 */  
   ) s& u" [9 @2 Q# P! O6 a
10.   __IO uint32_t RQR;    /*!< USART Request register,                   Address offset: 0x18 */
    
11.   __IO uint32_t ISR;    /*!< USART Interrupt and status register,      Address offset: 0x1C */
    # I% X) v6 X2 ~# G
12.   __IO uint32_t ICR;    /*!< USART Interrupt flag Clear register,      Address offset: 0x20 */
    " p, Y8 G6 L) S
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位
   * G' l7 K0 H- i8 s9 y# d# `5 p
4. typedef struct
   
5. {
   
6.   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
   . B/ S* f( i7 U/ ^
7.                                            The baud rate register is computed using the following formula:
   
8.                                            - If oversampling is 16 or in LIN mode,
   
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
   + {7 g" A/ j; _) K+ @; |% p# t
10.                                            - If oversampling is 8,
    9 y# }5 S$ L% e  g8 A' j% D) z
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    : O6 P( d  Y% g3 o' m5 b. n
12.                                               Baud Rate Register[3] =  0
    & U9 l' e; |9 F
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
      X! g( ]: ]2 y* S
14. 
    3 ^) Y8 Y) m& M
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
    
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    3 E) Q) o" n$ b6 p3 p& q1 S
17. 
    % O5 M  c1 X/ m& \+ E
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    * t/ A5 J7 M1 |) ~0 I$ Z
19.                                            This parameter can be a value of @ref UART_Stop_Bits */
    
20. 
    
21.   uint32_t Parity;                    /*!< Specifies the parity mode.
    ' @: e( k5 |' H2 {6 j3 c
22.                                            This parameter can be a value of @ref UART_Parity
    
23.                                            @note When parity is enabled, the computed parity is inserted
    $ q0 J2 ~: L6 C' |7 N% M( b
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
    ( U" h0 l" Y. b: P/ E4 N% v
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.
    6 w% M. N8 k3 w2 e6 B
29.                                            This parameter can be a value of @ref UART_Mode */
    
30. 
    
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    9 L- W! }+ I/ N2 @) P8 K
32.                                            or disabled.
    
33.                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
    4 h2 m  d0 s; M$ x( O
34. 
    $ ~" }' p; p! v, o' X" G3 D* |
35.   uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8).
    6 L' J# d# i$ D4 P# d' c7 W
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
    ! i; l6 ~0 C: j: d! m4 ^( m0 v, ^
40.                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling */
    & x- v& p4 D  U9 S. b
41. }UART_InitTypeDef;

复制代码

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

! R' i6 g8 f7 o

1. // 抽象出一个串口设备结构体
   
2. typedef struct
   * w7 ]; U* B% L! n( A2 Y' d( \9 b
3. {
   " G; A7 O  }, l9 T6 f& j* y- U
4.   UART_HandleTypeDef handle; // 串口句柄
   
5.   uart_queue_t recv;         // 接收队列
   
6.   uart_queue_t send;         // 发送队列
   8 Z- O9 P1 A% [. v0 C- d! w
7.   uint8_t ret;               // 接收的值
   1 {- t* s/ \' h! J+ ~5 N  _5 r  }% U8 ]
8. } uart_dev_t;
   # q. `2 _# o. N" O+ E; k% S4 U: p$ {
9. 
   
10. static uart_dev_t uart1_dev;
    
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
   8 a* i/ e' K/ A+ c- I
2. typedef enum
   % A: o2 A9 L7 v  K
3. {
   
4.   UART_CHANNEL_NONE,
   ) C5 ^  m2 ?+ \: ~+ R/ v' s) A$ r7 P
5.   UART_CHANNEL_1,
   
6.   UART_CHANNEL_2,
   0 L2 }, }4 _7 @3 m
7.   UART_CHANNEL_NUM
   5 P: N  Q  o4 L" k2 s* C4 `
8. } uart_channel_t;
   6 h) j3 j0 ?, w  v( _9 M4 B3 v
9. 
   ; }0 n6 ?0 o' {3 D* i" b! r
10. // 宏定义串口的基本信息 之所以这样写，方便移植修改
    
11. #define UART1_CHANNEL             USART1
    
12. #define UART1_PREEMPT_PRIO        UART1_PRIORITY
    3 U3 ]4 N% C$ V# p/ h& Z- y
13. #define UART1_IRQ                 USART1_IRQn
    
14. #define UART1_IRQ_FUNC            USART1_IRQHandler
    0 P5 z4 E7 g8 G6 Z7 c
15. #define UART1_CLK_ENABLE()        __HAL_RCC_USART1_CLK_ENABLE()
    # D0 n4 x0 `- ^
16. #define UART1_TX_PORT             GPIOA
    
17. #define UART1_TX_PIN              GPIO_PIN_10
    " _6 |, H. j0 s) Q( L- h% y9 v% K
18. #define UART1_TX_AF               GPIO_AF7_USART1
      ^' G/ @; c( X, Q  l* y
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
    + Y9 L5 j; o0 F; M, f7 H0 k
21. #define UART1_RX_PIN              GPIO_PIN_9
    
22. #define UART1_RX_AF               GPIO_AF7_USART1
    + Y) Z. {% S2 I* T) C- Q
23. #define UART1_RX_CONFIG()         GPIOConfigExt(UART1_RX_PORT, UART1_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_RX_AF)
    - O, {' _2 q" z1 r- c9 m
24. 
    
25. #define UART2_CHANNEL             USART2
    - }# S) ~3 p6 V- \  Z- p/ Y6 l
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    % ]0 U! p; C0 h9 N
27. #define UART2_IRQ                 USART2_IRQn
    5 z$ f% h* i7 e0 ^3 r" q2 g6 `6 r
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    3 E9 N; }9 x/ H  j8 |
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    
30. #define UART2_TX_PORT             GPIOA
    
31. #define UART2_TX_PIN              GPIO_PIN_2
    2 ]$ K1 n( C+ t$ s& L# g- i
32. #define UART2_TX_AF               GPIO_AF7_USART2
    - F- U6 Y' @; O$ O4 u
33. #define UART2_TX_CONFIG()         GPIOConfigExt(UART2_TX_PORT, UART2_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART2_TX_AF)
    * p% I0 T6 X  N% r% r/ j/ T% n
34. #define UART2_RX_PORT             GPIOA
    ; f! a8 x' H% {  ]( o' ]
35. #define UART2_RX_PIN              GPIO_PIN_3
    / L4 K6 Q% P0 y& h
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. // 串口的基本操作
   4 @9 R# f, K2 |9 J
2. // 串口1
   ! x( U% k, h9 }6 j) H- `' a
3. static void uart1_var_init(void)
   
4. {
   . t1 f% F! r- O; v5 _
5.   uart1_dev.recv = uart1_queue_recv;
   
6.   uart1_dev.send = uart1_queue_send;
   & ?' K3 g8 i. X. n! @! h
7. 
   ( ?8 U: F* |. f' P8 i, U. V7 u
8.   UartQueueInit(&uart1_dev.recv);
   
9.   UartQueueInit(&uart1_dev.send);
   3 @5 {3 ~( O( e7 H
10. }
    
11. 
    
12. static void uart1_gpio_init(void)
    7 c5 ]0 d7 ^* x  E/ [
13. {
    4 x9 ^4 K  l# J7 m" u  k. H5 M
14.   UART1_RX_CONFIG();
    
15.   UART1_TX_CONFIG();
    , f9 R( h' c* R2 M6 I9 z
16. }
    ; ^% B# h: P* P% F' U% L( F' `
17. 
    ( L' B) x/ F. d$ Z$ J
18. static void uart1_mode_init(uint32_t bound)
    
19. {
    ) O5 `* b, @  @& U" X
20.   UART1_CLK_ENABLE();
    
21. 
    - G. j5 A7 @! J7 G. ]
22.   uart1_dev.handle.Instance = UART1_CHANNEL;
    : T/ h" _# b  w* U1 e! m
23.   uart1_dev.handle.Init.BaudRate = bound;                // 波特率
    9 A6 Q0 L* O( k/ I
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;       // 无奇偶校验位
    
27.   uart1_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 无硬件流控
    + T9 b- t- I1 R( b) A8 _. B
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    , \' G- L( S3 Q5 A& \1 A0 O6 A
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    * n& G$ @6 W* Q6 ^: y! D( K
30. }
    - ?2 X# j: K) B. N' L, ]! x6 L+ d
31. 
    , b- b& D! u; v" G9 C4 S( w
32. static void uart1_nvic_init(void)
    
33. {
    ) l, ^% m7 d0 N+ A  w
34.   HAL_NVIC_SetPriority(UART1_IRQ, UART1_PREEMPT_PRIO, 3);
    
35.   HAL_NVIC_EnableIRQ(UART1_IRQ);
    8 k+ n1 N* ~1 ]) g2 \( ^4 U" `
36. 
    
37.   __HAL_UART_ENABLE_IT(&uart1_dev.handle, UART_IT_RXNE);
    
38. }
    , H: W" j" E$ E; }
39. 
    
40. // 串口2
    $ M; P0 ~9 ]" _! C
41. static void uart2_var_init(void)
    0 b2 @* G2 k  T' x- S
42. {
    
43.   uart2_dev.recv = uart2_queue_recv;
    
44.   uart2_dev.send = uart2_queue_send;
    
45. 
    
46.   UartQueueInit(&uart2_dev.recv);
    3 j5 m$ z( U5 m0 K! _! x/ N+ Y2 b4 n- |
47.   UartQueueInit(&uart2_dev.send);
    
48. }
    # O; W; S( ]. }/ i9 G
49. 
    ' v9 J) V3 \' ~& _
50. static void uart2_gpio_init(void)
    3 |5 M$ Q2 q; d" u4 `2 `, A
51. {
    3 ~+ N+ u, b1 e0 B6 |( x9 @; x
52.   UART2_RX_CONFIG();
    
53.   UART2_TX_CONFIG();
    
54. }
    
55. 
    
56. static void uart2_mode_init(uint32_t bound)
    
57. {
    0 I* z6 e. y# X2 E6 @) G
58.   UART2_CLK_ENABLE();
    
59. 
    
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    - ?- G- H* _1 t# b6 y2 y
61.   uart2_dev.handle.Init.BaudRate = bound;
    # I8 R% G, l1 |
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;
    ) X8 T% o9 \3 H9 I6 K- F
65.   uart2_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    $ |* g8 f" V) U5 B: P$ H. ?- {
66.   uart2_dev.handle.Init.Mode = UART_MODE_TX_RX;
    2 I' d/ ^  p+ N* Y/ F! f$ W" T
67.   HAL_UART_Init(&uart2_dev.handle);
    
68. }
    
69. 
    & s; ~- l9 u2 ^- _4 L
70. static void uart2_nvic_init(void)
    7 ~5 f& \% T$ \$ g0 Z0 y% L
71. {
    3 w, r+ b4 Y' v1 y' z  f" a
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    ( q- ]9 y7 r3 [2 T4 o8 g, K+ k
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    
74. 
    
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
   
2. // 定义一个串口的列表
   
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   8 o% {  P0 ?) N9 R& g* |
4. typedef struct
   / I$ [- H+ ?8 O; P' f
5. {
   2 V( p2 s' V3 c/ L! g3 A* N
6.   uint8_t channel;
   3 i: Y2 |. X( i6 d7 y$ r% m/ z
7.   uart_dev_t *dev;
   
8.   void (* var_init_cb)(void);
   
9.   void (* gpio_init_cb)(void);
   . \0 X+ D4 z( j/ L/ z  x
10.   void (* mode_init_cb)(uint32_t bound);
    # X) x" ]' c& r% e5 y/ T5 Z5 M6 ], D
11.   void (* nvic_init_cb)(void);
    1 {* P  z' E; D) z+ h
12. } uart_config_t;
    ; ]" m2 C, v: w  i8 ?
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},
    
17.   {UART_CHANNEL_2, &uart2_dev, uart2_var_init, uart2_gpio_init, uart2_mode_init, uart2_nvic_init},
    ( v  y0 v- n. s
18. };
    
19. 
    4 h8 Z2 l% V9 c, l5 j/ M
20. static uart_dev_t *uart_dev_get(uint8_t channel)
    
21. {
    ) s# V' P$ I9 F. C3 o& Y) W
22.   uint8_t i;
    
23. 
    - m- R- M5 s" Q! v, Y, L5 S5 _; o
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
25.   {
    ; B/ V& Z  ]) s% k  J
26.     if(uart_configs<i>.channel == channel)
    
27.   </i>  {
    
28.       return uart_configs.dev;
    4 j( ~" k1 U) r8 [( n
29.     }
    
30.   }
      N1 f4 F. O7 l0 l% }8 a
31. 
    
32.   return 0;
    , R5 q; q& k! N! v% r( v
33. }
    5 T3 |8 l3 ~; J/ B
34. 
    
35. static void uart_var_init(uint8_t channel)
    - ]$ m* ?3 R# ?8 H( g! W/ s
36. {
    
37.   uint8_t i;
    
38. 
    5 ?' N. f- l0 o
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
40.   {
    : t! Y+ Y1 B2 b8 Y; S' B$ b
41.     if(uart_configs.channel == channel)
    8 L" E2 s; P/ w, V0 w4 x2 X" N- E1 X
42.     {
    
43.       uart_configs.var_init_cb();
    
44.       break;
    . Z  ]5 Q5 D0 h( L( F) _4 R
45.     }
    
46.   }
    
47. }
    - w. p3 A$ [. ?' H9 ^
48. 
    / f1 ?  S- w" a4 y9 C" ^6 i
49. static void uart_gpio_init(uint8_t channel)
    5 z9 _' z# u. g% M" u
50. {
    ( g& Q7 D  E. [
51.   uint8_t i;
    6 s# ~, I' A; }0 z
52. 
    
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
54.   {
    9 w) x3 O7 ~9 L* x: L$ l# a
55.     if(uart_configs.channel == channel)
    . [0 q+ Q, W( O+ J+ B; T. s
56.     {
    . {: N/ p3 k; f! ?
57.       uart_configs.gpio_init_cb();
    & A, b5 ]" F& z6 m) M7 m$ h* k
58.       break;
    
59.     }
    % U  ]4 v1 [3 b8 T& J( ~
60.   }
    : S9 `& d. v% _
61. }
    ; l" u+ x' S5 w4 e- Z
62. 
    * |4 e1 B+ p3 S( P% _1 ^6 j
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    9 ^; q6 x# w- w- b+ O2 k
64. {
    * p" U* o+ d& j  Q* K" H
65.   uint8_t i;
    # ^  w+ E4 j3 @) k4 `5 O7 y
66. 
    5 F* v- ]# ]# C
67.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    1 G2 m! W; {. L3 Z$ s9 X1 U
68.   {
    ' N% |* Z  v* o1 I: D
69.     if(uart_configs.channel == channel)
    & ]) a$ s% O: J0 Z: H0 o2 Z
70.     {
    
71.       uart_configs.mode_init_cb(bound);
    
72.       break;
    
73.     }
    
74.   }
    , B7 [- f$ f5 i' q$ h3 K
75. }
    + U) i+ E2 u9 N! j* }
76. 
    % j4 ^6 O  S, a& _9 J
77. static void uart_nvic_init(uint8_t channel)
    
78. {
    
79.   uint8_t i;
    # j9 i5 ?+ b. Z9 L* t4 M
80. 
    & S7 Z! J# J) `6 g, |
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
82.   {
    $ S- R( R! O% L$ T
83.     if(uart_configs.channel == channel)
    
84.     {
    
85.       uart_configs.nvic_init_cb();
    
86.       break;
    3 o8 b: N* I/ X; M
87.     }
    
88.   }
    
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   5 J3 ]: a) p: B6 ?. q" Q3 Z8 z4 r3 d
2. // 初始化函数，同步发送 异步发送 接收处理
   
3. void UartInit(uint8_t channel, uint32_t bound)
   ' m6 I9 g; d& T7 X
4. {
   ) p4 W6 j8 E+ Y8 \
5.   uart_var_init(channel);
   
6.   uart_gpio_init(channel);
   
7.   uart_mode_init(channel, bound);
   : p; W+ P4 i, W0 j( D5 n
8.   uart_nvic_init(channel);
   
9. }
   
10. 
    - o' E0 g& Q* O
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
    
12. {
    3 @$ ]8 c  K; e. P# n: ?
13.   uart_dev_t *dev = uart_dev_get(channel);
    
14. 
    
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    
16. }
    & ]* [' M& f" d, f
17. 
    3 p3 @  R3 ]9 g8 [* {; l
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    
19. {
    
20.   uint16_t i;
    
21.   uart_dev_t *dev = uart_dev_get(channel);
    
22. 
    9 d+ ?$ F" `( @* u) n1 H, h2 h& m
23.   if(0 == dev)
    
24.   {
    - d  n! {, D8 `. I
25.     return;
    
26.   }
    
27. 
    5 P0 p, p, v5 ?5 T
28.   for(i = 0; i < length; ++i)
    
29.   {
    
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    
31.   }
    
32. }
    / g$ @) z( K/ \3 ~
33. 
    4 D. v( P( b$ w" J) i9 d& r0 i+ c
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    
35. {
    
36.   uart_dev_t *dev = uart_dev_get(channel);
    
37. 
    
38.   if(0 == dev)
    
39.   {
    
40.     return 0;
    3 f3 R. D5 \- Q6 X3 l4 F
41.   }
    ! ]5 z, I1 z  Z/ \. }7 ?: G: N
42. 
    
43.   return UartQueuePop(&dev->send, c);
    
44. }
    
45. 
    ' X1 h/ H$ n8 a+ N
46. uint8_t UartRecv(uint8_t channel, uint8_t *c)
    
47. {
    & D& E# t2 i* w( T
48.   uart_dev_t *dev = uart_dev_get(channel);
    ( s/ ?2 r: `' g, o% d
49. 
    : q0 N5 a3 `+ I  K8 B, I# m' Y3 l
50.   return UartQueuePop(&dev->recv, c);
    " }( }: a0 h; q; K/ J* y/ T! \
51. }
    
52. // 这里我没有使用串口的回调函数。
    
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    
54. void UART1_IRQ_FUNC(void)
    - ]: s+ O3 n, S
55. {
    . x! c; q# p% `) X6 r* T( I% B
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);
    
60.   }
    ; h6 [$ r9 k: N+ o( p6 F) S
61. 
    
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    : [; u7 }* F# [1 a; y; |
63. }
    5 e+ U1 X4 j5 B7 O( h
64. 
    
65. void UART2_IRQ_FUNC(void)
    ; G1 W; E/ i6 W! C. \4 @( I
66. {
    
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    
68.   {
    5 I4 K! n% x# k# ]( Z
69.     HAL_UART_Receive(&uart2_dev.handle, (uint8_t *)&uart2_dev.ret, 1, 1000);
    % _: e# R. k( r
70.     UartQueuePush(&uart2_dev.recv, uart2_dev.ret);
    
71.   }
    
72. 
    
73.   HAL_UART_IRQHandler(&uart2_dev.handle);
    , G4 V' n3 D4 J7 [" `! ~5 f# ~
74. }</span></span>

复制代码

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

裸机：裸机就在while(1)中调用UartRecv扫描数据；
4 X% K) l4 O: j0 o+ k2 h  v2 i
系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）
  _5 z3 @7 L7 f1 g1 g
% |7 V3 u. O, X串口队列可参考：串口队列
4 n4 D) L  }) H: |/ K  ?
* o$ T% G; h& p# t( l* D
. e2 K5 \: b+ w% Z& M. O

5 M2 k$ O) h1 k6 Y  O
3 J' \8 q9 ]. z3 S2 j' H# p4 E