单片机型号:STM32L051C8T6

开发环境MDK5.12

" C# W+ W/ G  h库版本:STM32L0xx_HAL_Driver V1.1.0
/ r( ]8 l8 e; s. @
主机环境:Windows XP
" D) x2 ^! q7 g" T9 ]" {; h
9 C9 ^; h" ]- _之前一直使用的STM32F030C8T6单片机来做开发，因需求更改更换了一个新型号STM32L051C8T6,主要是用到了其低功耗特性，本以为直接把代码拷贝一下就可以使用了，结果是太天真了，STM32F030C8T6使用的库是STM32F0_StdPeriph_Lib而STM32L051C8T6使用的库是STM32L0xx_HAL_Driver两者的差别还是很大的，而且官方也推荐使用后者，没办法，重新学习一下吧。。。参考其例程磕磕绊绊的勉强可以写一个工程了，这里写一下有关UART的调试。
8 \# ^. |9 `/ Z( }
5 J) A. `1 |8 X- m5 ^+ c参考的程序是STM32L053R8-Nucleo例程中的UART_TwoBoards_ComIT工程，采用中断方式来进行两个单片机之间的通信。STM32L0xx_HAL_Driver库的分层更加明显，板极初始化代码如下
; b0 A( c9 h" H9 s' \2 m
4 R0 B$ L$ N0 t2 g
1 Q) e- ?  d4 M7 L! I9 y6 J

1. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
   0 L" W! O) r( j# a" |
2. {  
   
3.   GPIO_InitTypeDef  GPIO_InitStruct;
   
4. 
   - l2 R" v* p5 G5 g2 K. p
5.   /*##-1- Enable peripherals and GPIO Clocks #################################*/
   4 B/ B! p; {0 q6 M$ |) `& b
6.   /* Enable GPIO TX/RX clock */
   ' T, h8 g0 N8 T, J8 T3 f
7.   USARTx_TX_GPIO_CLK_ENABLE();
   
8.   USARTx_RX_GPIO_CLK_ENABLE();
   0 e, l) G5 O2 y- X8 E0 {! g
9.   /* Enable USART1 clock */
   ; B8 b% J1 ^7 Z- ^5 s: h
10.   USARTx_CLK_ENABLE();
    ; A9 c! r  V: T/ J* V' A/ P3 ]
11. 
    7 ]% H0 P# t5 C$ T1 \
12.   /*##-2- Configure peripheral GPIO ##########################################*/  
    6 \5 p+ e0 M5 {/ r5 D  Z8 R- l
13.   /* UART TX GPIO pin configuration  */
    
14.   GPIO_InitStruct.Pin       = USARTx_TX_PIN;
    
15.   GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
16.   GPIO_InitStruct.Pull      = GPIO_NOPULL;
    
17.   GPIO_InitStruct.Speed     = GPIO_SPEED_HIGH;
    
18.   GPIO_InitStruct.Alternate = USARTx_TX_AF;
    * M' G, D. y/ X  @3 j
19. 
    
20.   HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct);
    - S% I- t( d1 J
21. 
    ! e. `* O9 H. B% O/ U7 M! ?: ?, t0 q! }
22.   /* UART RX GPIO pin configuration  */
    
23.   GPIO_InitStruct.Pin = USARTx_RX_PIN;
    
24.   GPIO_InitStruct.Alternate = USARTx_RX_AF;
    . q0 ?" _% b- K' g, @% m* a7 L
25. 
    ( N& @2 m3 F6 A2 U
26.   HAL_GPIO_Init(USARTx_RX_GPIO_PORT, &GPIO_InitStruct);
    + i# `3 P4 ~) f6 K- a+ d4 m
27. 
    3 @0 p  O4 n3 b* z
28.   /*##-3- Configure the NVIC for UART ########################################*/
    
29.   /* NVIC for USART1 */
    4 I1 r# Q1 |. n; D4 A3 C' H" R
30.   HAL_NVIC_SetPriority(USARTx_IRQn, 0, 1);
    
31.   HAL_NVIC_EnableIRQ(USARTx_IRQn);
    
32. }
    
33. 
    7 _- N9 m9 Z' T2 b1 Q( @% j' i% b
34. /**
    + ^5 o7 a/ \# Z8 M) A9 ?/ Z
35.   * @brief UART MSP De-Initialization
    ) E- |3 E6 ^" b" N3 @8 ]
36.   *        This function frees the hardware resources used in this example:
    + g+ o7 a7 X. @( c: P$ l) i
37.   *          - Disable the Peripheral's clock
    5 T" y* T. Z5 t$ H
38.   *          - Revert GPIO and NVIC configuration to their default state
    ( A% J4 w! |- k- z. ^6 m3 a
39.   * @param huart: UART handle pointer
    . Y8 d+ |! I" n1 K  N, H
40.   * @retval None
    
41.   */
    
42. void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)
    
43. {
    ; Z. U. ?( Q8 Q( K
44.   /*##-1- Reset peripherals ##################################################*/
    ! g$ [8 G3 V1 b2 D# d1 S
45.   USARTx_FORCE_RESET();
    
46.   USARTx_RELEASE_RESET();
    
47. 
    
48.   /*##-2- Disable peripherals and GPIO Clocks #################################*/
    
49.   /* Configure UART Tx as alternate function  */
    
50.   HAL_GPIO_DeInit(USARTx_TX_GPIO_PORT, USARTx_TX_PIN);
    " N0 a( e8 Y& f* K
51.   /* Configure UART Rx as alternate function  */
    - P" ^1 @: C6 v# f- \
52.   HAL_GPIO_DeInit(USARTx_RX_GPIO_PORT, USARTx_RX_PIN);
    
53. 
    , V2 w% K, ?! p! E& I3 @1 i
54.   /*##-3- Disable the NVIC for UART ##########################################*/
    
55.   HAL_NVIC_DisableIRQ(USARTx_IRQn);
    
56. }

复制代码

5 T9 m; i- h4 E; E* ~& k/ _, i这两个函数没什么可说的跟开发板对应修改即可，这样使得串口初始化更加的简洁只需要进行逻辑上的初始化即可
; _: p3 H9 s; A9 n
, K+ W& A. O" E* M4 Q6 V5 }9 P

1. /**********************************************************************
   
2. 函数:uart_init()
   8 S: _" K5 K% m( ], a
3. 函数作用:串口初始化
   
4. 参数:
   
5.         uint32_t BaudRate=========================串口波特率
   ! y0 Y: P# t) m2 E, y- ]7 m/ E. x
6. 返回值:无
   
7. 上一版本:无
   
8. 当前版本:1.0
   
9. 作者:
   
10. 最后修改时间:2015-04-02
    
11. 说明:
    
12. **********************************************************************/
    
13. void uart_init(uint32_t BaudRate)
    
14. {
    9 b* ^# t; n! o. J- _8 B% q
15. 
    " \  X) N. w) X- I5 a7 J
16.     UartHandle.Instance        = USARTx;
    3 X! d, Q1 _$ \" ~2 F/ M5 X
17.     UartHandle.Init.BaudRate   = BaudRate;
    5 |9 u, `# `/ {) T
18.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
19.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
20.     UartHandle.Init.Parity     = UART_PARITY_NONE;
    4 i# Y* @0 |; X9 u6 u7 Z" L
21.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
22.     UartHandle.Init.Mode       = UART_MODE_TX_RX;
    8 N0 n3 s8 c0 ^. T2 Z! R; a! R
23. 
    
24.     if(HAL_UART_Init(&UartHandle) != HAL_OK)
    8 H4 |3 g& c) ^
25.     {
    
26.         Error_Handler();
    ) G$ ?$ k. J6 p( {; x8 M2 H+ F- F
27.     }
    * H9 c+ c2 P" R
28.         __HAL_UART_ENABLE(&UartHandle);
    
29. 
    
30.         NVIC_SetPriority(USARTx_IRQn,0);
    
31.         NVIC_EnableIRQ(USARTx_IRQn);
    7 g; g' {/ f+ Z; V# [
32.         uart_rev.front = aRxBuffer;
    
33.         uart_rev.rear = aRxBuffer;        //两个指针指向相同的地址空间
    
34.         if(HAL_UART_Receive_IT(&UartHandle,(uint8_t*)aRxBuffer,1) != HAL_OK)
    . t* V; j  o7 S2 G- ~
35.         {
    5 X3 I' N. ~* \, T' M+ z
36.                 Error_Handler();
    
37.         }
    
38. }
    - F0 `4 ^: E' S7 [  ^1 g: ^

复制代码

这里为串口的接收开辟了500个字节的缓冲区aRxBuffer使用首尾指针来进行数据的接收和存取，即单缓冲机制。

5 D2 ^& ?8 K9 r& \# T

1. struct uart
   : L0 k# k( G; H% U6 l6 ~+ e) B
2. {
   8 C; l% C* P* A
3.         uint8_t *rear;                        //在中断函数中更改
     Y8 W+ ^- p1 o, \( s4 a; E
4.         uint8_t *front;                        //在主循环中更改
   
5. };
   ( e: m3 K/ w8 [0 ?' ~8 e0 g; d

复制代码

由于STM32L0xx_Hal_Driver库的使用串口底层分为了3种：查询方式、中断方式、DMA方式，都是使用HAL函数来实现，因此我们使用中断方式接收不能自动开启，必须使用函数HAL_UART_Receive_IT来打开接收中断，这里我们每接收一个字节就进入中断。STM32L0xx_Hal_Driver库的使用使得中断函数也十分简洁一句话搞定，采用回调函数机制来处理中断
' X0 J: x! B( U! P

1. void USARTx_IRQHandler(void)
   
2. {
   
3.           HAL_UART_IRQHandler(& UartHandle);
   2 V3 C- v/ \. f5 ^# m% A" F
4. }
   % s/ e9 m4 c! P+ @& g# c5 |; d
5. 在HAL_UART_IRQHandler()中会自动调用串口接收中断的回调函数
   
6. 
   
7. /**
   * A3 f* R4 N5 V+ U& g7 w# ~
8.   * @brief  Rx Transfer completed callback
   
9.   * @param  UartHandle: UART handle
   0 R" D) n" K- W9 C* `( H
10.   * @note   This example shows a simple way to report end of IT Rx transfer, and
    9 `  [: ]2 R- I* q; P/ z1 \
11.   *         you can add your own implementation.
    
12.   * @retval None
    
13.   */
    
14. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
    
15. {
    
16.         uint8_t ret = HAL_OK;
    
17.         /* Set transmission flag: trasfer complete*/
    ! ]  f$ ]7 {+ X! S  ~/ [/ A( ?
18.         uart_rev.rear++;        //更新rear指针
    ; I* W4 I1 t1 s4 a: f4 |! g
19.         if(uart_rev.rear >= (aRxBuffer + BUFFSIZE))
    
20.                 uart_rev.rear = aRxBuffer;
    8 q. y! L3 Z6 m
21.         do
    9 \1 K, g% v% c9 t' D  w
22.         {
      ^1 n% h2 Q/ l* p2 c9 m/ N# D
23.                 ret = HAL_UART_Receive_IT(UartHandle,uart_rev.rear,1);
    
24.         }while(ret != HAL_OK);
    8 o& F% M' [" d
25. }
    

复制代码

每次把接收到的数据存入rear所指向的地址空间，存入数据只更新rear指针，同时开启请求下一个数据的到来。在主函数中调用uart_read函数来取出数据

1. /**********************************************************************
   
2. 函数:uart_read()
   
3. 函数作用:从接收缓冲区中读取数据
   7 {/ E. ^, R: f6 ]; A
4. 参数:
   - D+ o/ H! D9 O4 C  e0 K
5.         uint8_t *fmt--------------------------------接收到的数据
   # t) \8 |1 B  l: k6 J
6.         uint16_t time_out---------------------------超时时间
   : x! C; j0 `+ q1 W& _% u
7. 返回值:0:读取到数据-1:没有读取到数据
   
8. 上一版本:无
   
9. 当前版本:1.0
   / m, m$ i$ L3 q' _% _
10. 作者:
      m3 O# C' U8 h7 D4 r9 T
11. 最后修改时间:2015-04-08
    2 _+ x" U6 k  h* Q) O$ D0 s
12. 说明:
    : D" m* U6 Y- v$ ~; W0 g
13. **********************************************************************/
    ' M0 [% x7 [2 l5 ^6 U7 e
14. int8_t uart_read(uint8_t *fmt, uint16_t time_out)
    
15. {
    ! |' G! ]' |7 q( j/ s: w
16.         while(time_out)
    ) G6 I/ b* s, Y9 I% c6 k% e3 P4 w
17.         {
    
18.                 if(uart_rev.front != uart_rev.rear)
    7 w% X1 F" n% h
19.                 {
    3 |- e1 d1 v4 E4 h2 w/ R
20.                         //如果队首指针和队尾指针不同表明缓冲区中有数据还未收取
    # j; y( h4 Q) M  f
21.                         *fmt=*uart_rev.front;
    
22.                
    ! t# Y2 S$ J0 I* b6 j
23.                         uart_rev.front++;
    . m$ j3 u5 n  V! P
24. 
    
25.                         if (uart_rev.front >= (aRxBuffer+BUFFSIZE))
    
26.                                 uart_rev.front = aRxBuffer;
    
27. 
    5 o/ Z+ P+ R9 e- f0 {
28.                         return 0;
    
29.                 }
    
30.                 time_out--;
    & n) Q! v8 A% h  X! H0 _
31.         }
    7 U0 S1 B+ c1 w& X9 U9 [
32.         return (int8_t)-1;
    
33. }

复制代码

取数据只更新front指针，这里有个不足的地方是如果一直不取数据或者取数据速度较慢而接收的数据很多会造成数据覆盖即出现数据丢失的情况，不过一般很少会有这种情发生（对于我来说是在主循环中不停地进行读取操作，所以没事啦）,整个文件如下

8 z" X+ g6 _5 n+ Y( W, u6 W6 V

1. #include "UART.h"
     o- \; W) x- z" x
2. #include "stm32l0xx_hal_def.h"
   ' i/ r3 s8 \' d1 y# |
3. #include "utils.h"
   + X: V( o* M1 x) B" q
4. 
   
5. UART_HandleTypeDef UartHandle;
   & ?: Y9 P1 Y2 F- v; A" }: n5 p$ Q1 a6 x
6. uint8_t aRxBuffer[BUFFSIZE];
   
7. struct uart uart_rev;
   
8. 
   
9. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
   ) Z6 E' b2 t5 H4 y
10. {  
    % B$ K; X9 l5 s* s1 S% ~
11.   GPIO_InitTypeDef  GPIO_InitStruct;
    6 q; ]8 f7 C0 E. |" M6 M
12. 
    
13.   /*##-1- Enable peripherals and GPIO Clocks #################################*/
    5 L- S% ]/ ?( ]' \& Q' Y6 _+ u5 J0 V- K
14.   /* Enable GPIO TX/RX clock */
    ' [0 y. K$ M3 \5 H# n1 ~: f
15.   USARTx_TX_GPIO_CLK_ENABLE();
    ! j4 ~  P) U. T) H, S
16.   USARTx_RX_GPIO_CLK_ENABLE();
    
17.   /* Enable USART1 clock */
    
18.   USARTx_CLK_ENABLE();
    
19. 
    # s; `) S4 `$ j- X5 q
20.   /*##-2- Configure peripheral GPIO ##########################################*/  
    ! p- O9 ~' ~2 ~  a- F
21.   /* UART TX GPIO pin configuration  */
    , A1 Q1 b0 D, F0 X
22.   GPIO_InitStruct.Pin       = USARTx_TX_PIN;
    
23.   GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
24.   GPIO_InitStruct.Pull      = GPIO_NOPULL;
    7 `( ]2 _  |9 ]6 i
25.   GPIO_InitStruct.Speed     = GPIO_SPEED_HIGH;
    
26.   GPIO_InitStruct.Alternate = USARTx_TX_AF;
    
27. 
    
28.   HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct);
    & D& f, _: g$ h
29. 
    9 ~( k9 E  U" d& D6 Z
30.   /* UART RX GPIO pin configuration  */
    
31.   GPIO_InitStruct.Pin = USARTx_RX_PIN;
    4 K6 [% }( }6 j* d* J( q
32.   GPIO_InitStruct.Alternate = USARTx_RX_AF;
    
33. 
    3 ?0 I8 c# j. y& G# ^! X$ x% N
34.   HAL_GPIO_Init(USARTx_RX_GPIO_PORT, &GPIO_InitStruct);
    + T2 A' y; p" w* ~: j5 O
35. 
    * g& |! d2 S- a  k0 z4 F9 ?7 `7 W
36.   /*##-3- Configure the NVIC for UART ########################################*/
    
37.   /* NVIC for USART1 */
    - T/ F2 _8 G- k' S: [; x$ z
38.   HAL_NVIC_SetPriority(USARTx_IRQn, 0, 1);
    
39.   HAL_NVIC_EnableIRQ(USARTx_IRQn);
    
40. }
    5 E- I: S" Z( X: S3 w3 G
41. 
    , ?( }* `+ f, ~
42. /**
    8 ~1 A* L7 C8 @% W/ V# O
43.   * @brief UART MSP De-Initialization
    / H/ W3 u6 m  p4 f' n
44.   *        This function frees the hardware resources used in this example:
    3 Y& r% E  |2 o1 v0 }
45.   *          - Disable the Peripheral's clock
    5 W+ a  i  S1 V
46.   *          - Revert GPIO and NVIC configuration to their default state
    
47.   * @param huart: UART handle pointer
      k; H( p7 h+ N
48.   * @retval None
    
49.   */
    ! R6 K, N3 n$ C, B8 @. U
50. void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)
    
51. {
    / V. G# e+ e  a% ?+ K4 Y- o; ]
52.   /*##-1- Reset peripherals ##################################################*/
    
53.   USARTx_FORCE_RESET();
    8 n3 H8 V# r$ e1 b7 D" D( P# [
54.   USARTx_RELEASE_RESET();
    9 v  x" A8 U5 y6 ?( Q+ o" l: b
55. 
    
56.   /*##-2- Disable peripherals and GPIO Clocks #################################*/
    
57.   /* Configure UART Tx as alternate function  */
    & m/ M/ P+ O# |7 }# L+ z+ @
58.   HAL_GPIO_DeInit(USARTx_TX_GPIO_PORT, USARTx_TX_PIN);
    
59.   /* Configure UART Rx as alternate function  */
    
60.   HAL_GPIO_DeInit(USARTx_RX_GPIO_PORT, USARTx_RX_PIN);
    # k0 E. J% M! b# O! X& P
61. 
    
62.   /*##-3- Disable the NVIC for UART ##########################################*/
    
63.   HAL_NVIC_DisableIRQ(USARTx_IRQn);
    
64. }
    
65. 
    
66. /**********************************************************************
    4 w- ]% u/ J. j2 f: R
67. 函数:uart_init()
    2 q& e, N, Y$ x  o
68. 函数作用:串口初始化
    
69. 参数:
    
70.         uint32_t BaudRate=========================串口波特率
    
71. 返回值:无
    8 i" H6 a# e  @4 N, }7 Z
72. 上一版本:无
    7 m4 D% t. \) G9 G3 W, A  }5 j
73. 当前版本:1.0
    8 y  N5 v7 w# {7 b4 c
74. 作者:
    
75. 最后修改时间:2015-04-02
    
76. 说明:
    * r1 x+ i& K0 F
77. **********************************************************************/
    + L8 S+ X( P+ C
78. void uart_init(uint32_t BaudRate)
    # {) Z& L( l' F8 r
79. {
    7 ]  c& q, w$ C
80. 
    
81.     UartHandle.Instance        = USARTx;
    ' ]& X3 x' `% _3 F
82.     UartHandle.Init.BaudRate   = BaudRate;
    
83.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
84.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
85.     UartHandle.Init.Parity     = UART_PARITY_NONE;
    
86.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
87.     UartHandle.Init.Mode       = UART_MODE_TX_RX;
    
88. 
    . Q5 c* t  T8 n: i# I9 V5 D
89.     if(HAL_UART_Init(&UartHandle) != HAL_OK)
    
90.     {
    
91.         Error_Handler();
    
92.     }
    
93.         __HAL_UART_ENABLE(&UartHandle);
    0 \& s1 B$ y* |; v8 e' _: A; ^  \
94. 
    
95.         NVIC_SetPriority(USARTx_IRQn,0);
    
96.         NVIC_EnableIRQ(USARTx_IRQn);
    
97.         uart_rev.front = aRxBuffer;
    
98.         uart_rev.rear = aRxBuffer;        //两个指针指向相同的地址空间
    
99.         if(HAL_UART_Receive_IT(&UartHandle,(uint8_t*)aRxBuffer,1) != HAL_OK)
    , U( i/ ]; L* `# h, V
100.         {
     
101.                 Error_Handler();
     
102.         }
     - q4 e# x" Y0 g0 K- c) q( ]
103. }
     , |: f" p, q# ^3 z: D# Q; J2 V
104. void Error_Handler(void)
     0 H8 d7 Y0 @  l  @) Q! `
105. {
     $ h) Q. S% r- b5 I& A
106.     while(1)
     
107.     {
     ) r4 s/ s0 h$ k
108. 
     
109.     }
     
110. }
     $ I2 H  C* A6 m3 P
111. 
     
112. /**********************************************************************
     
113. 函数:uart_read()
     
114. 函数作用:从接收缓冲区中读取数据
     
115. 参数:
     
116.         uint8_t *fmt--------------------------------接收到的数据
     
117.         uint16_t time_out---------------------------超时时间
     
118. 返回值:0:读取到数据-1:没有读取到数据
     
119. 上一版本:无
     " }  R- p4 y" {+ P
120. 当前版本:1.0
     9 R: C& d$ W+ A' y6 z$ K
121. 作者:
     & q( [2 x; p5 ^; {, S# ^  O- _
122. 最后修改时间:2015-04-08
     
123. 说明:
     
124. **********************************************************************/
     4 J: \; }) Z* S7 R1 \& _
125. int8_t uart_read(uint8_t *fmt, uint16_t time_out)
     
126. {
     ' j# Q+ k+ ]+ ?8 U7 n% g! C/ l) j
127.         while(time_out)
     
128.         {
     6 A" \/ s1 P3 {/ W4 Y% \
129.                 if(uart_rev.front != uart_rev.rear)
     
130.                 {
     # J7 o$ @! n% G. n. A) E4 o) I0 f8 _
131.                         //如果队首指针和队尾指针不同表明缓冲区中有数据还未收取
     
132.                         *fmt=*uart_rev.front;
     * o# B2 W+ ]$ |% \% o4 h- c) n3 O7 X
133.                
     ( c% s. _; `/ \: _9 s
134.                         uart_rev.front++;
     
135. 
     : Q5 ^/ |" C7 M; {" z2 C  g3 S: \
136.                         if (uart_rev.front >= (aRxBuffer+BUFFSIZE))
     + }/ s# S+ v( S
137.                                 uart_rev.front = aRxBuffer;
     
138. 
     ) i/ F& c3 Y5 G
139.                         return 0;
     / U3 g: B7 b- x+ m! l# Q* @
140.                 }
     
141.                 time_out--;
     % q8 l8 ~% V# {* V# B3 C
142.         }
     ! t) X9 ?9 b1 ^0 z. x
143.         return (int8_t)-1;
     
144. }
     ; R* s3 Q8 @: D2 J0 m0 I
145. 
     
146. int8_t uart_send(uint8_t *fmt, uint8_t len)
     
147. {
     
148.         while(len)
     
149.         {
     4 |' w6 M. n! ^4 o2 c, g
150.                 printf("%c",*fmt);
     
151.                 fmt++;
     
152.                 len--;
       J4 M$ Q& P6 Z6 k( r) j
153.         }
     " e, n1 S! l' M* ~( B: P8 ~
154. 
     
155.         return 0;
     
156. }
     - H! w, |+ v5 g) J! f0 \5 j
157. 
     ; U3 Z; E5 B8 y- P9 _
158. #ifdef UART_DEBUG
     - w: j7 L. i& B
159. int fputc(int ch, FILE *f)
     , N* {8 h5 P! a* R; r- ~
160. {
     
161.     USART1->TDR = ch;
     " t) L* ^7 {$ U5 {% m( A. u
162.     while(!(USART1->ISR & USART_ISR_TXE));
     0 E) w( G1 |+ i$ ^7 `
163.     return(ch);
     7 e  l" c; r% M4 s, Y! Z
164. }
     
165. #endif
     7 y/ b7 r4 t% V- {. Q2 Q* }; t
166. 
     
167. /**
     2 x. J" ~3 x5 [9 i; b2 C4 J; H
168.   * @brief  Tx Transfer completed callback
     5 T+ h0 Z$ p: x
169.   * @param  UartHandle: UART handle.
     
170.   * @note   This example shows a simple way to report end of IT Tx transfer, and
     ) c  O/ x# k: }" ~2 L
171.   *         you can add your own implementation.
     
172.   * @retval None
     
173.   */
     
174. void HAL_UART_TxCpltCallback(UART_HandleTypeDef * huart)
     
175. {
     1 S) ~  Q+ K3 B2 y
176.         uint8_t ret = HAL_OK;
     5 Q, [: T$ P. [. ~  ?
177.         UartReady = SET;
     5 x, |, ~0 Q* ^1 D5 ]
178.         #if 1
       M! q! K0 f" P* f
179.         uart_snd.front++;        //更新rear指针
     
180.         if(uart_snd.front >= (aTxBuffer + BUFFSIZE))
     
181.                 uart_snd.front = aTxBuffer;
     + n( q+ `' x. q# {) T: ?
182.         if(uart_snd.front != uart_snd.rear)
     
183.         {
     
184.                 //如果队首指针和队尾指针不同表明缓冲区中有数据还未发送
     ( y' W( ^8 C( A$ ^9 I
185.                 do
     ) B% h6 }& f& [1 `7 G
186.                 {
     
187.                         ret = HAL_UART_Transmit_IT(&UartHandle,uart_snd.front,1);//请求发送下一个数据
     
188.                 }while(ret != HAL_OK);
     
189.         }
     ) f+ x' E  H4 \0 K
190.         #endif
     : U6 O4 ]6 g( K
191. }
     
192. /**
     ( @# S7 s1 I9 g4 J
193.   * @brief  Rx Transfer completed callback
     
194.   * @param  UartHandle: UART handle
     
195.   * @note   This example shows a simple way to report end of IT Rx transfer, and
     
196.   *         you can add your own implementation.
     1 C& d- R- a9 \5 Z6 K$ r7 h. A
197.   * @retval None
     
198.   */
     
199. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
     7 l2 J8 D& K1 b3 [
200. {
     
201.         uint8_t ret = HAL_OK;
     : }" i. C; M! i) j8 u
202.         /* Set transmission flag: trasfer complete*/
     * z! f8 K0 [% u: r. S/ X
203.         uart_rev.rear++;        //更新rear指针
     , T' J, r* X" X$ {5 i8 T- X  c
204.         if(uart_rev.rear >= (aRxBuffer + BUFFSIZE))
     ( X, E. N# i0 T/ I
205.                 uart_rev.rear = aRxBuffer;
     
206.         do
     ) o4 ^& H" r$ ^$ f+ }& [
207.         {
     : j1 z4 ~$ _& L  b4 B/ x7 w. U( u
208.                 ret = HAL_UART_Receive_IT(UartHandle,uart_rev.rear,1);
     3 ^0 O3 w9 B6 q" Y
209.         }while(ret != HAL_OK);
     
210. }
     
211. /******************************************************************************/
     6 s/ C  C% m1 _% n) \, Z$ D
212. /*                 STM32L0xx Peripherals Interrupt Handlers                   */
     
213. /*  Add here the Interrupt Handler for the used peripheral(s) (PPP), for the  */
     
214. /*  available peripheral interrupt handler's name please refer to the startup */
     " V2 ?- R9 j/ _$ K5 E! v& |
215. /*  file (startup_stm32l0xx.s).                                               */
     
216. /******************************************************************************/
     
217. /**
     
218.   * @brief  This function handles UART interrupt request.  
     # ~$ L+ @$ o/ \
219.   * @param  None
     
220.   * @retval None
     
221.   * @Note   This function is redefined in "main.h" and related to DMA stream
     
222.   *         used for USART data transmission     
     
223.   */
     $ ?2 r! {, q! I
224. void USARTx_IRQHandler(void)
     # i& v3 _9 E+ h3 C  i- m
225. {
     - e. r! u- M$ ]& O
226.           HAL_UART_IRQHandler(& UartHandle);
     
227. }

复制代码

' l: }( q5 M- X1 @
: U  i9 u- a' I8 r( s在实际测试中也没有问题，当单缓冲机制可用时，就会考虑使用双缓冲机制即为串口发送也开辟一个缓冲区。

0 A% K( |& X% p: d7 s* A: |: K0 Y