1、LED灯的闪烁

在主函数while循环中直接使用延时控制：

1. HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
   
2.     HAL_Delay(1000);

复制代码

测试正常，这个延时1S钟靠肉眼识别，如果有误差其实也看不出来，影响delay应该是和系统时钟有关，后续再确定是否正常；

2、定时器控制LED闪烁

在tim.c文件中对应处添加  HAL_TIM_PeriodElapsedCallback 函数，这是定时器中断的响应函数，当然，参数的定义（这里使用的参数只不过是以前使用F103保留下来直接复制过来的，我这里就没有进行对应的处理），相关.h文件的包含不要忘记添加。还有一个需要注意的，定时器初始化了，需要在主函数中开启定时器所以进行以下操作，LED会每隔3S切换一次

1. /* USER CODE BEGIN 2 */
   ' `- T/ l8 \. t  y7 w% m- L/ s
2.   HAL_TIM_Base_Start_IT(&htim2);
   
3.   /* USER CODE END 2 */

复制代码

1. /* USER CODE BEGIN 1 */
   
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   6 N( Z/ K% I& P% |5 ^/ I* q$ v
3. {
   
4.   if(htim->Instance==TIM2){
   
5.     Timer3_count++;
   , l- B7 p9 G. t
6.     if(Timer3_count >= 3){
   
7.       Timer3_count = 0;
   
8.       HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);   
   
9.     }
   
10.       
    
11.   }
    ) k$ S5 l3 r8 j  q! e- `- m$ P* h
12.   else if(htim->Instance==TIM21){
    
13.     ++Timer4_count;
    
14.   if(Timer4_count>0X1FFFFFF)Timer4_count=0;   
    
15.   }
    
16. }
      q$ e5 f5 w, d
17. /* USER CODE END 1 */

复制代码

4 a# g2 D8 ~+ @2 c9 K2 C4 S3、串口相关3.1 printf函数的实现

1. /* USER CODE BEGIN 0 */
   
2. #if 1
   
3. #include <stdio.h>
   * s( i& U& O2 ?
4. 
   
5. /* 告知连接器不从C库链接使用半主机的函数 */
   
6. #pragma import(__use_no_semihosting)
   5 x; @# A1 d6 P! G/ z* A6 s
7. 
   
8. /* 定义 _sys_exit() 以避免使用半主机模式 */
   
9. void _sys_exit(int x)
   
10. {
    5 ~$ d, N% d6 c  T7 N& u
11.     x = x;
    
12. }
    * w) n5 m$ ]% R3 M! f
13. 
    
14. /* 标准库需要的支持类型 */
    
15. struct __FILE
    " e% k$ L  q) N9 j0 e/ C/ L
16. {
    
17.     int handle;
    6 [& t0 U2 S# c% Y# y8 }! \0 O
18. };
    
19. 
    
20. FILE __stdout;
    . }# G3 R* T5 }5 K
21. 
    
22. int fputc(int ch, FILE *stream)
    6 y7 h) ]3 v# ^9 U  T9 y/ r( H
23. {
    & N4 a' T, Z. E( ]. P, M
24.     /* 堵塞判断串口是否发送完成 */
    4 P1 o! J9 ~* r: ~3 K  E
25.     while((USART1->ISR & 0X40) == 0);
    
26. 
    5 s! j4 R% {. x1 O+ c
27.     /* 串口发送完成，将该字符发送 */
    : h( _" X) @% [+ V# F6 r) m
28.     USART1->TDR = (uint8_t) ch;
    
29. 
    
30.     return ch;
    
31. }
    2 o. a- j* H4 D$ [3 K
32. #endif
    ( r2 _' c& P" Z& @) Y
33. /* USER CODE END 0 */
    

复制代码

3 O0 Y0 y# b3 I% g$ [$ a

其中需要说明的是，如果是F103 ，不是 ISR 和 TDR 寄存器，而是 SR  DR寄存器

3.2 串口接收不定长度的数据

在 usart.c 文件中添加  HAL_UART_RxCpltCallback  函数，对应的缓存数组不要忘记定义，我们这里使用的是 LPUART1 和 我的无线通讯模块通讯（以前F103对应的引脚是串口3），在中断响应函数中把串口接收到的数据存到 USART_Enocean_BUF 中，然后在主函数中实现打印接收到的一串数据。

1. /* USER CODE BEGIN 1 */
   
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   3 J. j' z0 V% }
3. {
   
4.   if(huart->Instance == LPUART1){
   9 M! ^9 h  g* [" U
5.     Enocean_Data++;
   
6.     HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[Enocean_Data], 1);
   
7.   }
   8 n3 B- ^" d( ]' \' W0 l
8.   else if(huart->Instance==USART1)
   . @7 r. [9 O% o  @/ C+ N
9.   {
   
10.       // HAL_UART_Transmit_IT(&huart1,(uint8_t *)USART1_BUF, 10);
    
11.       // HAL_UART_Receive_IT(&huart1, (uint8_t *)USART1_BUF, 10);  
    3 P: w3 j  Z/ H- _( n' h0 O7 p
12.   }
    4 J1 D# r- T- Z
13. }
    + P  H0 ?/ Y9 g8 w; z
14. /* USER CODE END 1 */

复制代码

1.   /* Infinite loop */
   
2.   /* USER CODE BEGIN WHILE */
   
3.   while (1)
   
4.   {
   / `8 d- g2 r! l6 t% q- d
5.     if(test_data != Enocean_Data){
   . _  n3 C% @- |; Y
6.         HAL_Delay(7);
   " D. r3 ~7 m& S' N8 [; x# U
7.         HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF);     //将串口3接收到的数据通过串口1传出   
   ' l7 i% F% F1 N9 F& V# n
8.         memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF));   //清空缓存区
   ' N, z5 X5 s5 t0 Z$ h  |% Z) H
9.         Enocean_Data=0;
   3 H7 Z" I  v, S6 O3 d0 o
10.         (&hlpuart1)->pRxBuffPtr = &USART_Enocean_BUF[Enocean_Data];//这一句很重要，没有这一句，后面接收会出错
    
11.     }
    
12.     /* USER CODE END WHILE */
    - U( p2 V& k! H9 D* b
13. 
    
14.     /* USER CODE BEGIN 3 */
    
15.   }
    - U4 @* s! A; \0 p; h+ `
16.   /* USER CODE END 3 */

复制代码

和定时器一样要注意，串口开启中断接收，需要在初始化后执行一次中断接收的函数 HAL_UART_Receive_IT ，类似于开启中断接收：

1.   /* USER CODE BEGIN 2 */
   
2.   HAL_TIM_Base_Start_IT(&htim2);
   
3.   //使能串口中断接收
   2 O- D' Y  E$ J1 J
4.   HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[0], 1);
   0 q* g6 M0 K, G5 A5 H
5.   /* USER CODE END 2 */

复制代码

' y6 o5 ^& T2 j# v6 W

完成了以上操作，就能够实现将LPUART1 收到的数据，通过串口1打印出来

今天还发现一个细节，HAL_UART_RxCpltCallback 函数不需要再次在.h文件中申明，因为HAL库中虽然是 _weak 声明的，但是在底层stm32L0xx_hal_uart.h中已经申明了，所以在应用程序中申不申明都可以

3 f4 i( M* f. n, @* _

4、独立看门狗

看门狗还是比较简单的，直接在循环中加一个喂狗函数就可以：

1. HAL_IWDG_Refresh(&hiwdg);
   
2.   }
   * E$ @9 t8 H5 M0 a6 X- Z. Y% `) C
3.   /* USER CODE END 3 */

复制代码

这里我也测试了下上一篇文章我设置的看门狗时间，当时计算出来看门狗时间为6.4S，是准确的。

5、按键驱动移植

因为自己以前用到了一个非常好用的按钮设计，所以一直保留至今，直接上.c 和 .h文件

1. /*
   
2. 2019/5/21 按键程序移植成功，以后可以使用此按键，需要研究一下
   
3. 和以前单片机项目按钮方式类似  
   
4. by  qzh
   
5. 2019/8/30  
   
6. 确定了第三行，第一个必须是7，才能按下到时间自动触发
   
7. by  qzh
   
8. */
   7 u  ~$ {" U9 G7 S2 U0 Q
9. #include "mod_button.h"
   
10. 
    ) j* U  G! X( W+ X: _9 `; J& Z
11. 
    8 n; ~, q* D# u
12. //GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
      Z; v0 l1 ]* b5 q. y) n: j
13. void io_getDigital(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin,uint8 *pu8Value)
    % J  I( s( J* `& `3 q$ v& ?
14. {
    # E; `6 f. |4 P) V/ T
15. *pu8Value = HAL_GPIO_ReadPin(GPIOx,GPIO_Pin);
    6 M1 l! B) n" x% |" z- G
16. }
    : e4 G4 ^8 ~2 L, e. z' i
17. 
    0 d6 L+ c. C8 r4 n& [9 W$ j+ _) c
18. void time_setTimerCount(TIMER_TYPE *pu8timer,uint32 u32timeToCount)  
    - s$ h" ?8 i2 m& \7 o
19. {
    + y- b, h! T( O% ~
20. // __HAL_TIM_SET_COUNTER
      p$ l& A' S8 E9 q7 k1 b2 V" x1 K8 C
21. HAL_TIM_Base_Start_IT(&htim21);
    
22. // HAL_TIM_Base_Stop_IT
    
23. // TIM_Cmd(TIM4, ENABLE);
    
24. if(pu8timer->on == 0)
    
25.   pu8timer->on = 1;
    , y: u6 K" r' R3 r& p& r
26. if(pu8timer->on == 1)
    
27.   //IntNum = 0;
    8 Q6 E* o8 t. ], B# d/ Y
28.   pu8timer->timeInit = Timer4_count;
    3 b* f+ C$ }; n4 I; V$ n
29. //pu8timer->timeInit = IntNum;
    2 i: M, ]8 T4 A! @" x' D
30. pu8timer->timeOut = 0;
    
31. pu8timer->timeToCount = u32timeToCount;
    
32. }
    3 p2 D1 i0 o% s" }6 H
33. 
    1 a, r6 y& P6 S: z2 b5 P
34. RETURN_TYPE time_getTimeOut(TIMER_TYPE *pu8timer)
    
35. {
    " Y5 O+ b, X: g/ l* ?
36. uint32 Temp_Val;
    , R* H. Q3 w& ~' d7 M
37. if(Timer4_count > pu8timer->timeInit)
    
38.   Temp_Val = Timer4_count - pu8timer->timeInit;
    
39. else
    ' V$ A) X# x( ~% s2 ]* [/ d
40.   Temp_Val = (0xFFFFFFFF-pu8timer->timeInit)+Timer4_count;
    
41. if(Temp_Val >= pu8timer->timeToCount)
    + ^7 a8 a9 Z5 }2 X4 H: r
42. {
    
43.   pu8timer->timeOut = 1;
    
44.   pu8timer->on = 0;
    
45.   pu8timer->timeToCount = 0;
    0 D6 [, ?7 o! M0 ?& E
46.   pu8timer->timeInit = 0;
    " A. e2 C( i6 v/ \; A2 Y
47. }
    
48. else
    
49.   pu8timer->timeOut = 0;
    
50. return (pu8timer->timeOut == 1)?TIME_OUT:OK;
    
51. }
    
52. 
    9 J- z, {" U* X1 H! R4 h& Y
53. BTN_STATE btn_getState(BTN_STRUCT *pBtn)
    ; W1 e0 {6 v2 \7 m6 Q
54. {
    / e7 i$ j1 p# \
55. const uint8 transition_table[8][4]={ 0, 1, 0, 1,
    
56.           5, 2, 5, 1,
    1 R6 @5 I( S1 M7 |* k  w
57.           7, 2, 5, 3,
    
58.           5, 4, 5, 4,
    / F  h5 Z% I. H" I9 L3 C
59.           5, 4, 5, 4,
    
60.           6, 1, 0, 1,
    . S- i! U$ O  c, ]5 ^
61.           6, 1, 7, 1,
    - i6 {2 H1 z4 \8 N6 K
62.           0, 1, 0, 1 };
    ; k' Z3 ^/ }3 w* _
63. 
    / C( y/ B9 s0 \: k* `, n
64. //register uint8 u8Input;
    ) j# h* X2 |" E1 y
65. uint8 u8Input;
    3 s3 Q6 i+ \3 r0 y$ m2 C& C# z
66. // Get button state
    ( L9 O' j9 _; J$ @9 k% t
67. io_getDigital(pBtn->u8Pin,pBtn->GPIO_Pin ,&u8Input);
    
68. u8Input = (u8Input == pBtn->u8ActiveState)?1:0;
    
69. 
    
70. // Get timeout state
    : C! O4 A& @; E& Y
71. u8Input |= ((time_getTimeOut(&(pBtn->tTimer))==TIME_OUT)?2:0);
    
72. 
    
73. // Get new state
    
74. pBtn->u8State = transition_table[pBtn->u8State][u8Input]; // we want only the state, not action
    ( T/ v) Q$ {0 ?: x
75. 
    
76. // Perform action
    
77. switch (pBtn->u8State)
    , C0 T/ N; ?( C# t
78. {
    
79.   case 1:
    
80.    time_setTimerCount(&(pBtn->tTimer), pBtn->u16TimeOutON);
    
81.    break;
    
82.   case 5:
    
83.    time_setTimerCount(&(pBtn->tTimer), pBtn->u16TimeOutOFF);
    
84.    break;
    ) o( N6 r6 h' R/ Y
85. }
    
86. // return pBtn->u8State;
    & j; h" ^1 e- F+ d
87. //待测试
    
88. return (BTN_STATE)pBtn->u8State;
    1 q" H- ^/ C; R& P* l* a
89. }
    
90. 
    # R8 ?( o$ I% O4 [7 Z1 Z
91. 
    
92. void Button_Action()
    / ~" u9 q# y' M/ Z+ v  o# Y
93. {
    9 M2 }- C0 W2 R' _
94. /*
    
95. 按键动作，模式选择
    
96. */
    0 F: G  S- x, t
97. }
    

复制代码

1. #ifndef _MOD_BUTTON_H_INCLUDED
   : z2 ?' N; l9 @1 p% [! ?
2. #define _MOD_BUTTON_H_INCLUDED
   5 s0 ?. p! F  x. z
3. 
   
4. #include "main.h"
   
5. #include "Datadef.h"
   8 {) G! j: o) D" X1 Y% x5 X  y3 F  v
6. #include "tim.h"
   # C% S& G, a& E- N8 r$ O& [$ M4 \
7. /*
   " L+ R" Z" j( h( D9 c
8.        Timeout ON
   
9.                 _______|_____
   * w4 ?: y, `4 Q9 ?
10. P             |             |    Timeout OFF
    
11. R  ___________|             |________|____
    
12.   ^      ^  ^    ^  ^  ^   ^    ^
    & R9 Q/ b* [1 R/ ?% x' ]& i
13. S  0    1  2    3  4  5  6    7
    & u, ^  R  H1 B2 v" ~" A
14. 
    & m! p# a- K4 C4 ]' U' p7 N9 m
15. P - pressed, R - released, S - BTN_STATE
    
16. */
    
17. 
    , X6 W7 ^/ m) |* @
18. /*
    ' m* F8 D; {4 W# E7 ]1 @- [
19. °´Å¥Ïà¹Ø  KEY1  learn  PB5  KEY2  CLEAR  PB6
    ; B$ O. w4 z  S
20. */
    
21. #define BTN_ACTIVE    0       //when pressed, switch to GND
    
22. 
    
23. 
    , ~* W/ z$ l. h! e0 j
24. typedef struct
    
25. {
    1 x+ R8 Y1 A1 Z% f+ A1 n& w% f
26. // Public
    6 v5 `0 `) t6 K, p3 w5 @
27. //uint8  u8Pin;   // e.g. ADIO0
    
28. //uint16  u8Pin;   // e.g. ADIO0
    
29. GPIO_TypeDef * u8Pin;
    " n# [  C/ Y9 g3 a0 f; |3 p' X
30. uint16_t    GPIO_Pin;
    9 w7 f7 @# y+ D$ v  M( T! C
31. uint8  u8ActiveState; // button is pressed if (io_getDigital(u8Button)==bActiveState)
    
32. uint16  u16TimeOutON; // time the button has to be pressed to be recognized as pressed
    + g0 X5 x# @0 |3 Z! h* w: k
33. uint16  u16TimeOutOFF; // time the button has to be pressed to be recognized as released
    - a& ~+ G7 V; T9 ]6 r5 i
34. 
    8 {5 {9 ?9 N" ~
35. // Private
    : W6 A$ G. h: r7 F7 Y$ b5 H; W8 p! H
36. TIMER_TYPE tTimer;
    
37.   uint8  u8State;
      N' F) h% r  V, |# n% L6 i
38. 
    
39. } BTN_STRUCT;
    ! \/ Q9 n1 ~( d- _, V0 q
40. 
    * p' t6 R4 W% b
41. typedef enum
    
42. {
    
43. BTN_IDLE = 0,
    7 R2 a. `/ r; _7 O6 i
44. BTN_EDGE1,
    7 G$ S) g9 T8 g6 m* ?' P- y% O6 p
45. BTN_TRIGGERED,
    
46. BTN_PRESSED, //< most important
    
47. BTN_PRESS_HOLD,
    ) f% l1 K; p+ M- R( J
48. BTN_EDGE2,
    8 A& q+ T5 U) h: T. X& u
49. BTN_RELEASE_HOLD,
    
50. BTN_RELEASED
    - H# z/ q+ R% c6 P$ u
51. } BTN_STATE;
    
52. 
    
53. extern u16 Timer4_count;
    5 J" |& y* l" A  z
54. 
    * ^, @9 n1 {+ X0 P
55. BTN_STATE btn_getState(BTN_STRUCT *pBtn);
    
56. void time_setTimerCount(TIMER_TYPE *pu8timer,uint32 u32timeToCount);
    % G7 K& _2 Q, v2 |) I
57. void io_getDigital(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin,uint8 *pu8Value);
    
58. RETURN_TYPE time_getTimeOut(TIMER_TYPE *pu8timer);
    - }2 n4 B- H5 W8 Y9 T% k
59. 
    
60. 
    
61. #endif //_MOD_BUTTON_H_INCLUDED

复制代码

在主函数中添加需要用到的按钮操作：

1. /* USER CODE BEGIN 3 */
   
2.     if(btn_getState(&K1_BUTTON_150mS) == BTN_EDGE2){
   
3.         HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
   
4.     }
   
5. 
   
6.     if((btn_getState(&K1_BUTTON_2S)==BTN_PRESSED)){
   9 {2 G8 }7 ^3 A8 T8 Z
7.        while(btn_getState(&K1_BUTTON_150mS));
   " X, r6 l0 A! ?+ D
8.     }
   4 o' b5 I+ N5 U! b. ^
9. 
   
10.     if(btn_getState(&K2_BUTTON_150mS) == BTN_EDGE2){
    5 r0 A# H$ N0 c: Q+ Q- ?
11.         HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
    ! X8 \! X( `8 e3 g5 m6 d) D. S: c
12.         HAL_Delay(150);
    
13.         HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
    2 c6 Y* P) ]% H+ b
14.     }
    0 u; `  D$ `) Y7 J( e, W
15.     HAL_IWDG_Refresh(&hiwdg);
    
16.   }
    5 Q% r* f8 E( ?
17.   /* USER CODE END 3 */

复制代码

, Y$ r- }9 |# {! F+ j, A

测试结果OK。

6、软件复位
* z5 D8 `( u% d  ^

1. /* Private user code ---------------------------------------------------------*/
   ; m7 p+ w/ z4 ]4 d
2. /* USER CODE BEGIN 0 */
   3 _' n( A2 r4 r' w2 `' b
3. void SoftReset(void)
   1 w& y9 Z8 \) I9 o8 @6 `% M
4. {
   
5.     __set_FAULTMASK(1); // 关闭所有中断
   
6.     NVIC_SystemReset(); // 复位
   
7. }
   - d$ V7 V7 e6 A0 v
8. /* USER CODE END 0 */

复制代码

4 t' R% b2 S3 F/ f' Q1 H: o9 ^
5 I, }( S2 A$ a9 O& V( ?' k0 O  q4 e, C3 t

其实上面这个是有问题的，在HAL库中没有__set_FAULTMASK(1)这个，直接如下：

1. /* USER CODE BEGIN 0 */
   
2. void SoftReset(void)
   
3. {
   ) j* a) [! k8 C) U: a" ~, ^
4.     HAL_NVIC_SystemReset(); // 复位
   ) @' b; j  k; m: J
5. }
   
6. /* USER CODE END 0 */

复制代码

或者直接用HAL_NVIC_SystemReset();这个函数在程序中就可以；

小结，基本上项目上使用到的串口，LED，按钮等功能都测试过了，然后我还得把通讯模块的底层一些驱动移植过来，其实也就是根据通讯模块的串口协议进行的一系列操作。这里就不说明，等今天完成这部分，下一篇文章会来写一下通过IO口，软件模拟的I2C接口测试。

; {7 ]. O5 k+ p( {

转载自： 矜辰所致

如有侵权请联系删除

% @3 J$ i& Y6 I' _