创建基于F411的芯片空工程。
& ?# ]$ V. T5 N- M启用hwtimer：


& h4 f+ a6 a: I
$ ]% o+ M  F" b拷贝以下三个文件到drivers目录，路径分别为
, e4 \2 i4 g1 Z. S7 z5 g1 TC:\RT-ThreadStudio\download\rt-thread-sdk\rt-thread-src\v4.0.2\bsp\stm32\libraries\HAL_Drivers\config\f4
# P: b6 u% V+ Q和 C:\RT-ThreadStudio\download\rt-thread-sdk\rt-thread-src\v4.0.2\bsp\stm32\libraries\HAL_Drivers 。



注释掉drv_hwtimer.c中的#include "drv_config.h"。
取消注释stm32f4xx_hal_conf.h中的#define HAL_TIM_MODULE_ENABLED。
% r  Y, Z7 r1 C* z. q, O6 |向tim_config.h添加#include <board.h>。
3 P" e! f2 ~& l3 i! Q向drv_hwtimer.c添加#include <rtdevice.h>。
向drv_hwtimer.c添加#include <tim_config.h>。
; F& [) k, s! t
在board.h中定义需要使用的定时器：


/ y  k" A6 h# ~' _: N7 l  s( y9 `
- |- H7 F5 G$ a5 ]: ~* L, _根据要使用的定时器，修改tim_config.h：

1. /*
   2 ~2 n: ^; ~* U. E2 P
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   8 ]' ~% Q& F5 f* ]' N6 f7 g
3. *
   " n% l/ ]- Z- ^2 n5 \  C/ f
4. * SPDX-License-Identifier: Apache-2.0
   
5. *
   
6. * Change Logs:
   - T$ M; E: ^0 l
7. * Date           Author       Notes
   
8. * 2018-12-11     zylx         first version
   ! k. e  [! p% {0 E2 K& l3 X$ L
9. */
   3 E' A% {0 X- p& `. R9 k
10. 
    2 v. }, y: B$ O) s8 s3 ?3 w% D, d
11. #ifndef __TIM_CONFIG_H__
    - q( h3 D5 m7 u( V+ P& y
12. #define __TIM_CONFIG_H__
    
13. 
    
14. #include <rtthread.h>
    8 J$ P. L) h: `$ r; Q8 T# V
15. #include <board.h>
    
16. #ifdef __cplusplus
    
17. extern "C" {
    ! r2 [# F$ ?: \) }
18. #endif
    6 J( T: F: _5 b1 A+ l
19. 
    
20. #ifndef TIM_DEV_INFO_CONFIG
    4 G: `4 q' Z. E1 R
21. #define TIM_DEV_INFO_CONFIG                     \
    
22.     {                                           \
    & t" `; D6 @+ c3 r/ U* Q
23.         .maxfreq = 1000000,                     \
    
24.         .minfreq = 3000,                        \
    
25.         .maxcnt  = 0xFFFF,                      \
    
26.         .cntmode = HWTIMER_CNTMODE_UP,          \
    8 I# O9 z! V7 V$ M
27.     }
    
28. #endif /* TIM_DEV_INFO_CONFIG */
    
29. 
    4 N. o& t5 o' H4 ?
30. 
    " Y  W* ^% S" m+ l0 t
31. #ifdef BSP_USING_TIM1
    " r+ D- ?/ ~9 V
32. #ifndef TIM1_CONFIG
    ) V  q" ]7 R6 G
33. #define TIM1_CONFIG                                        \
    6 q. H9 u' d# V$ i) w$ P- U! I
34.     {                                                       \
    
35.        .tim_handle.Instance     = TIM1,                    \
    / `  ^1 I2 b5 F9 V
36.        .tim_irqn                = TIM1_UP_TIM10_IRQn,  \
    
37.        .name                    = "timer1",                \
    
38.     }
    
39. #endif /* TIM11_CONFIG */
    
40. #endif /* BSP_USING_TIM11 */
    ! k" p2 ~% Y2 x( T1 f2 l3 u" n$ x! x! J2 H
41. 
    ! D2 t% t2 A4 [" x+ @- E
42. 
    
43. 
    
44. #ifdef BSP_USING_TIM2
    
45. #ifndef TIM2_CONFIG
    5 s3 ^4 y' ~% B; R9 N9 V3 F2 c
46. #define TIM2_CONFIG                                        \
    
47.     {                                                       \
    
48.        .tim_handle.Instance     = TIM2,                    \
    # S, O  ?1 a  K6 L
49.        .tim_irqn                = TIM2_IRQn,  \
    
50.        .name                    = "timer2",                \
    
51.     }
    ) A! W/ N  q- S" d; S9 b. O
52. #endif /* TIM11_CONFIG */
    4 C/ r' E) Z" ?+ U8 y: a
53. #endif /* BSP_USING_TIM11 */
    ) `3 z5 a% O% p: X7 G. T# a
54. 
    
55. 
    * N: g" i$ j3 L3 e& U
56. 
    
57. #ifdef BSP_USING_TIM3
    
58. #ifndef TIM3_CONFIG
    
59. #define TIM3_CONFIG                                        \
    , m$ h; v7 O+ l- c- m1 a
60.     {                                                       \
    ) C# h; C, \3 w. o" f3 E
61.        .tim_handle.Instance     = TIM3,                    \
    ; J" g& ^5 [; Y$ `; d, q! w
62.        .tim_irqn                = TIM3_IRQn,  \
    
63.        .name                    = "timer3",                \
    ; s- ]; y* U$ X# L9 ]
64.     }
    
65. #endif /* TIM11_CONFIG */
    4 J1 @- c/ n7 K" O( q
66. #endif /* BSP_USING_TIM11 */
    
67. 
    
68. 
    3 `3 X, r* [; x: y
69. 
    
70. 
    4 L9 e) z0 a% X% _
71. #ifdef BSP_USING_TIM4
    3 _0 S0 Z4 v# a7 {+ j
72. #ifndef TIM4_CONFIG
    
73. #define TIM4_CONFIG                                        \
    
74.     {                                                       \
    $ @' {+ v- ~- t$ ?+ G6 w7 G
75.        .tim_handle.Instance     = TIM4,                    \
    - i& X/ S# t# H
76.        .tim_irqn                = TIM4_IRQn,  \
    6 K. S9 L! r- j" g
77.        .name                    = "timer4",                \
    - D- \- `! B0 O- O, o
78.     }
    
79. #endif /* TIM11_CONFIG */
    
80. #endif /* BSP_USING_TIM11 */
    
81. 
    
82. #ifdef BSP_USING_TIM5
    
83. #ifndef TIM5_CONFIG
    
84. #define TIM5_CONFIG                                        \
    * o% i, D! W3 _- B
85.     {                                                       \
    4 j6 s- }% `) s1 E% }! q/ H0 [. H
86.        .tim_handle.Instance     = TIM5,                    \
    
87.        .tim_irqn                = TIM5_IRQn,  \
    9 e6 X# R# q$ {% g7 j* b6 h8 O
88.        .name                    = "timer5",                \
    
89.     }
    * Q; _/ l7 j1 g2 J4 o, o6 Y8 e
90. #endif /* TIM11_CONFIG */
    9 }9 Z' T$ r  S1 C
91. #endif /* BSP_USING_TIM11 */
    . n1 B" R7 Q3 O8 Z6 d* P' d9 C
92. 
    8 s8 }( ^8 y& X2 r* @0 e
93. #ifdef BSP_USING_TIM9
    
94. #ifndef TIM9_CONFIG
    
95. #define TIM9_CONFIG                                        \
    . i2 V3 j/ f% W5 ^: f3 f
96.     {                                                       \
    
97.        .tim_handle.Instance     = TIM9,                    \
    " G& ]6 J4 a" ^
98.        .tim_irqn                = TIM1_BRK_TIM9_IRQn,  \
    
99.        .name                    = "timer9",                \
    0 e7 \* K6 {% k* n, u2 j
100.     }
     % u* ?) N) e! V' d
101. #endif /* TIM11_CONFIG */
     : @! j) A1 V9 X
102. #endif /* BSP_USING_TIM11 */
     5 z) L8 Q/ t2 h" o( @: c# q, z
103. 
     . d" t3 W5 H5 |8 s/ k& W
104. #ifdef BSP_USING_TIM10
     7 }) A/ W9 u) o1 f( E  R
105. #ifndef TIM10_CONFIG
     & \1 q3 ^+ G+ ?. B7 J( x" ?7 g
106. #define TIM10_CONFIG                                        \
     4 G2 x) H& ]1 `0 ]
107.     {                                                       \
     
108.        .tim_handle.Instance     = TIM10,                    \
     2 C% D8 |& G: i# V- g
109.        .tim_irqn                = TIM1_UP_TIM10_IRQn,  \
     
110.        .name                    = "timer10",                \
     
111.     }
     ! k2 C; ]. H4 e4 u
112. #endif /* TIM11_CONFIG */
     % L8 L4 [8 C  h+ p5 H5 c& E& Q( l
113. #endif /* BSP_USING_TIM11 */
     : {* v( S: {! W1 N; M& [4 L$ b
114. 
     
115. #ifdef BSP_USING_TIM11
     
116. #ifndef TIM11_CONFIG
     
117. #define TIM11_CONFIG                                        \
       k" N6 M0 p# _; l1 v2 k4 u! F' M
118.     {                                                       \
     
119.        .tim_handle.Instance     = TIM11,                    \
     $ m, U. o' a8 G+ a# L9 w3 v" t, `
120.        .tim_irqn                = TIM1_TRG_COM_TIM11_IRQn,  \
     
121.        .name                    = "timer11",                \
     5 Q* p# w  O$ ?, L
122.     }
     
123. #endif /* TIM11_CONFIG */
     
124. #endif /* BSP_USING_TIM11 */
     
125. 
     - R) X- |$ J! Q: `
126. 
     , ]2 z; k9 r0 z4 c+ g1 Y, f
127. 
     
128. #ifdef __cplusplus
     
129. }
     8 M9 A) c6 T( t8 ?/ H$ z- C
130. #endif
     : G! Y; O% P; Y& }) L
131. 
     % Z8 a0 F3 K  V8 _
132. #endif /* __TIM_CONFIG_H__ */
     4 S4 b" }, H* k

复制代码

6 i1 X9 S$ O  O8 \0 }在drv_hwtimer.h中增加CubeMX生成的底层代码：
* P' _. g% X; L  A3 i4 v5 L9 ?

1. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
   
2. {
   , z4 z. y7 x& @" {9 f# Z
3.     if (htim_base->Instance == TIM1)
   
4.     {
   
5.         __HAL_RCC_TIM1_CLK_ENABLE();
   
6.     }
   ' Q' N- s9 j: F8 l( E$ p
7.     else if (htim_base->Instance == TIM2)
   
8.     {
   ' e7 f3 }/ d2 a5 ^3 \9 C
9.         __HAL_RCC_TIM2_CLK_ENABLE();
   " w: n1 O6 e/ x3 Y' \. j
10.     }
    
11.     else if (htim_base->Instance == TIM3)
    
12.     {
    9 @* m3 r. c, c% x
13.         __HAL_RCC_TIM3_CLK_ENABLE();
    5 w4 i/ v9 x9 j: `
14.     }
    
15.     else if (htim_base->Instance == TIM4)
    
16.     {
    ; b) N" A0 Q" C
17.         __HAL_RCC_TIM4_CLK_ENABLE();
    
18.     }
    
19.     else if (htim_base->Instance == TIM5)
    & G1 i- D3 r/ H- R
20.     {
    
21.         __HAL_RCC_TIM5_CLK_ENABLE();
    3 ]' r* E8 O+ V
22.     }
    % X! |, j# I" Y# l* B; S9 [1 ]
23.     else if (htim_base->Instance == TIM9)
    9 P: f! Y" R3 c9 g, X8 I! h! y
24.     {
      E$ `" V+ j! B4 Q7 ?3 N2 G
25.         __HAL_RCC_TIM9_CLK_ENABLE();
    
26.     }
    + q+ I$ ^3 \5 ~& E0 `
27.     else if (htim_base->Instance == TIM10)
    8 e/ |5 _3 a0 a* p; Q
28.     {
    
29.         __HAL_RCC_TIM10_CLK_ENABLE();
    
30.     }
    
31.     else if (htim_base->Instance == TIM11)
    
32.     {
    
33.         __HAL_RCC_TIM11_CLK_ENABLE();
    
34.     }
    , R8 K6 ~! A3 Q0 }' O( k
35. }
    # ]! `! e4 ^1 o; _3 |

复制代码

/ n/ z, ?9 }4 J/ M3 F, c5 I  D修改drv_hwtimer.h中HAL_TIM_PeriodElapsedCallback，为使用的定时器添加回调函数：

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   ' W: Q0 ?! I! ]
2. {
   , i0 d. l& p' ~
3. #ifdef BSP_USING_TIM1
   $ p+ g1 c/ e0 ^1 I$ y* U
4. if (htim->Instance == TIM1)
   / I' ?) I3 L7 o3 y- K6 ~# D8 Z9 y+ M$ t
5. {
   " B; t" R" y7 u) `1 n+ D
6.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM1_INDEX].time_device);
   ) U& F  r: m2 x$ T3 n3 }
7. }
   
8. #endif
   
9. #ifdef BSP_USING_TIM2
   
10. if (htim->Instance == TIM2)
    
11. {
    ; L7 b+ v2 ]0 L4 n( S' ]6 A
12.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM2_INDEX].time_device);
    + W+ k1 \8 R! I# f
13. }
    
14. #endif
    , R1 B$ b# @, F; Z6 ?) b1 Z4 ?* _
15. #ifdef BSP_USING_TIM3
    
16. if (htim->Instance == TIM3)
    
17. {
    
18.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM3_INDEX].time_device);
    
19. }
    ! G9 [* A! V3 ]. v/ j9 }3 L  D) L
20. #endif
    
21. #ifdef BSP_USING_TIM4
    
22. if (htim->Instance == TIM4)
    $ h$ R3 @. [0 C5 G- X% R
23. {
    
24.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM4_INDEX].time_device);
    4 ~4 r+ K( L# g$ y' [2 g; R
25. }
    
26. #endif
    ) M2 e* u1 J7 V# Q! p7 o6 o+ [! L
27. #ifdef BSP_USING_TIM5
    - G$ v0 T4 m/ v
28. if (htim->Instance == TIM5)
    
29. {
    ; Z) c' f) O: i; v
30.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM5_INDEX].time_device);
    
31. }
    9 U8 P( K$ V) N( ^% m: \
32. #endif
    
33. #ifdef BSP_USING_TIM9
    ( G# O' O2 E9 e! Y+ K; t
34. if (htim->Instance == TIM9)
    
35. {
    
36.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM9_INDEX].time_device);
    / a% h; ~( [0 q% s$ C+ M
37. }
    3 _& p; L- Q5 Y: b9 q+ X" z
38. #endif
    
39. #ifdef BSP_USING_TIM10
    ( i; }$ q, I- f  d$ U
40. if (htim->Instance == TIM10)
    
41. {
    4 w% H( `0 q0 G0 |: L
42.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM10_INDEX].time_device);
    
43. }
    
44. #endif
    
45. #ifdef BSP_USING_TIM11
    
46. if (htim->Instance == TIM11)
    4 @8 u& H* P7 P% `& ~
47. {
    
48.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM11_INDEX].time_device);
    
49. }
    
50. #endif
    , }4 G* h9 S8 s- l! u' }' j+ @
51. }
    

复制代码

3 z2 q' y- G' Z- S4 K添加中断函数入口：
9 ]# z* M9 r8 J( _

1. #ifdef BSP_USING_TIM2
   , z6 |+ o$ t) V0 B3 B9 Y' q
2. void TIM2_IRQHandler(void)
   
3. {
   
4. /* enter interrupt */
   
5. rt_interrupt_enter();
   4 b! b0 Q7 u7 N* s* @1 R
6. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM2_INDEX].tim_handle);
   " j: p3 p+ W- Z# Q. B$ t' F! `
7. /* leave interrupt */
   
8. rt_interrupt_leave();
   3 j9 n, R% @5 w: I6 P
9. }
   ( q. b/ u, w3 G9 o: G" I
10. #endif
    9 b- e5 s8 e+ O
11. #ifdef BSP_USING_TIM3
    
12. void TIM3_IRQHandler(void)
    
13. {
    
14. /* enter interrupt */
    : ~  k$ k1 Q- m! M
15. rt_interrupt_enter();
    
16. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM3_INDEX].tim_handle);
    
17. /* leave interrupt */
    
18. rt_interrupt_leave();
    
19. }
    
20. #endif
    ! `) H5 q- {+ Q! _$ u* l7 K
21. #ifdef BSP_USING_TIM4
    3 ?- J: ?+ r- o6 L% f
22. void TIM4_IRQHandler(void)
    4 K+ @3 N9 F; c# U' V
23. {
    - }- y' [( \8 T. I. m. _
24. /* enter interrupt */
    
25. rt_interrupt_enter();
    
26. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM4_INDEX].tim_handle);
    4 q. C  C( W1 B, R4 D
27. /* leave interrupt */
    
28. rt_interrupt_leave();
    
29. }
    / y, r0 l) g6 U0 [
30. #endif
    
31. #ifdef BSP_USING_TIM5
    5 l6 B- m) h4 _. |& M% [
32. void TIM5_IRQHandler(void)
    
33. {
    4 R' [$ O. N+ X7 }) t# F/ X) S
34. /* enter interrupt */
    & u! m& {& h1 ]& |& \
35. rt_interrupt_enter();
    
36. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM5_INDEX].tim_handle);
    $ d. |( I% y6 q. A, D; R: @$ e
37. /* leave interrupt */
    ) A5 N" _3 o- e& b. c
38. rt_interrupt_leave();
    2 A4 y) N% W8 Q2 w0 O6 b$ V$ o
39. }
    
40. #endif
    9 q% a) t5 g& v' n+ P! U
41. #ifdef BSP_USING_TIM11
    ( z5 o" ^( u4 `8 t# I5 a& k0 z, g% B
42. void TIM1_BRK_TIM9_IRQHandler(void)
    
43. {
    " N$ J; }$ Z2 P- d7 g
44. /* enter interrupt */
    $ [) Z9 Z. T+ a' B
45. rt_interrupt_enter();
    
46. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM9_INDEX].tim_handle);
    
47. /* leave interrupt */
    
48. rt_interrupt_leave();
    
49. }
    7 e; q" t- v% ~( X  m4 J
50. #endif
    
51. 
    
52. #if defined( BSP_USING_TIM1) ||defined(BSP_USING_TIM10)
    " h/ r* C5 X. `; m
53. void TIM1_UP_TIM10_IRQHandler(void)
    
54. {
    
55. /* enter interrupt */
    
56. rt_interrupt_enter();
    
57. #ifdef BSP_USING_TIM1
    
58. if (__HAL_TIM_GET_FLAG(&stm32_hwtimer_obj[TIM1_INDEX].tim_handle,TIM_IT_UPDATE) != RESET)
    . S5 ^0 V- i6 I" Y8 n4 t
59.     HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM1_INDEX].tim_handle);
    7 H$ l5 }! V* D" ~1 @; K4 c
60. #endif
    
61. #ifdef BSP_USING_TIM10
    6 b0 r' U* x0 h% b8 h, }
62. if (__HAL_TIM_GET_FLAG(&stm32_hwtimer_obj[TIM10_INDEX].tim_handle,TIM_IT_UPDATE) != RESET)
    
63.     HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM10_INDEX].tim_handle);
    
64. #endif
    
65. 
    # G* t: @" e! F6 O" W* j) J
66. /* leave interrupt */
    9 F3 Q4 e/ M: w& i* g
67. rt_interrupt_leave();
    + z& e, O+ J$ n, C5 w
68. }
    
69. #endif
    - Y: t, T# R" m2 u6 ~/ H
70. 
    2 A' U4 S1 n2 D4 a
71. #ifdef BSP_USING_TIM11
    
72. void TIM1_TRG_COM_TIM11_IRQHandler(void)
    
73. {
    ) C! ^9 z/ I; Q' l0 _  L
74. /* enter interrupt */
    / ~( B! O( f- C  ]! w
75. rt_interrupt_enter();
    5 A5 _- [* W; D3 l0 c5 ?# o
76. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM11_INDEX].tim_handle);
    % s. p, ?2 w7 `1 T! }
77. /* leave interrupt */
    : Q: k8 u3 Z5 a4 H! V
78. rt_interrupt_leave();
    & L2 C6 Y) D+ q0 q# s
79. }
    
80. #endif
    , o" B7 J) G0 T' f3 y* ]

复制代码

2 |& s- U# K8 O) z% {- n新建一个usertimer.c，添加示例代码，通过msh调用即可看到效果：

1. /*
   " \! d  d4 H0 m" K3 c
2. * Copyright (c) 2006-2020, RT-Thread Development Team
   
3. *
   
4. * SPDX-License-Identifier: Apache-2.0
   ; k) Y( }1 x# u
5. *
   
6. * Change Logs:
   
7. * Date           Author       Notes
   , e/ X1 D$ F  p/ k6 s" Q5 F0 P
8. * 2020-03-23     ShineRoyal       the first version
     H& {8 b) c, ~" H; a7 ^0 f, Z
9. */
   
10. #include <rtthread.h>
    ' N  j2 I3 K9 a, H/ o! h1 a
11. #include <board.h>
    7 m- j- i# a5 R! N: w
12. #include <rtdevice.h>
    0 V9 q+ q( u9 C& w3 L
13. 
    ) u+ G2 \: M' c; _* e$ q; a1 o
14. #define DBG_TAG "user"
    
15. #define DBG_LVL DBG_LOG
    
16. #include <rtdbg.h>
    
17. 
    
18. #define LED0_PIN    GET_PIN(C, 0)
    $ }6 P7 N9 K8 d8 C, j
19. #define LED1_PIN    GET_PIN(C, 1)
    
20. #define LED2_PIN    GET_PIN(C, 2)
    
21. #define LED3_PIN    GET_PIN(C, 3)
    6 S. G" f; q9 ^1 C( M
22. #define LED4_PIN    GET_PIN(C, 4)
    
23. #define LED5_PIN    GET_PIN(C, 5)
    
24. #define LED6_PIN    GET_PIN(C, 6)
    7 c: b% s1 v+ ?- t3 [" c3 N2 p
25. #define LED7_PIN    GET_PIN(C, 7)
    ) v- G% w5 S6 V1 V% ~
26. 
    
27. 
    
28. static int rt_hw_pin_init()
    
29. {
    
30.     rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);
    2 @# N3 w0 B8 F; T' u
31.     rt_pin_mode(LED1_PIN, PIN_MODE_OUTPUT);
    4 }0 b  o: W) I) m" F2 q
32.     rt_pin_mode(LED2_PIN, PIN_MODE_OUTPUT);
    9 ?  u) z  s5 j. D* P! z/ H) ^
33.     rt_pin_mode(LED3_PIN, PIN_MODE_OUTPUT);
    & ~8 d& L2 u; l& m7 \
34.     rt_pin_mode(LED4_PIN, PIN_MODE_OUTPUT);
    
35.     rt_pin_mode(LED5_PIN, PIN_MODE_OUTPUT);
    % j9 y1 L$ u' u9 v* f
36.     rt_pin_mode(LED6_PIN, PIN_MODE_OUTPUT);
    
37.     rt_pin_mode(LED7_PIN, PIN_MODE_OUTPUT);
    
38.     return 0;
    " I: C5 X, ?' \! x: G1 m1 [
39. }
    : @' W/ I# A& g, r3 E
40. INIT_BOARD_EXPORT(rt_hw_pin_init);
    
41. 
    
42. /* 定时器超时回调函数 */
    0 c0 T) k* I/ c6 P- C5 [! a0 w2 f4 o
43. static rt_err_t timeout_cb1(rt_device_t dev, rt_size_t size)
    8 }& a5 Q/ K; x5 l. a
44. {
    1 r6 M7 d7 _: o5 M* v8 b; a
45.     static int i = 0;
    " g6 _& R9 J; \* u
46.     i++;
    
47.     if (i % 2)
    
48.         rt_pin_write(LED0_PIN, PIN_LOW);
    5 z6 A" [# ?3 W# o8 Z: G
49.     else
    , m* U; z4 ]% l' A
50.         rt_pin_write(LED0_PIN, PIN_HIGH);
    
51.     LOG_D("%d",i);
    ) t0 D) b: X2 p+ K- Q6 Q# T
52.     return 0;
    ) P: ?( [4 I" x! b
53. }
    
54. 
    
55. /* 定时器超时回调函数 */
    
56. static rt_err_t timeout_cb2(rt_device_t dev, rt_size_t size)
    
57. {
    
58.     static int i = 0;
    & Q9 ~. t& G9 q
59.     i++;
    
60.     if (i % 2)
    1 l* s7 d# Y9 |) t8 a( b
61.         rt_pin_write(LED1_PIN, PIN_LOW);
    6 I' Z& X3 x# D5 K' }: O
62.     else
    
63.         rt_pin_write(LED1_PIN, PIN_HIGH);
    
64.     return 0;
    " v, F+ d6 b+ c/ G/ e0 W9 `) {
65. }
    # S4 G# j3 O; {
66. 
    
67. /* 定时器超时回调函数 */
    , i3 _* a0 M& K% p; M  }+ E
68. static rt_err_t timeout_cb3(rt_device_t dev, rt_size_t size)
    
69. {
    
70.     static int i = 0;
    / N: e* d5 S* R" l
71.     i++;
    1 g, q6 {2 F* \7 F: y
72.     if (i % 2)
    - W2 N6 F7 }4 X  [  _. j& _. ~
73.         rt_pin_write(LED2_PIN, PIN_LOW);
    
74.     else
    $ l; C8 B! R+ h. L
75.         rt_pin_write(LED2_PIN, PIN_HIGH);
    9 `+ q/ F& J  s
76.     return 0;
    % M! w: d* ^. g8 K$ x2 T
77. }
    5 d! f6 c1 c6 ~" R
78. 
    
79. /* 定时器超时回调函数 */
    ' b' q3 C+ z6 D' j3 I. i# X
80. static rt_err_t timeout_cb4(rt_device_t dev, rt_size_t size)
    
81. {
    ; {4 \  \+ i9 J2 n/ K: O1 M, t
82.     static int i = 0;
    
83.     i++;
    
84.     if (i % 2)
    ; w, M% ?' M% F
85.         rt_pin_write(LED3_PIN, PIN_LOW);
    9 C* ~$ T% |" A) k; h- `
86.     else
    
87.         rt_pin_write(LED3_PIN, PIN_HIGH);
    9 X7 B4 b& E7 |& P3 a( G
88.     return 0;
    
89. }
    - f" }; _8 M: h: _3 V. i4 G- ]
90. 
    - V' b9 D5 c" p1 K  I0 f; G* M
91. /* 定时器超时回调函数 */
    
92. static rt_err_t timeout_cb5(rt_device_t dev, rt_size_t size)
    
93. {
    * @4 E3 A; l, A9 W# \6 Y
94.     static int i = 0;
    
95.     i++;
    ) t& a1 _# A# k! L1 U0 a
96.     if (i % 2)
    / O) B9 l( q; \5 U5 |
97.         rt_pin_write(LED4_PIN, PIN_LOW);
    - r0 N% M! b) a0 {
98.     else
    
99.         rt_pin_write(LED4_PIN, PIN_HIGH);
    7 \' g) C/ D! H. v
100.     return 0;
     
101. }
     - W& w* B. Q0 G" R! x: `7 G. g
102. 
     
103. 
     , O9 x; W! e' [; ?1 q9 Y/ s9 ~4 N
104. /* 定时器超时回调函数 */
     * X2 R/ T. S' W4 n8 n% b- Y$ T
105. static rt_err_t timeout_cb9(rt_device_t dev, rt_size_t size)
     
106. {
     
107.     static int i = 0;
     
108.     i++;
     $ s% ~9 u0 ?8 E, @5 s+ @
109.     if (i % 2)
     / X3 f+ T0 ]7 i8 J/ |9 C
110.         rt_pin_write(LED5_PIN, PIN_LOW);
     2 h* M8 i7 V' E& q$ x
111.     else
     
112.         rt_pin_write(LED5_PIN, PIN_HIGH);
     ' ~$ X7 {) k/ j: Q( }* f8 m& i
113.     return 0;
     % n" B& q6 ?. u; `
114. }
     1 a" w9 J8 A# I7 x/ `7 U
115. 
     & ]) f' @+ A( k$ c8 D3 P
116. /* 定时器超时回调函数 */
     2 s4 ~* ^  o3 \2 F
117. static rt_err_t timeout_cb10(rt_device_t dev, rt_size_t size)
     
118. {
     
119.     static int i = 0;
       a+ `& {5 W$ d8 o+ x* ~
120.     i++;
     
121.     if (i % 2)
     # i! m- t" R4 `+ b' O
122.         rt_pin_write(LED6_PIN, PIN_LOW);
     5 z6 t* `; g* M
123.     else
       F9 Q4 \% @  ]  S% a) p
124.         rt_pin_write(LED6_PIN, PIN_HIGH);
     ( k) e/ ]7 q; H
125.     return 0;
     1 K% G5 i( J! c. {' |: t  e
126. }
     9 y6 }5 a8 Y9 `! [
127. 
     5 P6 G$ V& o( [9 m, d
128. /* 定时器超时回调函数 */
     
129. static rt_err_t timeout_cb11(rt_device_t dev, rt_size_t size)
     $ {0 d2 |. ^9 m1 r" f
130. {
     6 J# f. V7 ~; S( i/ j+ U( v$ U$ l
131.     static int i = 0;
     ! R, y& n9 m0 r$ Y
132.     i++;
     
133.     if (i % 2)
     
134.         rt_pin_write(LED7_PIN, PIN_LOW);
     
135.     else
     
136.         rt_pin_write(LED7_PIN, PIN_HIGH);
     
137.     return 0;
     / k% V; E, x/ X" A# [+ _1 p! r
138. }
     
139. 
     ) w) {5 f( L- o/ o6 x6 {
140. 
     3 T) m6 K. u6 i3 V! B8 [% J2 d
141. static int hw1timer_sample(int argc, char *argv[])
     
142. {
     
143.     rt_err_t ret = RT_EOK;
       n. f4 V9 Y8 z( ~) j8 G; c" }5 ~+ H
144.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
145.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     * l, v' F7 z9 n( L7 Q6 b
146.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     ) ?$ ^7 I8 h# @4 ^
147. 
     
148.     /* 查找定时器设备 */
     ( c+ q5 N" D5 w: l* ^
149.     hw_dev = rt_device_find("timer1");
     
150.     /* 以读写方式打开设备 */
     , N4 u; S/ r. Z
151.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
152.     /* 设置超时回调函数 */
     ( {' f1 g* j1 f1 O
153.     rt_device_set_rx_indicate(hw_dev, timeout_cb1);
     
154.     /* 设置模式为周期性定时器 */
     ' A  y2 A: \; u( P0 F, A- `3 ^6 ?- O
155.     mode = HWTIMER_MODE_PERIOD;
     ; \/ x1 t7 _+ e5 ?2 J0 f
156.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
157.     /* 设置定时器超时值为5s并启动定时器 */
     
158.     timeout_s.sec = 1;      /* 秒 */
     1 f3 M, I  E4 x& M
159.     timeout_s.usec = 0;     /* 微秒 */
     
160.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     " U/ C. V, }, ?$ T3 Q8 G
161.     {
     
162.         rt_kprintf("set timeout value failed\n");
     
163.         return RT_ERROR;
     5 a( \4 O: @! Y. P3 a2 u( M; D8 K
164.     }
       F, V4 r5 j5 s4 C0 Z- x5 W: c
165.     return ret;
     9 \; N. P* {5 r
166. }
     * p) ?. Z& c4 @5 j: T
167. MSH_CMD_EXPORT(hw1timer_sample, hw1timer_sample);
     . j# J( S5 I6 e0 i7 b$ Z2 A/ P
168. 
     
169. static int hw2timer_sample(int argc, char *argv[])
       ^6 `1 W' z! t
170. {
     & j6 Z9 M8 {+ N$ L4 d* x3 v# [) N
171.     rt_err_t ret = RT_EOK;
     
172.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     % b" N* F' C% q& R" }3 r
173.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     ) K( ~( h0 ~6 M
174.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
175. 
     ; m2 D' L  A5 i2 R$ \- S9 y
176.     /* 查找定时器设备 */
     ' _1 y2 W# D$ g
177.     hw_dev = rt_device_find("timer2");
     # H; z  W# b9 x  ]8 o: `6 g
178.     /* 以读写方式打开设备 */
       m; s1 h  H; |: X
179.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
180.     /* 设置超时回调函数 */
     
181.     rt_device_set_rx_indicate(hw_dev, timeout_cb2);
     
182.     /* 设置模式为周期性定时器 */
     
183.     mode = HWTIMER_MODE_PERIOD;
     
184.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
185.     /* 设置定时器超时值为5s并启动定时器 */
     
186.     timeout_s.sec = 1;      /* 秒 */
     - p9 o; Z/ ]; z1 j: V* e
187.     timeout_s.usec = 0;     /* 微秒 */
     
188.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     
189.     {
     
190.         rt_kprintf("set timeout value failed\n");
     
191.         return RT_ERROR;
     
192.     }
     ( L' q5 [* G, e7 c: m7 r
193.     return ret;
     3 i$ g: m" q& ^  z( s5 X& a6 Y1 ?
194. }
     % e0 b+ f  P) Y" X+ W9 h4 ]
195. MSH_CMD_EXPORT(hw2timer_sample, hw2timer_sample);
     
196. 
     - R8 a7 H; n- i0 W
197. static int hw3timer_sample(int argc, char *argv[])
     
198. {
     
199.     rt_err_t ret = RT_EOK;
     ) h2 R. ^7 d- |: q5 ?4 Y
200.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
201.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
202.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     - f' ]/ H. m6 o4 Y2 o
203. 
     
204.     /* 查找定时器设备 */
     1 w9 L6 [. l2 m- f. ]
205.     hw_dev = rt_device_find("timer3");
     
206.     /* 以读写方式打开设备 */
     
207.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     7 v) Q' y' I4 N- X  l
208.     /* 设置超时回调函数 */
     
209.     rt_device_set_rx_indicate(hw_dev, timeout_cb3);
     % t- ]9 ?7 p# G# d* Y
210.     /* 设置模式为周期性定时器 */
     4 q* y1 G* p. X; |8 l0 F) \
211.     mode = HWTIMER_MODE_PERIOD;
     
212.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     0 j# C2 T5 }5 S6 O
213.     /* 设置定时器超时值为5s并启动定时器 */
     8 C' Y0 I  `% k. V* g
214.     timeout_s.sec = 1;      /* 秒 */
     
215.     timeout_s.usec = 0;     /* 微秒 */
     
216.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     
217.     {
     
218.         rt_kprintf("set timeout value failed\n");
     
219.         return RT_ERROR;
     # p" P2 A: X0 b: c# p6 q3 F
220.     }
     " a  F; u) F+ x
221.     return ret;
     
222. }
     
223. MSH_CMD_EXPORT(hw3timer_sample, hw3timer_sample);
     
224. 
     
225. static int hw4timer_sample(int argc, char *argv[])
     
226. {
     " e6 R: |9 g' g, d
227.     rt_err_t ret = RT_EOK;
     
228.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
229.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
230.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
231. 
     
232.     /* 查找定时器设备 */
     
233.     hw_dev = rt_device_find("timer4");
     2 ~; ~  p: G$ G1 p0 o) `: r
234.     /* 以读写方式打开设备 */
     
235.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     3 {, E0 i+ F; }
236.     /* 设置超时回调函数 */
     ( h5 ?" g: |* b5 e/ {
237.     rt_device_set_rx_indicate(hw_dev, timeout_cb4);
       D- C8 t* @8 |% P7 O
238.     /* 设置模式为周期性定时器 */
     4 G- h; F# N4 ^& E( T7 l
239.     mode = HWTIMER_MODE_PERIOD;
     3 J+ J! M+ D. u5 }% G8 H- x
240.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
241.     /* 设置定时器超时值为5s并启动定时器 */
     
242.     timeout_s.sec = 1;      /* 秒 */
     
243.     timeout_s.usec = 0;     /* 微秒 */
     
244.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     - ^" o0 T5 a/ e2 n; P
245.     {
     9 y% ]- q3 A* H! S3 r- I
246.         rt_kprintf("set timeout value failed\n");
     
247.         return RT_ERROR;
       ^3 u4 c& n4 m4 E  {) k3 a
248.     }
     - p: H) E/ v7 Y1 t# \7 L
249.     return ret;
     
250. }
     
251. MSH_CMD_EXPORT(hw4timer_sample, hw4timer_sample);
     
252. 
     
253. static int hw5timer_sample(int argc, char *argv[])
     5 E4 O. z$ R" s9 h* R
254. {
     
255.     rt_err_t ret = RT_EOK;
     
256.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     " t. ]1 `& Z7 n$ o) _+ K" W
257.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
258.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
259. 
     
260.     /* 查找定时器设备 */
     
261.     hw_dev = rt_device_find("timer5");
     
262.     /* 以读写方式打开设备 */
     
263.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
264.     /* 设置超时回调函数 */
       k$ A7 l& ]- T' X2 y) Y
265.     rt_device_set_rx_indicate(hw_dev, timeout_cb5);
     
266.     /* 设置模式为周期性定时器 */
     
267.     mode = HWTIMER_MODE_PERIOD;
     9 X5 y8 Z- r, U: y7 p
268.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     & g  @& M$ s; h3 Q$ Y
269.     /* 设置定时器超时值为5s并启动定时器 */
     8 G  C* L9 I2 }7 @9 f0 n! A
270.     timeout_s.sec = 1;      /* 秒 */
     # _/ f& ~: K, F) c' I
271.     timeout_s.usec = 0;     /* 微秒 */
     . @* ~# |8 u4 [) b* D- {+ j- G6 b4 x
272.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     2 T7 \$ h+ Y: ?' \$ L
273.     {
     
274.         rt_kprintf("set timeout value failed\n");
     
275.         return RT_ERROR;
     8 p: r: ^- y, n; u; y  G
276.     }
     
277.     return ret;
     
278. }
     % |0 L* s& r( x7 y
279. MSH_CMD_EXPORT(hw5timer_sample, hw5timer_sample);
     
280. 
     # d4 }; Q5 {8 y) Y& Q/ k) r6 g2 j
281. static int hw9timer_sample(int argc, char *argv[])
     , r& a' w5 E" R! K' M
282. {
     
283.     rt_err_t ret = RT_EOK;
     
284.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     4 {! M% R) `9 S0 b. n- n
285.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
286.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     6 B: I8 T+ m- g6 q
287. 
     
288.     /* 查找定时器设备 */
     6 y( z2 J8 X/ }, S: L& R) D% s
289.     hw_dev = rt_device_find("timer9");
     
290.     /* 以读写方式打开设备 */
     - `: Z' v% U/ G
291.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     4 x+ e. N0 I: {* g7 B/ h; n& x% i
292.     /* 设置超时回调函数 */
     / d$ J4 ^' y3 H$ t) R/ b
293.     rt_device_set_rx_indicate(hw_dev, timeout_cb9);
     . s! g* J. u- T* W
294.     /* 设置模式为周期性定时器 */
     2 R9 q! r% k' L
295.     mode = HWTIMER_MODE_PERIOD;
     
296.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
297.     /* 设置定时器超时值为5s并启动定时器 */
     
298.     timeout_s.sec = 1;      /* 秒 */
     # j0 N7 b0 c; Y, s0 p. O
299.     timeout_s.usec = 0;     /* 微秒 */
     
300.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     
301.     {
     
302.         rt_kprintf("set timeout value failed\n");
     % r9 O# }2 a4 o, j5 J5 W3 d
303.         return RT_ERROR;
     9 u& A! l. r6 D1 Y# x3 c- I- ?
304.     }
     
305.     return ret;
     6 L' O* A7 A8 C0 z1 h
306. }
     
307. MSH_CMD_EXPORT(hw9timer_sample, hw9timer_sample);
     
308. 
     7 f) U, J( E& y5 |4 J
309. static int hw10timer_sample(int argc, char *argv[])
     8 Z, u' m0 f% L* f) s2 I/ E
310. {
     * w4 E/ i0 U; ?( E6 n/ t. B# d
311.     rt_err_t ret = RT_EOK;
     
312.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     , ?7 _0 [# S3 [- x+ o, [- y
313.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
314.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
315. 
     1 @2 H5 b# D0 _  s
316.     /* 查找定时器设备 */
     
317.     hw_dev = rt_device_find("timer10");
     
318.     /* 以读写方式打开设备 */
     
319.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
320.     /* 设置超时回调函数 */
     
321.     rt_device_set_rx_indicate(hw_dev, timeout_cb10);
     
322.     /* 设置模式为周期性定时器 */
     0 d" R( y5 W8 S
323.     mode = HWTIMER_MODE_PERIOD;
     3 Z. q7 W- ?4 N/ V
324.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
325.     /* 设置定时器超时值为5s并启动定时器 */
     
326.     timeout_s.sec = 1;      /* 秒 */
     
327.     timeout_s.usec = 0;     /* 微秒 */
     / r' K4 R; o; u, o  G
328.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     
329.     {
     " x  {8 Z, O8 T/ S7 y! c2 ~3 W
330.         rt_kprintf("set timeout value failed\n");
     " a! g9 H( m2 g+ S2 [
331.         return RT_ERROR;
     
332.     }
     
333.     return ret;
     # W  |7 L  P. m2 b( Y6 f7 o' `
334. }
     8 g2 Q% S6 G! x: T; M! J" s
335. MSH_CMD_EXPORT(hw10timer_sample, hw10timer_sample);
     
336. 
     
337. static int hw11timer_sample(int argc, char *argv[])
     
338. {
     + v$ r6 Q1 H' s
339.     rt_err_t ret = RT_EOK;
     
340.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
341.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
342.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     7 D4 y$ h* M8 x: M" g; h% v
343. 
     5 C1 O" k  w; @4 c4 r
344.     /* 查找定时器设备 */
     
345.     hw_dev = rt_device_find("timer11");
     . ]+ o0 S- n: F
346.     /* 以读写方式打开设备 */
     
347.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
348.     /* 设置超时回调函数 */
     # T* S, T. u' P2 d5 Y; M6 _% N
349.     rt_device_set_rx_indicate(hw_dev, timeout_cb11);
     ; x4 H# d* ?3 P, w! Y! l% V
350.     /* 设置模式为周期性定时器 */
     
351.     mode = HWTIMER_MODE_PERIOD;
     * b  O" L1 J) s
352.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     1 |1 c% p0 {, l5 T. x
353.     /* 设置定时器超时值为5s并启动定时器 */
     
354.     timeout_s.sec = 1;      /* 秒 */
     0 U2 y% t0 p- l5 N& O1 e5 h( T
355.     timeout_s.usec = 0;     /* 微秒 */
     
356.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     
357.     {
     
358.         rt_kprintf("set timeout value failed\n");
     
359.         return RT_ERROR;
     
360.     }
     
361.     return ret;
     0 V6 U% h+ j  O. v/ y# z8 c
362. }
     
363. MSH_CMD_EXPORT(hw11timer_sample, hw11timer_sample);
     
364. 
     & J* g# N  h0 i! f

复制代码

注意，定时器1的定时会快一倍（这里是1s的间隔，但定时器1会500ms进一次中断），尚不清楚是rt-thread的库造成的还是硬件本身时钟相关的原因，后续在研究。
& l& @' n, B4 w————————————————
0 m: p: x. H/ K版权声明：小盼你最萌哒
如有侵权请联系删除