一、串口初始化过程
! P+ @. Y, [7 y- ?3 K& Y) G3 \1、时钟使能；

2、GPIO初始化；
: x& Y+ f: p7 r
$ s0 e/ F, v  S3、串口波特率设置；
2 P3 r/ a! x2 B$ P2 T
4、串口控制；
% L6 d- U# i; m* k1 }5 [0 z! Q+ r
. Z+ [8 o  a# P/ ]5、数据发送与接收
& ~% ?4 m3 d) C  f5 l/ ~; _! l2 k

. F' O) d$ W8 |" R, I二、几个重要的串口函数

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); // 串口初始化
   
2. 
   0 v6 y+ C' ]* q. Z: G, y% t
3. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口发送
   % n! A1 A& r2 M0 T; |9 o
4. 
   
5. HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 串口接收
   
6. 
   
7. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)  // 串口中断使能
   % V1 @* ?) p6 `* i; f- S/ S" n
8. 
   ) G8 v# o) O1 c1 z
9. void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority); // 设置中断优先级
   8 p9 `/ t; V3 {( _6 |
10. 
    ' t$ ^: t# n4 E8 B( \
11. void HAL_NVIC_EnableIRQ(IRQn_Type IRQn); // 使能中断

复制代码

三、几个重要的结构
" |5 ], m, }9 G+ W8 D+ o

1. // 串口初始化结构体 包含了串口句柄 波特率配置 发送接收缓存 dma等
   8 v( P6 A  w% ^. Z2 n. }
2. // 我们只描述前两个基本功能，对效率要求极高可以使用DMA。
   7 @$ u1 g3 M& R
3. typedef struct
   3 O7 S. M; o) Y& W6 W" ~" p+ f
4. {
   ; ]  P/ Z, b' x
5.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   
6. 
   8 b$ d* H4 @, i$ j8 g- b
7.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
     f6 o+ E. i/ J% S) b' p: ?; R
8. 
   9 t) q7 X" U6 ?2 b3 j% T
9.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   
10. 
    7 r' q. Y2 G) L" [
11.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
    
12. 
    
13.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    
14. 
    
15.   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
    
16. 
    ' K/ w: C2 T1 r5 u( a  y( x9 g
17.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    
18. 
    
19.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    
20. 
    
21.   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
    
22. 
    
23.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    
24. 
    . V7 ]5 e* [0 B
25.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    * I% ]3 }1 X" M2 [% X. m
26. 
    
27.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
28. 
    
29.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    
30. 
    7 e# j7 E3 Z4 l" n
31.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    " U' h, j) v+ n
32.                                                   and also related to Tx operations.
    
33.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
34. 
    , z% k$ l0 R+ T- |2 w2 ?( c
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. 
    5 n/ E7 E" L# M# a# Z
38.   __IO uint32_t             ErrorCode;   /*!< UART Error code                    */
    " O& \7 y3 f+ Z3 q5 h6 S
39. 
    
40. }UART_HandleTypeDef;

复制代码

1. // 串口的操作句柄 如 USART1 USART2 USART3等
   ' r. P6 m* ]; v" n2 T  y2 i9 I$ Y+ B
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 */
   ' A1 Q6 n" l4 P7 u$ I! x2 C
6.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   
7.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */                                               
   9 r; H' Z2 W! x  r* V7 |
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 */  
   & z6 \3 A; ^5 g! d
10.   __IO uint32_t RQR;    /*!< USART Request register,                   Address offset: 0x18 */
    
11.   __IO uint32_t ISR;    /*!< USART Interrupt and status register,      Address offset: 0x1C */
    $ g) F9 v/ h+ P3 S$ d& Y
12.   __IO uint32_t ICR;    /*!< USART Interrupt flag Clear register,      Address offset: 0x20 */
    + N! S7 V8 p$ k# c+ w  x7 {3 X! f
13.   __IO uint32_t RDR;    /*!< USART Receive Data register,              Address offset: 0x24 */
    4 _% X; Y3 k# ~& Z; ]. A
14.   __IO uint32_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    5 k4 ], ]% O9 k3 T9 E
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.
   
7.                                            The baud rate register is computed using the following formula:
   & n3 m' A9 f3 C/ v
8.                                            - If oversampling is 16 or in LIN mode,
   
9.                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))
   4 i2 O2 [0 f  b; K
10.                                            - If oversampling is 8,
    7 |8 s* Z6 u" A8 S. e. t2 `# O
11.                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]
    
12.                                               Baud Rate Register[3] =  0
    - I3 s" W$ R% B1 T" a4 c3 ]
13.                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */
    
14. 
    3 Q: x, T8 c6 w! W
15.   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
    ! z( q! M5 p; ]' z/ ?9 M/ L, r
16.                                            This parameter can be a value of @ref UARTEx_Word_Length */
    ' p, R, k; A6 m/ E/ \1 q
17. 
    
18.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
    * H  s6 r. P% L3 i+ |5 m4 x
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
    : P0 c! @3 L5 ^4 P. M) {" a
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
    
26.                                                  word length is set to 8 data bits). */
    : M- C$ i7 ?1 H, C' B
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 */
    + ?  x# ^$ c4 s9 ]$ B7 y
30. 
    9 ~8 }" [' f- G+ W2 K
31.   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
    
32.                                            or disabled.
    
33.                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
    + w! n* K5 Z/ J1 k! S. n" G" ]
34. 
    " B% q0 f( J( k/ U1 A2 Q
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. 
    $ J! \9 L0 T/ U; J& B
38.   uint32_t OneBitSampling;            /*!< Specifies whether a single sample or three samples' majority vote is selected.
    3 p' E$ ~; \) O6 x! i
39.                                            Selecting the single sample method increases the receiver tolerance to clock
    3 N& m) ?) ]' i- x+ [% T
40.                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling */
    
41. }UART_InitTypeDef;

复制代码

四、基本接口设计
" S$ k. @+ l6 n" J我们使用中断接收，普通发送。中断接收到的数据放入队列中，在外部可配置每路串口的功能。
$ s1 Y( t2 y$ `/ [

1. // 抽象出一个串口设备结构体
   : Q" Z% v- B* A+ _8 `
2. typedef struct
   9 k  M/ L& ]; N: {8 L" i/ W0 u1 `) D0 W; o
3. {
   . R& {3 B1 E3 h1 I
4.   UART_HandleTypeDef handle; // 串口句柄
   
5.   uart_queue_t recv;         // 接收队列
   ! W- Y$ J( o, k5 i$ C' d& |  H
6.   uart_queue_t send;         // 发送队列
   
7.   uint8_t ret;               // 接收的值
   
8. } uart_dev_t;
   * i' l8 [1 |& j0 O1 J
9. 
   ( |3 O; H* ~6 S7 x$ M6 u/ ^
10. static uart_dev_t uart1_dev;
    
11. static uart_dev_t uart2_dev;

复制代码

1. // 对外只有通道 不再包含USART1...
   
2. typedef enum
   8 V. [) b) N+ j9 g+ ^
3. {
   
4.   UART_CHANNEL_NONE,
   ; Z% M9 L. @* g, y0 O3 _) ~9 L
5.   UART_CHANNEL_1,
   
6.   UART_CHANNEL_2,
   
7.   UART_CHANNEL_NUM
   
8. } uart_channel_t;
   * q( n, k3 O0 M/ u
9. 
   : w$ ~$ L3 d* W
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
    0 E0 w6 V2 D9 m6 z
15. #define UART1_CLK_ENABLE()        __HAL_RCC_USART1_CLK_ENABLE()
    
16. #define UART1_TX_PORT             GPIOA
      N0 X, B3 a; U
17. #define UART1_TX_PIN              GPIO_PIN_10
    
18. #define UART1_TX_AF               GPIO_AF7_USART1
    ( y- T. L! ^5 D" K: `. w  f
19. #define UART1_TX_CONFIG()         GPIOConfigExt(UART1_TX_PORT, UART1_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, UART1_TX_AF)
    , ~: N4 s; z3 O3 X: n
20. #define UART1_RX_PORT             GPIOA
    
21. #define UART1_RX_PIN              GPIO_PIN_9
    + e: r0 M. c" V. E5 Q
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)
      \7 A, n7 _; @$ ]: m
24. 
    ! p& ]$ M" m8 K; ?
25. #define UART2_CHANNEL             USART2
    ) e0 e: {( r7 d6 `0 a6 r  J1 o; v
26. #define UART2_PREEMPT_PRIO        UART2_PRIORITY
    1 Z$ J% S- f6 v3 k9 X
27. #define UART2_IRQ                 USART2_IRQn
    
28. #define UART2_IRQ_FUNC            USART2_IRQHandler
    ) c( x/ S$ s5 ^' S* k! L
29. #define UART2_CLK_ENABLE()        __HAL_RCC_USART2_CLK_ENABLE()
    
30. #define UART2_TX_PORT             GPIOA
    
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)
    8 J, A" `" o6 ^& ]: F
34. #define UART2_RX_PORT             GPIOA
    5 @4 Y/ N3 }  t* Z
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. {
   : r6 l5 g6 }0 j; L$ u8 a0 P
5.   uart1_dev.recv = uart1_queue_recv;
   6 J8 \% j( b% [- K6 U/ n
6.   uart1_dev.send = uart1_queue_send;
   , H& ?# P, y1 T" m3 y
7. 
   + r  a$ J3 Z% E# R6 g( X
8.   UartQueueInit(&uart1_dev.recv);
   6 o, r  P! T4 \, @/ j/ C, X
9.   UartQueueInit(&uart1_dev.send);
   
10. }
    
11. 
    
12. static void uart1_gpio_init(void)
    / l: b- ^6 o( E) G, x" ^
13. {
    
14.   UART1_RX_CONFIG();
    
15.   UART1_TX_CONFIG();
    - `9 M* g. |, t; Q( j$ l: V
16. }
    
17. 
    1 |" h! K; f7 Q7 o3 x$ k1 [
18. static void uart1_mode_init(uint32_t bound)
    
19. {
    , m, M; x* r; v2 a$ n; s$ ~6 ]" t+ ~
20.   UART1_CLK_ENABLE();
    * z% H/ ^4 p8 m/ }/ k3 m# |
21. 
    
22.   uart1_dev.handle.Instance = UART1_CHANNEL;
    5 q1 l$ a) i' O8 C
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;       // 无奇偶校验位
    
27.   uart1_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 无硬件流控
    ) `( o% s" _. o7 J! R6 f* ?2 f$ h
28.   uart1_dev.handle.Init.Mode = UART_MODE_TX_RX;          // 收发模式
    
29.   HAL_UART_Init(&uart1_dev.handle);                      // HAL_UART_Init()会使能UART1
    
30. }
    
31. 
    / R7 ~8 z  P/ T$ O- U: S  e
32. static void uart1_nvic_init(void)
    9 u- p9 z4 f$ d, {
33. {
    7 a; r! O* }9 w
34.   HAL_NVIC_SetPriority(UART1_IRQ, UART1_PREEMPT_PRIO, 3);
    
35.   HAL_NVIC_EnableIRQ(UART1_IRQ);
    
36. 
    ; i# q( z; ~' h( P$ ?/ f
37.   __HAL_UART_ENABLE_IT(&uart1_dev.handle, UART_IT_RXNE);
    
38. }
    
39. 
    ! s4 n; k9 t0 H9 `
40. // 串口2
    
41. static void uart2_var_init(void)
    3 O) L5 K; @: H# ?) E9 ~
42. {
    1 I, d8 W, ?! f/ E8 ^  q  T  r
43.   uart2_dev.recv = uart2_queue_recv;
    
44.   uart2_dev.send = uart2_queue_send;
    & j+ s  r; C# d9 g, T6 }
45. 
    
46.   UartQueueInit(&uart2_dev.recv);
    & Y+ |1 }8 \# Q  P
47.   UartQueueInit(&uart2_dev.send);
    * x8 @7 F' a- [* a6 c4 S7 y
48. }
    
49. 
    ) R1 y% p0 e/ v- ]
50. static void uart2_gpio_init(void)
    7 W' {8 t( Y; O) }" J* r  D4 N
51. {
    
52.   UART2_RX_CONFIG();
    + ^" u/ \7 d7 k: g5 a; F4 x- p
53.   UART2_TX_CONFIG();
    
54. }
    0 Z* P& P( ^2 |7 b* X
55. 
    
56. static void uart2_mode_init(uint32_t bound)
    8 h, k0 x+ m6 D8 u% p
57. {
    9 y3 ^, Q- ?- n+ q
58.   UART2_CLK_ENABLE();
    
59. 
    
60.   uart2_dev.handle.Instance = UART2_CHANNEL;
    
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;
    . t7 ^- O- M; \: O* }
64.   uart2_dev.handle.Init.Parity = UART_PARITY_NONE;
    ) q2 u$ u6 k' j5 i8 I
65.   uart2_dev.handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    ! i1 q% M( k. Y- t0 S# j  Q* t
66.   uart2_dev.handle.Init.Mode = UART_MODE_TX_RX;
    4 T; M1 h: T( R6 n
67.   HAL_UART_Init(&uart2_dev.handle);
    
68. }
    ( {$ h5 S( }+ g" ^9 j
69. 
    , p) Z* ~& E. }  L
70. static void uart2_nvic_init(void)
    
71. {
    3 y, A+ d8 U; P
72.   HAL_NVIC_EnableIRQ(UART2_IRQ);
    % ~3 D" t3 E. B3 W6 r, `5 \6 S
73.   HAL_NVIC_SetPriority(UART2_IRQ, UART2_PREEMPT_PRIO, 1);
    
74. 
    1 A& `6 P7 ^+ k5 [- _2 _9 D
75.   __HAL_UART_ENABLE_IT(&uart2_dev.handle, UART_IT_RXNE);
    ' c* Z3 c+ j: [
76. }

复制代码

1. // 抽象出一个初始化的结构体 每个串口都有的操作
   
2. // 定义一个串口的列表
   
3. // 下面的函数就是扫描列表 到这里为止，这些接口都是给内部使用的，外部文件用不到。
   : s: M" M% j# @
4. typedef struct
   
5. {
   
6.   uint8_t channel;
   
7.   uart_dev_t *dev;
   
8.   void (* var_init_cb)(void);
   & t- l$ ^+ n8 H* @, r
9.   void (* gpio_init_cb)(void);
   
10.   void (* mode_init_cb)(uint32_t bound);
    
11.   void (* nvic_init_cb)(void);
    
12. } uart_config_t;
    
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},
    0 s4 A, H& \$ V2 O* i
17.   {UART_CHANNEL_2, &uart2_dev, uart2_var_init, uart2_gpio_init, uart2_mode_init, uart2_nvic_init},
    5 x( t- M4 A& g  [7 ~
18. };
    
19. 
    5 x/ t: [6 `3 j: z6 w6 Y
20. static uart_dev_t *uart_dev_get(uint8_t channel)
    8 B8 ?2 k) F0 `; D7 G6 @1 s
21. {
      Q" i: k7 H7 U8 F$ y" b0 s/ k
22.   uint8_t i;
    + B+ }0 n' M% o6 V; h' n3 s) F
23. 
    
24.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    0 a' ^; }! p; V2 |1 D6 O. u
25.   {
    
26.     if(uart_configs<i>.channel == channel)
    ; X* ~9 a3 y+ Q
27.   </i>  {
    
28.       return uart_configs.dev;
    
29.     }
    , U( S& K. {( L% M7 {
30.   }
    7 D' m: p  g  x1 Z9 G" p9 ?/ X
31. 
    
32.   return 0;
    * O; B( g9 \- [- L
33. }
    
34. 
    
35. static void uart_var_init(uint8_t channel)
    
36. {
    . U6 ]! ~6 X5 [* c7 U
37.   uint8_t i;
    
38. 
    % s8 o$ [' h: l* G0 [! G
39.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
40.   {
    4 G. v( A- D" q
41.     if(uart_configs.channel == channel)
    
42.     {
    
43.       uart_configs.var_init_cb();
    
44.       break;
    
45.     }
    
46.   }
    
47. }
    
48. 
    
49. static void uart_gpio_init(uint8_t channel)
    
50. {
    
51.   uint8_t i;
    
52. 
    . d% t7 X" s6 z# l5 i9 p0 L, n
53.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    3 U( H2 K: A6 B( K
54.   {
    
55.     if(uart_configs.channel == channel)
    7 l. d; i8 i* G+ e$ M* i' W
56.     {
    
57.       uart_configs.gpio_init_cb();
    & _" J3 n- X6 U% A$ j- x
58.       break;
    & z# u/ Z! w1 c
59.     }
    , ]: e6 |: `9 E4 u( O- P4 J% q
60.   }
      g  L# T  c$ P
61. }
      J# Q: O, m# C! A7 X
62. 
    
63. static void uart_mode_init(uint8_t channel, uint32_t bound)
    
64. {
    ' h4 v1 l; X( X6 J4 E" u% J; R! O0 \
65.   uint8_t i;
    8 I3 u; _: Q' [+ |: b% w
66. 
    
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);
    $ ^- P5 u) X5 E5 i/ ?
72.       break;
    - ]  W, K" c& G: D
73.     }
    
74.   }
    ' _8 V$ O7 z3 _
75. }
    1 C' _1 f+ s* |
76. 
    
77. static void uart_nvic_init(uint8_t channel)
    
78. {
    ) _& X  z2 {! H/ v% P1 d
79.   uint8_t i;
    5 b6 C( w* `% Q# M; ~
80. 
    % P& x; E; d8 b
81.   for(i = 0; i < ARRAY_SIZE(uart_configs); ++i)
    
82.   {
    % _" O5 v7 g3 T7 T3 W3 y
83.     if(uart_configs.channel == channel)
    ' x: [" r8 D8 A; o
84.     {
    " a6 n3 F  r7 m" r
85.       uart_configs.nvic_init_cb();
    
86.       break;
    / m; e- _4 \* O1 m  S! W/ G
87.     }
    * |5 M4 ]) F$ l. ]3 l' n7 s5 H: y4 o0 e
88.   }
    / P- V; T2 S% L) P8 o" h. F
89. }

复制代码

1. // 这里的函数就是非常重要的了，都是给外部使用的。
   9 L- b+ F9 n5 u8 T* B
2. // 初始化函数，同步发送 异步发送 接收处理
   
3. void UartInit(uint8_t channel, uint32_t bound)
   9 r8 ^+ V$ ?; g* P, f% q% g
4. {
   
5.   uart_var_init(channel);
   # E- q2 L3 v6 e8 {
6.   uart_gpio_init(channel);
   3 \- x1 g& ~  ~8 Z9 |
7.   uart_mode_init(channel, bound);
   & ?; r' L7 I4 R, W( h' g
8.   uart_nvic_init(channel);
   
9. }
   
10. 
    + i2 ^( s0 n2 C! {2 l
11. void UartSendSync(uint8_t channel, uint8_t *buffer, uint16_t length)
    / e2 r! s3 S2 k
12. {
    6 }  q0 p1 j; B; t
13.   uart_dev_t *dev = uart_dev_get(channel);
    + X, @* L5 D& q
14. 
    
15.   HAL_UART_Transmit(&dev->handle, buffer, length, 10);
    : i0 k7 w: T$ O6 Q! K
16. }
      j+ L+ O! X. E0 @" P9 T
17. 
    
18. void UartSendWriteAsyn(uint8_t channel, uint8_t *buffer, uint16_t length)
    
19. {
    1 a/ u+ G) `4 o- @! d/ F
20.   uint16_t i;
      y* o7 t) X% P6 K$ m
21.   uart_dev_t *dev = uart_dev_get(channel);
    
22. 
    
23.   if(0 == dev)
    
24.   {
    9 F  C+ u$ O1 P# C: m1 \
25.     return;
    7 }9 c/ N4 N$ j! Q
26.   }
    / L2 Z% P* L& {' p! Z
27. 
    9 m% R% v* B/ `5 i  x5 Y
28.   for(i = 0; i < length; ++i)
    ( n" _6 Z) @" s! e3 ~
29.   {
    6 W4 C0 C; p9 }" o0 m6 x: f: I2 T
30.     UartQueuePush(&dev->send, buffer<span style="font-style: italic;"><span style="font-style: normal;">);
    / L+ i: K, }! _# i) N
31.   }
    * z9 w" K' n; ^$ M8 B. X2 o0 M
32. }
    7 S+ R0 y" D& b2 F4 N
33. 
    
34. uint8_t UartSendReadAsyn(uint8_t channel, uint8_t *c)
    + p' f4 f9 I4 _* a7 x) [! r5 A
35. {
    2 t# N5 @% C; R  [+ v; E4 k4 {
36.   uart_dev_t *dev = uart_dev_get(channel);
    3 m$ b+ M" }4 @5 f1 I" Y
37. 
    7 s" g7 @( d0 g( ]5 E: w6 ]5 |
38.   if(0 == dev)
    : M$ }2 e$ j* s2 t$ M, y
39.   {
    
40.     return 0;
    5 T, |3 |$ |4 E9 @' q$ C  O( B, _
41.   }
    - h1 D. I& Q" |% j
42. 
      f0 a$ K8 Z) c4 P, R+ L& ]
43.   return UartQueuePop(&dev->send, c);
    / O* u) x) X7 ?1 y, v9 J
44. }
    ) P1 l& g# z+ D! e$ ]. p7 ?
45. 
    
46. uint8_t UartRecv(uint8_t channel, uint8_t *c)
    - p, t) q" \- N8 b# S
47. {
    ' W5 \. i# W6 R* K0 j, N( k, [
48.   uart_dev_t *dev = uart_dev_get(channel);
    + g/ x9 Q8 X3 y  W, Q
49. 
    : P1 l" O8 Y+ z( Z: X
50.   return UartQueuePop(&dev->recv, c);
    % @9 S3 ]: `% H. b
51. }
    7 {9 |1 s. Q$ V4 {, T
52. // 这里我没有使用串口的回调函数。
    " _7 \6 e; h# q! H
53. // 中断服务函数 接收到数据就加入到队列中。在UartRecv读队列数据并处理。
    
54. void UART1_IRQ_FUNC(void)
    7 ~; f2 z( S) ]. Y( `$ w
55. {
    / r+ v- S) }! I+ f$ l* s5 C
56.   if(__HAL_UART_GET_IT(&uart1_dev.handle, UART_IT_RXNE) != RESET)
    $ l. }! Z# J1 o( s% j
57.   {
    3 g# R1 q  G0 H. L
58.     HAL_UART_Receive(&uart1_dev.handle, (uint8_t *)&uart1_dev.ret, 1, 1000);
    
59.     UartQueuePush(&uart1_dev.recv, uart1_dev.ret);
    ; i& K- V- T0 V
60.   }
    
61. 
    
62.   HAL_UART_IRQHandler(&uart1_dev.handle);
    2 D- C" c4 a- v/ z+ ?& ?" i; R! Y
63. }
    
64. 
    
65. void UART2_IRQ_FUNC(void)
    
66. {
    
67.   if(__HAL_UART_GET_IT(&uart2_dev.handle, UART_IT_RXNE) != RESET)
    ) @2 e) o9 M3 K% ^; o3 z& ^
68.   {
    & y0 c0 {5 f0 g% [3 L* T6 ~+ \. I% k
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);
    1 W3 w" D: K. ]! ?2 c* K
74. }</span></span>

复制代码

到这里，串口的初始化，发送，接收的接口就封装好了。
9 Z2 g" u/ H+ j
" \. }" s! |' c* v9 G* Z: ?裸机：裸机就在while(1)中调用UartRecv扫描数据；

0 v* g1 t$ b4 c7 Q( b系统：带系统就在任务中扫描并解析数据。（带系统可以使用信号量去同步数据 -- 这里只提出一种思路）
$ p( p: m2 b) Y, w* ]
串口队列可参考：串口队列




; y* ~+ Y0 \/ o  w0 `6 v) l( ~