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 */
   * g" S* N+ W4 K' K  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)
   3 K! [7 J5 K( u% B" H
3. {
   ) l' b% q* T/ j; W2 G2 d0 N% ~, Q
4.   if(htim->Instance==TIM2){
   0 k0 U: U0 m( e3 S
5.     Timer3_count++;
   4 }3 j4 u* k/ }( f; G
6.     if(Timer3_count >= 3){
   ! |! O: E$ S9 Z8 O
7.       Timer3_count = 0;
   
8.       HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);   
   ; U+ A, R8 a, T/ ^+ g" ]% D9 h
9.     }
     t+ Y8 x6 z! W
10.       
    
11.   }
    2 N6 T+ ]8 e  E, |
12.   else if(htim->Instance==TIM21){
      }  r( J2 X$ P( n% F4 w
13.     ++Timer4_count;
    1 W! }; _. j7 |" a! g; F( D
14.   if(Timer4_count>0X1FFFFFF)Timer4_count=0;   
    
15.   }
    ' X  h& D! l& m
16. }
    
17. /* USER CODE END 1 */

复制代码

3、串口相关3.1 printf函数的实现
6 f6 u  J! _: C6 m( P

1. /* USER CODE BEGIN 0 */
   
2. #if 1
   
3. #include <stdio.h>
   
4. 
   - w* k( z& C$ [7 ~  V' e& N& |
5. /* 告知连接器不从C库链接使用半主机的函数 */
   / q9 C1 u. E) ]
6. #pragma import(__use_no_semihosting)
   
7. 
   
8. /* 定义 _sys_exit() 以避免使用半主机模式 */
   
9. void _sys_exit(int x)
   
10. {
    
11.     x = x;
    / x7 ]7 F$ g" M% d& K
12. }
    
13. 
    
14. /* 标准库需要的支持类型 */
    ( J* _; E5 L9 T' i8 [
15. struct __FILE
    
16. {
    9 u8 m" j( _6 M, E# x
17.     int handle;
    
18. };
    
19. 
    
20. FILE __stdout;
    
21. 
    ; d2 t# O. ^4 N
22. int fputc(int ch, FILE *stream)
    
23. {
    5 }+ @6 w/ m9 c9 Z
24.     /* 堵塞判断串口是否发送完成 */
    
25.     while((USART1->ISR & 0X40) == 0);
    
26. 
    
27.     /* 串口发送完成，将该字符发送 */
    
28.     USART1->TDR = (uint8_t) ch;
    
29. 
    
30.     return ch;
    ( X+ }6 O& D2 i  v3 S3 W5 S
31. }
    : W# @& a" B3 ]/ [7 j! ~  p9 b8 V) ~  h
32. #endif
    
33. /* USER CODE END 0 */
    

复制代码

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

! ?! m3 E0 V" ?1 n$ g6 G

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

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

1. /* USER CODE BEGIN 1 */
   + H- |+ v+ G6 J$ K6 h
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
3. {
   ; ~  A/ F3 v) T. r
4.   if(huart->Instance == LPUART1){
   ) x5 H8 z0 @1 \% ^2 y  S' Z4 N# g2 f
5.     Enocean_Data++;
   
6.     HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[Enocean_Data], 1);
   
7.   }
   9 s; T# a* i7 m6 _6 s
8.   else if(huart->Instance==USART1)
   
9.   {
   
10.       // HAL_UART_Transmit_IT(&huart1,(uint8_t *)USART1_BUF, 10);
    
11.       // HAL_UART_Receive_IT(&huart1, (uint8_t *)USART1_BUF, 10);  
    6 ?* R( D: K& U& o5 c' a+ D
12.   }
    5 j$ d+ V$ \& Q; b& M& Z
13. }
    3 A8 x4 K: }* [$ m! j1 m
14. /* USER CODE END 1 */

复制代码

1.   /* Infinite loop */
   % [/ P- W  _3 K5 q0 F
2.   /* USER CODE BEGIN WHILE */
   1 [+ C' c! D  s* _
3.   while (1)
   $ A+ I( f7 [7 l. a' E' Y* x8 o
4.   {
   7 T- i9 S# o. a7 j+ x, G+ x
5.     if(test_data != Enocean_Data){
   # ^1 A; @$ `' _; ]
6.         HAL_Delay(7);
   $ N* L$ r! l; e, t
7.         HAL_UART_Transmit(&huart1,USART_Enocean_BUF, Enocean_Data,0xFFFF);     //将串口3接收到的数据通过串口1传出   
   
8.         memset(USART_Enocean_BUF, 0, sizeof(USART_Enocean_BUF));   //清空缓存区
   
9.         Enocean_Data=0;
   
10.         (&hlpuart1)->pRxBuffPtr = &USART_Enocean_BUF[Enocean_Data];//这一句很重要，没有这一句，后面接收会出错
    
11.     }
    
12.     /* USER CODE END WHILE */
    " K8 v) o) @' _* o$ S
13. 
    " w. l- k6 ^3 j; n8 w6 G: R
14.     /* USER CODE BEGIN 3 */
    
15.   }
    6 V/ W; s9 s. |
16.   /* USER CODE END 3 */

复制代码

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

1.   /* USER CODE BEGIN 2 */
   
2.   HAL_TIM_Base_Start_IT(&htim2);
   
3.   //使能串口中断接收
   & x+ `- t1 ^! ^' O, D( `
4.   HAL_UART_Receive_IT(&hlpuart1, (uint8_t *)&USART_Enocean_BUF[0], 1);
   
5.   /* USER CODE END 2 */

复制代码

' `' w- c! [$ l' G

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

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

4、独立看门狗

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

1. HAL_IWDG_Refresh(&hiwdg);
   0 y! k( O6 n$ e# \
2.   }
   
3.   /* USER CODE END 3 */

复制代码

5 U) ?& B% {+ t, R

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

4 ~: T( B: x( @

5、按键驱动移植

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

1. /*
     R" H. G2 C+ o
2. 2019/5/21 按键程序移植成功，以后可以使用此按键，需要研究一下
   
3. 和以前单片机项目按钮方式类似  
   
4. by  qzh
   
5. 2019/8/30  
   
6. 确定了第三行，第一个必须是7，才能按下到时间自动触发
   
7. by  qzh
   
8. */
   
9. #include "mod_button.h"
   : Y1 j4 _, ?% [& I
10. 
    
11. 
    
12. //GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
    
13. void io_getDigital(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin,uint8 *pu8Value)
    ) x) h9 L) `( W. O% T
14. {
    6 ]8 n# i6 x/ w; `( d. A. L
15. *pu8Value = HAL_GPIO_ReadPin(GPIOx,GPIO_Pin);
    
16. }
    ; v6 b# |, x, E$ x
17. 
    + e2 N- P5 h1 d( p% s
18. void time_setTimerCount(TIMER_TYPE *pu8timer,uint32 u32timeToCount)  
    
19. {
    
20. // __HAL_TIM_SET_COUNTER
    : k- P* }& I, ^7 B. z
21. HAL_TIM_Base_Start_IT(&htim21);
    ' p  {( D* w" n# j
22. // HAL_TIM_Base_Stop_IT
    
23. // TIM_Cmd(TIM4, ENABLE);
    + L9 c! o) E: p: w, ~' X, m% l
24. if(pu8timer->on == 0)
    
25.   pu8timer->on = 1;
    7 E* f  [$ J  u) n
26. if(pu8timer->on == 1)
    
27.   //IntNum = 0;
    1 {! R2 F4 q6 I; W$ C9 f
28.   pu8timer->timeInit = Timer4_count;
    
29. //pu8timer->timeInit = IntNum;
    + Z: `( h' Y* X9 _4 T! P1 D
30. pu8timer->timeOut = 0;
    
31. pu8timer->timeToCount = u32timeToCount;
    9 D- \0 w8 x; C+ J
32. }
    3 ]# \3 p# _& `6 n4 c; W4 p5 V
33. 
    
34. RETURN_TYPE time_getTimeOut(TIMER_TYPE *pu8timer)
    * i- D' P+ ]( C; j; P' F
35. {
    : }. q5 |5 D: t; T! R
36. uint32 Temp_Val;
      U% C/ ^; F# \6 B3 A: o
37. if(Timer4_count > pu8timer->timeInit)
    + m" e  [% q+ o. p* ^- s; z; u7 O
38.   Temp_Val = Timer4_count - pu8timer->timeInit;
    
39. else
    6 d7 e8 B9 d  ~" Z$ g
40.   Temp_Val = (0xFFFFFFFF-pu8timer->timeInit)+Timer4_count;
    
41. if(Temp_Val >= pu8timer->timeToCount)
    
42. {
    
43.   pu8timer->timeOut = 1;
    
44.   pu8timer->on = 0;
    6 t2 A( z/ B0 Q! |
45.   pu8timer->timeToCount = 0;
    
46.   pu8timer->timeInit = 0;
    4 w; s- p4 I. G7 V( e2 Y) Q. [
47. }
    
48. else
    
49.   pu8timer->timeOut = 0;
    $ m1 K( F$ B: p" E
50. return (pu8timer->timeOut == 1)?TIME_OUT:OK;
    
51. }
    5 b/ O+ U3 b( D% M: i
52. 
    
53. BTN_STATE btn_getState(BTN_STRUCT *pBtn)
    
54. {
    % u+ a7 E7 `. P/ m! B! {  y
55. const uint8 transition_table[8][4]={ 0, 1, 0, 1,
    $ h9 g) i8 Z6 E& ?2 K8 X( g2 x
56.           5, 2, 5, 1,
    $ r( b( ?, ?5 F+ o! b
57.           7, 2, 5, 3,
    
58.           5, 4, 5, 4,
    " O+ ^; i4 o5 i( C
59.           5, 4, 5, 4,
    1 `7 A1 c; b8 w7 C$ L
60.           6, 1, 0, 1,
    8 B$ H2 x; ^& X# C. m. L
61.           6, 1, 7, 1,
    , o% \: I' h' e
62.           0, 1, 0, 1 };
    
63. 
    
64. //register uint8 u8Input;
      V# z  r/ f7 S$ \: R
65. uint8 u8Input;
    
66. // Get button state
      ~1 p) S, @8 ?+ H
67. io_getDigital(pBtn->u8Pin,pBtn->GPIO_Pin ,&u8Input);
    / N: h" z/ u2 s" u
68. u8Input = (u8Input == pBtn->u8ActiveState)?1:0;
    
69. 
    
70. // Get timeout state
    $ q* k! j$ Y! b$ f" @! ]
71. u8Input |= ((time_getTimeOut(&(pBtn->tTimer))==TIME_OUT)?2:0);
    
72. 
    - O( o+ p- m) _5 a8 `
73. // Get new state
    6 g) z' m1 q' P3 v- c. G; H% s% B
74. pBtn->u8State = transition_table[pBtn->u8State][u8Input]; // we want only the state, not action
    
75. 
    , C  E8 H# Y  D
76. // Perform action
    + s$ G6 @- w' r+ M2 {- ^1 {
77. switch (pBtn->u8State)
    
78. {
    
79.   case 1:
    # v# F3 s4 J$ A  H! ?
80.    time_setTimerCount(&(pBtn->tTimer), pBtn->u16TimeOutON);
    7 |" x0 @) K5 D9 u; I. u
81.    break;
    
82.   case 5:
    + G$ M* E% @/ s8 r( ]) y
83.    time_setTimerCount(&(pBtn->tTimer), pBtn->u16TimeOutOFF);
    
84.    break;
    . @7 i1 t4 t. h6 g0 [: q
85. }
    
86. // return pBtn->u8State;
    
87. //待测试
    : l) o* z8 W; B" j
88. return (BTN_STATE)pBtn->u8State;
    
89. }
    
90. 
    . Q  h/ K1 x4 V( w1 n5 c7 f
91. 
    
92. void Button_Action()
    1 y6 d# {+ }. R  u4 {) y- n6 S
93. {
    
94. /*
    5 F  S7 \- c5 J1 m2 u  n
95. 按键动作，模式选择
    
96. */
    3 J4 F" a% B2 \: D1 j
97. }
    

复制代码

1. #ifndef _MOD_BUTTON_H_INCLUDED
   4 h6 A$ o1 H& _4 a3 G) [2 S- i
2. #define _MOD_BUTTON_H_INCLUDED
   
3. 
   
4. #include "main.h"
   
5. #include "Datadef.h"
   . c* m' X/ d6 f$ l  {& s& \/ g: v
6. #include "tim.h"
   
7. /*
   ; f  J/ y: R* C+ A
8.        Timeout ON
   6 p  ^. z( {% `9 n
9.                 _______|_____
   
10. P             |             |    Timeout OFF
    $ n& t/ \  a0 f0 K4 \
11. R  ___________|             |________|____
    # f/ ]9 {5 J1 N8 x* M
12.   ^      ^  ^    ^  ^  ^   ^    ^
      U, r8 w+ a) M3 J+ @& K! f
13. S  0    1  2    3  4  5  6    7
    
14. 
    
15. P - pressed, R - released, S - BTN_STATE
    % ]- S' ?0 X( [1 J
16. */
    ' J; D5 \8 Q& k: h' G
17. 
    3 R9 W( T1 U! b( m" ^
18. /*
    
19. °´Å¥Ïà¹Ø  KEY1  learn  PB5  KEY2  CLEAR  PB6
    
20. */
    
21. #define BTN_ACTIVE    0       //when pressed, switch to GND
    
22. 
    
23. 
    
24. typedef struct
    8 m0 c2 Q7 w: |
25. {
    
26. // Public
    
27. //uint8  u8Pin;   // e.g. ADIO0
    2 G# D+ S5 P( |9 l* t
28. //uint16  u8Pin;   // e.g. ADIO0
    ( y0 x. `( p& T1 Q
29. GPIO_TypeDef * u8Pin;
    9 i8 H2 p8 j/ Z' [
30. uint16_t    GPIO_Pin;
    
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
    
33. uint16  u16TimeOutOFF; // time the button has to be pressed to be recognized as released
    5 ^7 q4 w; w: ]' o3 P
34. 
    
35. // Private
    
36. TIMER_TYPE tTimer;
    0 R) Z3 K% h) d
37.   uint8  u8State;
    * q+ g  q$ x* l6 o, n
38. 
    ; n- ]7 j9 w. j+ A
39. } BTN_STRUCT;
    
40. 
    . s# ]( S7 j$ U, b
41. typedef enum
    
42. {
    % s; s0 ^2 X. C  ?5 v" q
43. BTN_IDLE = 0,
    
44. BTN_EDGE1,
    7 ]; j, Y& L$ t( `. g  r! `
45. BTN_TRIGGERED,
    
46. BTN_PRESSED, //< most important
    - s6 m( s5 `9 z9 \9 N
47. BTN_PRESS_HOLD,
    
48. BTN_EDGE2,
    
49. BTN_RELEASE_HOLD,
    : q& u7 b: b. r! Y/ a: s# ?' M
50. BTN_RELEASED
    9 X7 ~8 {' ~+ W! `' S1 C$ \! K
51. } BTN_STATE;
    
52. 
    - c4 r. l0 T2 t0 m8 i% H  o# T
53. extern u16 Timer4_count;
    
54. 
    % H1 d3 ^! R; m1 w  m4 W) m) b+ I
55. BTN_STATE btn_getState(BTN_STRUCT *pBtn);
    ! {. l% v: ?2 K/ K) W5 E
56. void time_setTimerCount(TIMER_TYPE *pu8timer,uint32 u32timeToCount);
    
57. void io_getDigital(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin,uint8 *pu8Value);
    
58. RETURN_TYPE time_getTimeOut(TIMER_TYPE *pu8timer);
    
59. 
    
60. 
    $ u) `  M* B6 K
61. #endif //_MOD_BUTTON_H_INCLUDED

复制代码

% C; H3 p4 w7 _& W! p& c  A* N+ |

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

1. /* USER CODE BEGIN 3 */
   7 B- p, N3 R& o# ]- V! y6 z& x  m$ s
2.     if(btn_getState(&K1_BUTTON_150mS) == BTN_EDGE2){
   
3.         HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
   ( G2 x4 A$ l( {8 \3 w$ D
4.     }
   
5. 
   
6.     if((btn_getState(&K1_BUTTON_2S)==BTN_PRESSED)){
   
7.        while(btn_getState(&K1_BUTTON_150mS));
   3 @& f; Q0 u. S
8.     }
   
9. 
   # \2 x% ~. ]9 S0 T; R2 [
10.     if(btn_getState(&K2_BUTTON_150mS) == BTN_EDGE2){
    
11.         HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
    2 D1 \# `/ F1 F2 s: `8 _) t
12.         HAL_Delay(150);
    
13.         HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
    
14.     }
    5 S: F$ s; A5 n4 ^: S" m: g0 r) e' ^
15.     HAL_IWDG_Refresh(&hiwdg);
    
16.   }
    7 N3 S2 y+ ?& M: y& f
17.   /* USER CODE END 3 */

复制代码

测试结果OK。

6、软件复位

1. /* Private user code ---------------------------------------------------------*/
   5 h7 y7 A0 U5 z) S% o
2. /* USER CODE BEGIN 0 */
   
3. void SoftReset(void)
   
4. {
   : y& O7 |1 ~0 S6 q, ^
5.     __set_FAULTMASK(1); // 关闭所有中断
   2 Y3 M2 h& G( n3 b0 M0 q$ u4 @
6.     NVIC_SystemReset(); // 复位
   : ?& U- z, O8 d% F
7. }
   
8. /* USER CODE END 0 */

复制代码

; u8 g: z' Y' f1 w
) s5 F. v# S  v8 }5 _

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

1. /* USER CODE BEGIN 0 */
   0 z. O/ j% \* M8 D' t. |
2. void SoftReset(void)
   
3. {
   
4.     HAL_NVIC_SystemReset(); // 复位
   , D/ O  v+ W4 w  n" ^3 f' b
5. }
   % U0 f' j; S$ A
6. /* USER CODE END 0 */

复制代码

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

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

转载自： 矜辰所致

如有侵权请联系删除