创建基于F411的芯片空工程。
/ q: J4 t( t5 n4 i% l0 B启用hwtimer：
4 M( d$ X* Z7 N


0 {, _' @, N0 p拷贝以下三个文件到drivers目录，路径分别为
. E1 D8 L) E# C: J& RC:\RT-ThreadStudio\download\rt-thread-sdk\rt-thread-src\v4.0.2\bsp\stm32\libraries\HAL_Drivers\config\f4
和 C:\RT-ThreadStudio\download\rt-thread-sdk\rt-thread-src\v4.0.2\bsp\stm32\libraries\HAL_Drivers 。
1 Y! Y9 `4 J1 X/ x

+ D0 Y5 H0 p2 g0 v1 M
+ O! i* Y" b( [注释掉drv_hwtimer.c中的#include "drv_config.h"。
取消注释stm32f4xx_hal_conf.h中的#define HAL_TIM_MODULE_ENABLED。
向tim_config.h添加#include <board.h>。
. V: l& N9 c( \向drv_hwtimer.c添加#include <rtdevice.h>。
* e5 i8 ^3 w! B/ w, ]6 o) x向drv_hwtimer.c添加#include <tim_config.h>。

7 k, l0 u$ x( K7 ]) k& h! r5 b; c* Z# O在board.h中定义需要使用的定时器：
, g9 C& \8 H# {9 E7 c! m
( |  |! Y( D& A1 ]# |

6 ~* ~7 d! H% _; o根据要使用的定时器，修改tim_config.h：

1. /*
   + m' j. P+ y+ i7 \
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   
3. *
   
4. * SPDX-License-Identifier: Apache-2.0
   ( `) o/ R$ N! N3 ]& O& J7 A& e
5. *
   & z# \8 o4 @: I
6. * Change Logs:
   
7. * Date           Author       Notes
   $ c: q$ H+ L3 ~/ v* X! V. j
8. * 2018-12-11     zylx         first version
     @) p( _6 r. j6 N% J
9. */
   
10. 
    ( ^: D+ s. q" g3 k& T" m1 b
11. #ifndef __TIM_CONFIG_H__
    ; q5 o0 B; t7 O! x8 U
12. #define __TIM_CONFIG_H__
    9 I* G2 j; z' U1 C
13. 
    
14. #include <rtthread.h>
    3 o+ D+ w9 C* s1 C
15. #include <board.h>
    
16. #ifdef __cplusplus
    
17. extern "C" {
    
18. #endif
    
19. 
    2 t9 Q( [" \: X/ y1 p
20. #ifndef TIM_DEV_INFO_CONFIG
    0 e& ~% B" K) @  [) r6 v
21. #define TIM_DEV_INFO_CONFIG                     \
    
22.     {                                           \
    
23.         .maxfreq = 1000000,                     \
    5 T: _* w7 R. C8 C) p; h
24.         .minfreq = 3000,                        \
    
25.         .maxcnt  = 0xFFFF,                      \
    " r9 t1 D) s9 f& F  \9 g( j3 q$ {
26.         .cntmode = HWTIMER_CNTMODE_UP,          \
    
27.     }
    3 t1 H0 y3 c3 P$ r( [' T
28. #endif /* TIM_DEV_INFO_CONFIG */
    & r7 `) ]! h/ f
29. 
    
30. 
    
31. #ifdef BSP_USING_TIM1
    % S: t9 n* r+ @0 h. B- e7 j3 W
32. #ifndef TIM1_CONFIG
    1 u3 n* n5 U" @8 m4 A2 k
33. #define TIM1_CONFIG                                        \
    
34.     {                                                       \
    
35.        .tim_handle.Instance     = TIM1,                    \
    
36.        .tim_irqn                = TIM1_UP_TIM10_IRQn,  \
    
37.        .name                    = "timer1",                \
    
38.     }
    ' u* A5 F5 h/ ]" G9 J2 \! a- [
39. #endif /* TIM11_CONFIG */
    
40. #endif /* BSP_USING_TIM11 */
    
41. 
    - O1 w! n5 ^; h( e$ v$ U
42. 
    ' w) S4 N; I/ a* [. g( T% w" P) \
43. 
    + [/ m& @* Y2 W
44. #ifdef BSP_USING_TIM2
    
45. #ifndef TIM2_CONFIG
    8 b3 H7 |3 k6 N# b9 M/ @
46. #define TIM2_CONFIG                                        \
    
47.     {                                                       \
    9 X. q  D5 z1 ]# M- h3 c0 r
48.        .tim_handle.Instance     = TIM2,                    \
    - D0 ^6 W7 D5 O- O& i$ {- @
49.        .tim_irqn                = TIM2_IRQn,  \
    + u+ r; j4 P8 O
50.        .name                    = "timer2",                \
    4 y; w2 v  v5 A$ X  z  e
51.     }
    
52. #endif /* TIM11_CONFIG */
    
53. #endif /* BSP_USING_TIM11 */
    * @9 I  v& T% v4 @0 r# S9 V
54. 
    
55. 
    5 h8 L( I" ?" m2 }1 J
56. 
    7 x" S. N* N4 @7 o" {3 v9 {
57. #ifdef BSP_USING_TIM3
    ' L9 w* m* q6 d# Y3 a9 z; L1 G- z
58. #ifndef TIM3_CONFIG
    
59. #define TIM3_CONFIG                                        \
    
60.     {                                                       \
    
61.        .tim_handle.Instance     = TIM3,                    \
    4 B+ N* a  A- I. A: G
62.        .tim_irqn                = TIM3_IRQn,  \
    
63.        .name                    = "timer3",                \
    
64.     }
    7 \0 J. G7 ]+ f3 [1 h: d! m
65. #endif /* TIM11_CONFIG */
    6 z! {/ q( q' z' F0 l* a2 X
66. #endif /* BSP_USING_TIM11 */
    / l8 c5 w( q( C3 {9 h& I" f
67. 
    4 R+ \  `2 B: c) F% V
68. 
    9 m1 b. R! I- Z( h! n3 {! x
69. 
    
70. 
    2 B8 o4 w; T" ]; l3 L0 g" b
71. #ifdef BSP_USING_TIM4
    
72. #ifndef TIM4_CONFIG
    
73. #define TIM4_CONFIG                                        \
    
74.     {                                                       \
    
75.        .tim_handle.Instance     = TIM4,                    \
    
76.        .tim_irqn                = TIM4_IRQn,  \
    
77.        .name                    = "timer4",                \
      i  C/ t9 x! t5 t5 F1 v
78.     }
    & P, u- b/ v0 \8 O0 G  m
79. #endif /* TIM11_CONFIG */
    
80. #endif /* BSP_USING_TIM11 */
    / v- X7 Q, _% z7 {. Z- {
81. 
    . F' K0 H3 e2 U5 [
82. #ifdef BSP_USING_TIM5
    
83. #ifndef TIM5_CONFIG
    
84. #define TIM5_CONFIG                                        \
    $ B; e+ L2 J  F- p0 E: K
85.     {                                                       \
      g& u. Y+ S' H: j- l) W& t
86.        .tim_handle.Instance     = TIM5,                    \
    5 T& B- M# k% Q. ~" ?/ y
87.        .tim_irqn                = TIM5_IRQn,  \
    3 |7 K0 E& j2 v
88.        .name                    = "timer5",                \
    
89.     }
    ! E/ X2 q0 G$ K6 m* [4 n8 ?2 l
90. #endif /* TIM11_CONFIG */
    
91. #endif /* BSP_USING_TIM11 */
    
92. 
    8 d" r1 b9 E! F; E; _: C- ~: K
93. #ifdef BSP_USING_TIM9
    
94. #ifndef TIM9_CONFIG
      W. g  I/ v" `! I: r3 Y7 N
95. #define TIM9_CONFIG                                        \
    7 X+ c# X- @1 E+ I9 \
96.     {                                                       \
    
97.        .tim_handle.Instance     = TIM9,                    \
    
98.        .tim_irqn                = TIM1_BRK_TIM9_IRQn,  \
    : s- z, @# G( }7 ^1 k
99.        .name                    = "timer9",                \
    9 A, ?8 m( x4 T: Q, `
100.     }
     
101. #endif /* TIM11_CONFIG */
     
102. #endif /* BSP_USING_TIM11 */
     1 u' r; n5 ?  X. o* l
103. 
     
104. #ifdef BSP_USING_TIM10
     
105. #ifndef TIM10_CONFIG
     4 b! N3 P' C( j5 \
106. #define TIM10_CONFIG                                        \
     ) d4 I7 l0 m) v6 T
107.     {                                                       \
     
108.        .tim_handle.Instance     = TIM10,                    \
     
109.        .tim_irqn                = TIM1_UP_TIM10_IRQn,  \
     " a" W' _, I- v1 T! T; a
110.        .name                    = "timer10",                \
     
111.     }
     
112. #endif /* TIM11_CONFIG */
     8 k1 O, Y  B, H3 n$ n
113. #endif /* BSP_USING_TIM11 */
     / u5 `. |0 B/ c, f; a
114. 
     ( F9 o/ i! N  Z8 u  q
115. #ifdef BSP_USING_TIM11
     4 g( G0 v' Y) |8 }6 \: l) A
116. #ifndef TIM11_CONFIG
     " o( B1 _4 m* V* E) G8 }4 ^
117. #define TIM11_CONFIG                                        \
     $ ?4 D: @# k. Q( G1 ^, A' W6 K
118.     {                                                       \
     
119.        .tim_handle.Instance     = TIM11,                    \
     
120.        .tim_irqn                = TIM1_TRG_COM_TIM11_IRQn,  \
     : N" Z& r* {6 A! z! A& n
121.        .name                    = "timer11",                \
     & v8 V, ]7 g8 Z% S9 a1 z
122.     }
     
123. #endif /* TIM11_CONFIG */
     
124. #endif /* BSP_USING_TIM11 */
     ; ]+ s2 M* d2 Y4 {9 J+ k
125. 
     
126. 
     
127. 
     
128. #ifdef __cplusplus
     % U3 l8 R' B, H; D
129. }
     ; \9 [, F$ j) L. d+ D6 i8 ~' B
130. #endif
     ' ?' u; Y" K3 R
131. 
     ' ?' F) J, O. n+ a. Y1 T
132. #endif /* __TIM_CONFIG_H__ */
     2 j. ~7 e" g/ Y# \% p+ }4 |

复制代码

% b5 M3 C* Y" h0 K在drv_hwtimer.h中增加CubeMX生成的底层代码：

1. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
   
2. {
   : F% R! p) k7 `4 D3 V. J2 e
3.     if (htim_base->Instance == TIM1)
   1 R1 F" J3 o4 i
4.     {
   
5.         __HAL_RCC_TIM1_CLK_ENABLE();
   
6.     }
   
7.     else if (htim_base->Instance == TIM2)
   " Y$ @) J" P) m# P# z
8.     {
   " T2 b9 p+ V" }# b! P
9.         __HAL_RCC_TIM2_CLK_ENABLE();
   - x! }: @( x6 Q9 W1 I
10.     }
    - U1 e# t/ v5 _9 ^
11.     else if (htim_base->Instance == TIM3)
    6 B8 ~; i; R3 p' C
12.     {
    # i* M3 q' W: w: e: {" w1 L
13.         __HAL_RCC_TIM3_CLK_ENABLE();
    4 C# I$ {1 X7 C; h; ]: t5 A  s
14.     }
    0 Z8 o, K4 M# q4 {" A: Q- k9 `' w
15.     else if (htim_base->Instance == TIM4)
    
16.     {
    
17.         __HAL_RCC_TIM4_CLK_ENABLE();
    + G% M) V5 R0 W
18.     }
    " b1 M+ r) {6 `
19.     else if (htim_base->Instance == TIM5)
    
20.     {
    
21.         __HAL_RCC_TIM5_CLK_ENABLE();
    
22.     }
    + |0 Q1 c$ z& B+ g6 _: ?$ P$ P
23.     else if (htim_base->Instance == TIM9)
    3 g6 {4 z! T- Y7 x2 X7 A/ A! {
24.     {
    9 D5 c* F1 `/ f$ K2 W# \: T. L
25.         __HAL_RCC_TIM9_CLK_ENABLE();
    
26.     }
    , u/ n) a: w9 ?
27.     else if (htim_base->Instance == TIM10)
    + W! r' M- b+ v8 R, n+ E
28.     {
    ' U% x6 D. n. E1 X4 G, d% \& m$ y7 x# C
29.         __HAL_RCC_TIM10_CLK_ENABLE();
    
30.     }
    & p: q5 \) E: |; t
31.     else if (htim_base->Instance == TIM11)
    
32.     {
    
33.         __HAL_RCC_TIM11_CLK_ENABLE();
    
34.     }
    
35. }
    7 a/ P# P! [  Z0 K" s' z6 e

复制代码

修改drv_hwtimer.h中HAL_TIM_PeriodElapsedCallback，为使用的定时器添加回调函数：
; ^  i% \) l0 j: X

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   ' E, \8 T/ [; j/ @7 Q, f' ?8 z
2. {
   
3. #ifdef BSP_USING_TIM1
   1 C0 d, c; v8 R+ P. o! Z
4. if (htim->Instance == TIM1)
   
5. {
   1 L3 r# a7 F$ b( o6 d0 T. f
6.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM1_INDEX].time_device);
   ! N2 [# E2 b0 Q; v' a" g4 s* [
7. }
   4 ]& ^6 i/ D8 L7 e. b2 \) s
8. #endif
   * f  e0 `" f+ b1 I
9. #ifdef BSP_USING_TIM2
   9 ~0 B- g' j% A8 f% c9 r
10. if (htim->Instance == TIM2)
    
11. {
    
12.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM2_INDEX].time_device);
    ( K- j+ J1 v/ o+ j0 Q
13. }
    2 A1 s, i# m9 U: y2 d$ Q/ ^" L
14. #endif
    - G+ k/ y3 Z6 i  {# ~4 r
15. #ifdef BSP_USING_TIM3
    
16. if (htim->Instance == TIM3)
    
17. {
    
18.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM3_INDEX].time_device);
    
19. }
    
20. #endif
    ; r6 q4 z1 l% P0 J( k
21. #ifdef BSP_USING_TIM4
    
22. if (htim->Instance == TIM4)
    
23. {
    " \2 j( D" ]6 D% J0 H! y& ]
24.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM4_INDEX].time_device);
    % l( J3 w- t" ?/ `/ Y; w0 {
25. }
    % G; c+ r9 r/ u6 s
26. #endif
    
27. #ifdef BSP_USING_TIM5
    ' Q* i9 Y/ Z6 V
28. if (htim->Instance == TIM5)
    . M' |( n* G! d. P, t+ L. E
29. {
    
30.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM5_INDEX].time_device);
    / w, |3 {' x/ \& v3 c
31. }
    
32. #endif
    
33. #ifdef BSP_USING_TIM9
    
34. if (htim->Instance == TIM9)
    3 M9 n6 z4 Z/ e+ s1 M, r9 P
35. {
    
36.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM9_INDEX].time_device);
    
37. }
    
38. #endif
    % P+ n0 d3 V, v+ B; x. w
39. #ifdef BSP_USING_TIM10
    * |4 V# d  Z- b. f; \* C/ x- Y0 l& d, T
40. if (htim->Instance == TIM10)
    
41. {
    
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)
    
47. {
    $ _# i+ C2 h# L9 {2 Y% m
48.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM11_INDEX].time_device);
    + m. M$ d% D6 n' X) Z
49. }
    1 ]# `) k6 G& e( o3 a
50. #endif
    # i& b! `  i2 {  R" a. e- l5 c
51. }
    % t' I) V4 Q; R: A! T" |& f

复制代码

' K# H2 P0 s  J! ~$ E添加中断函数入口：

1. #ifdef BSP_USING_TIM2
   " A5 q, K4 ?; ?6 V: a# }  d
2. void TIM2_IRQHandler(void)
   1 i0 W4 s+ D; S5 m
3. {
   
4. /* enter interrupt */
   & f$ L: y# R( B9 S- D  |
5. rt_interrupt_enter();
   
6. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM2_INDEX].tim_handle);
   ) @0 y* R4 J% V0 v, ?8 Y
7. /* leave interrupt */
   , k% H0 K1 r1 E/ v7 K, O/ G2 f, D
8. rt_interrupt_leave();
   4 S6 {, a) N2 J$ h3 |+ ~+ c
9. }
   2 y3 s/ f/ L, @' W! M! p& V; W" M
10. #endif
    
11. #ifdef BSP_USING_TIM3
    
12. void TIM3_IRQHandler(void)
    2 r, `) v, H4 F( Z" J# y3 [$ B; @  W, H2 q
13. {
    
14. /* enter interrupt */
    
15. rt_interrupt_enter();
      e1 \0 H" G/ H- G
16. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM3_INDEX].tim_handle);
    
17. /* leave interrupt */
    
18. rt_interrupt_leave();
    # R8 e: E4 q/ ^" K- [" ]  k
19. }
    
20. #endif
    / l" O5 h7 `, @% E+ K& @; Q
21. #ifdef BSP_USING_TIM4
    ' p- i8 Q9 {/ R# |8 b8 e# V
22. void TIM4_IRQHandler(void)
    6 g( x0 B- F$ L0 v
23. {
    
24. /* enter interrupt */
    
25. rt_interrupt_enter();
    
26. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM4_INDEX].tim_handle);
    
27. /* leave interrupt */
    7 F' I! k8 i  l; K* F! o1 }
28. rt_interrupt_leave();
    
29. }
    
30. #endif
    * r& `4 {& L3 ~- F" D
31. #ifdef BSP_USING_TIM5
    2 j! S* s$ M: e# V& H  T5 A
32. void TIM5_IRQHandler(void)
    . U/ c5 P3 s1 X% I6 d
33. {
    
34. /* enter interrupt */
    
35. rt_interrupt_enter();
    
36. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM5_INDEX].tim_handle);
    ' S8 B+ `! R* x) k# h5 T. o
37. /* leave interrupt */
    7 K" t- E) ~& L: c& N
38. rt_interrupt_leave();
    , q# }; I5 p( m3 D
39. }
    - A- k* W2 o, B) F4 D# b0 ?
40. #endif
    
41. #ifdef BSP_USING_TIM11
    0 e1 N5 g2 ]& _  P4 c, Q
42. void TIM1_BRK_TIM9_IRQHandler(void)
    & R% U% y' r7 z" T: \/ I% B
43. {
    9 R4 y. e  O5 n9 R/ O
44. /* enter interrupt */
    8 D" r! m8 |  U
45. rt_interrupt_enter();
    ' ~9 A* ~; a6 m7 n+ Y7 I# @
46. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM9_INDEX].tim_handle);
      k9 f5 y; u6 k$ }( K8 D
47. /* leave interrupt */
    
48. rt_interrupt_leave();
    
49. }
    
50. #endif
    - }# s% `% l6 i4 ^
51. 
    2 j" D" G4 z* }3 v( j
52. #if defined( BSP_USING_TIM1) ||defined(BSP_USING_TIM10)
    6 ]( y: P- q1 y" e0 }
53. void TIM1_UP_TIM10_IRQHandler(void)
    1 e5 ?5 W" C+ l" I# k
54. {
    
55. /* enter interrupt */
    % c; A8 l8 B0 h4 f) Q' e
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)
    
59.     HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM1_INDEX].tim_handle);
    9 n) p/ S! S" \# Y
60. #endif
    : e( V' A1 u( U' E" R
61. #ifdef BSP_USING_TIM10
    . I6 ^* B. N% d
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. 
    
66. /* leave interrupt */
    ! D+ x; j/ O& h% H8 J0 V, S
67. rt_interrupt_leave();
    6 f! G6 K5 y" Y
68. }
    * {8 m; ?! |# l/ u
69. #endif
    
70. 
    # e) P, }5 P+ X& n0 R9 a# Y
71. #ifdef BSP_USING_TIM11
    
72. void TIM1_TRG_COM_TIM11_IRQHandler(void)
    
73. {
      r! r+ |: l5 O/ c+ L# |* j& k* |
74. /* enter interrupt */
    
75. rt_interrupt_enter();
    , x3 R! I  W) u4 y7 H* ?, ~9 D# Y
76. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM11_INDEX].tim_handle);
    
77. /* leave interrupt */
    
78. rt_interrupt_leave();
    
79. }
    
80. #endif
    - y$ q' B- o' L2 v0 W& Q

复制代码

新建一个usertimer.c，添加示例代码，通过msh调用即可看到效果：
$ W3 b+ Z& e  j; T  Z

1. /*
   * }* w7 ?1 l2 N5 }% q8 ]2 a7 f
2. * Copyright (c) 2006-2020, RT-Thread Development Team
   6 K) l; d2 h& T% P
3. *
   1 B4 m. }6 x" f: f
4. * SPDX-License-Identifier: Apache-2.0
   
5. *
   - i  J" C+ T0 w& j3 [/ ]
6. * Change Logs:
   
7. * Date           Author       Notes
   # \4 e8 l1 x) R
8. * 2020-03-23     ShineRoyal       the first version
   3 N) W! N5 G. w! g6 R
9. */
     K1 l, u9 T& J+ w- F
10. #include <rtthread.h>
    * o( ~. `$ @- P
11. #include <board.h>
    
12. #include <rtdevice.h>
    . A& K2 d  A2 _9 U+ W' n
13. 
    
14. #define DBG_TAG "user"
    + o! H3 q. M+ p
15. #define DBG_LVL DBG_LOG
    
16. #include <rtdbg.h>
    % _' ?2 a. Z+ h. X4 ?
17. 
    $ f) }5 V( M: ]
18. #define LED0_PIN    GET_PIN(C, 0)
    
19. #define LED1_PIN    GET_PIN(C, 1)
    
20. #define LED2_PIN    GET_PIN(C, 2)
    2 h/ o" ]+ G- t8 G' e4 P5 N
21. #define LED3_PIN    GET_PIN(C, 3)
    
22. #define LED4_PIN    GET_PIN(C, 4)
    6 E! v: L( }" X: X  v- U# k* S" ]
23. #define LED5_PIN    GET_PIN(C, 5)
    5 M. I9 W1 R% H: I/ F1 F& ~
24. #define LED6_PIN    GET_PIN(C, 6)
    / T4 k1 {4 {1 [+ _1 D! R! F9 j
25. #define LED7_PIN    GET_PIN(C, 7)
    
26. 
    
27. 
    8 p4 @# k* n/ m# B7 e4 m, [- y+ @4 g
28. static int rt_hw_pin_init()
    
29. {
    
30.     rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);
    
31.     rt_pin_mode(LED1_PIN, PIN_MODE_OUTPUT);
    + O# L+ A( d6 L8 w- z- _
32.     rt_pin_mode(LED2_PIN, PIN_MODE_OUTPUT);
    / M: `% b( j, {* j; x( y, v
33.     rt_pin_mode(LED3_PIN, PIN_MODE_OUTPUT);
    
34.     rt_pin_mode(LED4_PIN, PIN_MODE_OUTPUT);
    
35.     rt_pin_mode(LED5_PIN, PIN_MODE_OUTPUT);
    
36.     rt_pin_mode(LED6_PIN, PIN_MODE_OUTPUT);
    3 J( k  @$ l/ q* H4 {( z
37.     rt_pin_mode(LED7_PIN, PIN_MODE_OUTPUT);
    " C9 J7 G/ K0 }8 v. B5 g- ?7 Z. f
38.     return 0;
    4 {, a( u: x- I0 ~  I# x* |' c' W
39. }
    " B6 Y& e3 x: r6 O& ?1 M
40. INIT_BOARD_EXPORT(rt_hw_pin_init);
      O& B1 k3 B5 Q/ m5 G% t0 e
41. 
    
42. /* 定时器超时回调函数 */
    * z+ [5 G$ m2 ?" r. P& I
43. static rt_err_t timeout_cb1(rt_device_t dev, rt_size_t size)
    
44. {
    
45.     static int i = 0;
    
46.     i++;
    
47.     if (i % 2)
    
48.         rt_pin_write(LED0_PIN, PIN_LOW);
    7 b+ @' H2 V+ a. y7 a% f& `
49.     else
    
50.         rt_pin_write(LED0_PIN, PIN_HIGH);
    
51.     LOG_D("%d",i);
    / m# M0 X2 }+ l' E6 Q2 E6 z/ l
52.     return 0;
    
53. }
    
54. 
    & Y7 k! f! M9 W4 Q" n
55. /* 定时器超时回调函数 */
    ' Q/ I6 e4 b7 L' S6 F3 e
56. static rt_err_t timeout_cb2(rt_device_t dev, rt_size_t size)
    
57. {
    
58.     static int i = 0;
    : \$ G/ r5 M$ r2 h- X7 P) c) `' S0 S
59.     i++;
    7 d) T  O2 n, ]' c! H
60.     if (i % 2)
    
61.         rt_pin_write(LED1_PIN, PIN_LOW);
    
62.     else
    7 v% B$ \1 J2 R/ H' }: u6 L# M; A/ }
63.         rt_pin_write(LED1_PIN, PIN_HIGH);
    4 T1 V  ^5 }+ p8 z8 |8 Q
64.     return 0;
    
65. }
    
66. 
    2 M2 \0 W6 v# w( z  ]6 X
67. /* 定时器超时回调函数 */
    
68. static rt_err_t timeout_cb3(rt_device_t dev, rt_size_t size)
    
69. {
    
70.     static int i = 0;
    
71.     i++;
    : X9 \9 i0 u1 i
72.     if (i % 2)
      _( S. {8 J% [! o
73.         rt_pin_write(LED2_PIN, PIN_LOW);
    
74.     else
    
75.         rt_pin_write(LED2_PIN, PIN_HIGH);
    1 I- m. g9 G  e- X
76.     return 0;
    1 n7 w; d# H$ w
77. }
    4 M3 Q, X% T9 e4 {2 k
78. 
    # {4 Z0 q, T8 j3 F) z$ A9 z
79. /* 定时器超时回调函数 */
    
80. static rt_err_t timeout_cb4(rt_device_t dev, rt_size_t size)
    
81. {
      n/ i. n% c: \/ M
82.     static int i = 0;
    2 o- @+ c' G) n. t* H9 D
83.     i++;
    
84.     if (i % 2)
    
85.         rt_pin_write(LED3_PIN, PIN_LOW);
    / ]: ^. f/ L) I: c6 D/ H& U: o
86.     else
    ! M. I( f4 G+ F5 _. X7 _8 M  f5 P
87.         rt_pin_write(LED3_PIN, PIN_HIGH);
    9 c. f- Z; e9 x9 ~. W/ M- Y
88.     return 0;
      W) f! ?2 G- t/ V" x9 ^9 J
89. }
    
90. 
    
91. /* 定时器超时回调函数 */
    
92. static rt_err_t timeout_cb5(rt_device_t dev, rt_size_t size)
    
93. {
    8 O( d0 ~# t6 |$ H3 ]- G7 r8 G
94.     static int i = 0;
    
95.     i++;
    / X9 r5 M( c; w/ b$ Z
96.     if (i % 2)
    5 G8 b8 a8 x1 e9 G2 S: f7 A* a. T
97.         rt_pin_write(LED4_PIN, PIN_LOW);
    
98.     else
    
99.         rt_pin_write(LED4_PIN, PIN_HIGH);
    ' }8 Y* p4 s2 J& r0 ]5 D! t' P
100.     return 0;
       v" U0 A& |# N0 O. F9 v# e
101. }
     6 i: C$ k" ?5 I2 j% g& T& M
102. 
     
103. 
     
104. /* 定时器超时回调函数 */
     
105. static rt_err_t timeout_cb9(rt_device_t dev, rt_size_t size)
     
106. {
     8 t+ S0 t9 b) S8 f
107.     static int i = 0;
     8 ~1 M- \5 u# p% q+ P
108.     i++;
     " |2 x; J1 h# ?6 N: u( U
109.     if (i % 2)
     
110.         rt_pin_write(LED5_PIN, PIN_LOW);
     $ ^4 \( @' C1 ^$ ]6 T# c" e) R3 K" J
111.     else
     
112.         rt_pin_write(LED5_PIN, PIN_HIGH);
     
113.     return 0;
     
114. }
     2 M' V" g! c& }  d* U
115. 
     
116. /* 定时器超时回调函数 */
     
117. static rt_err_t timeout_cb10(rt_device_t dev, rt_size_t size)
     ) `# c1 j5 ]; O) @1 p
118. {
     
119.     static int i = 0;
     % m, M! {3 ^# z+ e
120.     i++;
       x7 o- y% x" I4 J' S  }
121.     if (i % 2)
     
122.         rt_pin_write(LED6_PIN, PIN_LOW);
     
123.     else
     6 w4 T% ~$ L; f6 h9 z  Q* {$ r
124.         rt_pin_write(LED6_PIN, PIN_HIGH);
     . M- _- N' H! F# x5 B" m# E8 j& ^$ M
125.     return 0;
     
126. }
     6 B7 J$ o& D7 s5 w9 V
127. 
     " i" N7 K. V$ h: A( |
128. /* 定时器超时回调函数 */
     
129. static rt_err_t timeout_cb11(rt_device_t dev, rt_size_t size)
     
130. {
     
131.     static int i = 0;
     
132.     i++;
     & P* m. a. f, X5 a2 G2 n+ A
133.     if (i % 2)
     
134.         rt_pin_write(LED7_PIN, PIN_LOW);
     
135.     else
     
136.         rt_pin_write(LED7_PIN, PIN_HIGH);
     + I# r+ z6 C9 `' j
137.     return 0;
     
138. }
     ; E1 J5 b8 K7 H  i1 I. g( h, f' ?
139. 
     
140. 
     
141. static int hw1timer_sample(int argc, char *argv[])
     
142. {
     
143.     rt_err_t ret = RT_EOK;
     
144.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
145.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
146.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
147. 
     
148.     /* 查找定时器设备 */
     6 a  G) l2 p; R5 J, K; x- V
149.     hw_dev = rt_device_find("timer1");
       o3 q5 N; c' [+ y- [& L7 N
150.     /* 以读写方式打开设备 */
     
151.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
152.     /* 设置超时回调函数 */
     
153.     rt_device_set_rx_indicate(hw_dev, timeout_cb1);
     
154.     /* 设置模式为周期性定时器 */
     9 f% w/ m7 A4 E/ s3 O
155.     mode = HWTIMER_MODE_PERIOD;
     ( g% ^- f* M* ]5 k6 P
156.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
157.     /* 设置定时器超时值为5s并启动定时器 */
     7 ~6 J! t8 y! W+ p& ~
158.     timeout_s.sec = 1;      /* 秒 */
     
159.     timeout_s.usec = 0;     /* 微秒 */
     
160.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     8 }* U+ E; T9 |9 ^- ~
161.     {
     5 U% F2 ?: d4 r* ^2 c2 {
162.         rt_kprintf("set timeout value failed\n");
     ! E; s0 }6 `# x2 C
163.         return RT_ERROR;
     
164.     }
     ; M, }, x0 E' E, ?0 l' z; ]1 ?
165.     return ret;
     
166. }
     - g; H' U& f2 c# u/ @' b
167. MSH_CMD_EXPORT(hw1timer_sample, hw1timer_sample);
     
168. 
     . P  j4 M  {* F  s+ a' w: f
169. static int hw2timer_sample(int argc, char *argv[])
     
170. {
     
171.     rt_err_t ret = RT_EOK;
     ; n/ C3 x% ?7 M5 ~  h5 f$ Y! L
172.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
173.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
174.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
175. 
     " e2 U8 T; R/ m
176.     /* 查找定时器设备 */
     " ~3 K' D9 T  ^0 F
177.     hw_dev = rt_device_find("timer2");
     4 X0 Y) @' t/ Q& ~3 Y+ f% x
178.     /* 以读写方式打开设备 */
     
179.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     % G" m: u% h; h/ i& ^) G
180.     /* 设置超时回调函数 */
     6 S  I, Q* Q' c: O
181.     rt_device_set_rx_indicate(hw_dev, timeout_cb2);
     
182.     /* 设置模式为周期性定时器 */
     . ^0 c9 d# b$ t. P7 ^) f) n
183.     mode = HWTIMER_MODE_PERIOD;
     . ^* i* _$ O0 G9 [  F
184.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     6 `3 Q4 s9 J: B+ |. e# v
185.     /* 设置定时器超时值为5s并启动定时器 */
     * v9 k  _* C1 `
186.     timeout_s.sec = 1;      /* 秒 */
     
187.     timeout_s.usec = 0;     /* 微秒 */
     % K& K" u9 x! H  E% |; _% d
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");
     : J/ A/ k5 _- t/ o) q+ \; q
191.         return RT_ERROR;
     
192.     }
     
193.     return ret;
     ! ]% ~) v) m/ |4 Q
194. }
     
195. MSH_CMD_EXPORT(hw2timer_sample, hw2timer_sample);
     
196. 
     & S- R5 J: _# K( }& ~7 G$ e& V
197. static int hw3timer_sample(int argc, char *argv[])
     + }9 ]% s- v# I  {2 x  i- d
198. {
     ! @" C; O% ?3 G5 U$ J7 U, `
199.     rt_err_t ret = RT_EOK;
     
200.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     & ~9 N/ g9 Q! c- w( S
201.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
202.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
203. 
     
204.     /* 查找定时器设备 */
     
205.     hw_dev = rt_device_find("timer3");
     
206.     /* 以读写方式打开设备 */
     / N: G! f" Y) W* s# X5 ]! u4 V, P4 ~
207.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     ; _1 K* Y) }2 L7 o
208.     /* 设置超时回调函数 */
     
209.     rt_device_set_rx_indicate(hw_dev, timeout_cb3);
     ) G! M8 O; [+ C" ?5 S0 j+ F; _
210.     /* 设置模式为周期性定时器 */
     * U2 @1 o! i% ^% e  F
211.     mode = HWTIMER_MODE_PERIOD;
     ( ]4 H# R# h. [) |# T& Y" s7 I7 l
212.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
       D  Q4 t3 g. T! _8 F3 H+ l
213.     /* 设置定时器超时值为5s并启动定时器 */
     ; k; Z7 O$ H. O5 i# X/ N
214.     timeout_s.sec = 1;      /* 秒 */
     
215.     timeout_s.usec = 0;     /* 微秒 */
     ' e& q8 P% }- @& @% z2 i% [; _
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");
     5 T/ Q5 k' Q9 W" }; U9 s* C
219.         return RT_ERROR;
     . C- ], P$ @/ V, ~
220.     }
     # I; R( M$ W) r
221.     return ret;
     ( X7 J/ H4 h  ]1 V: X3 D
222. }
     
223. MSH_CMD_EXPORT(hw3timer_sample, hw3timer_sample);
     . ~$ l1 m, ]% T1 J, z: D
224. 
     
225. static int hw4timer_sample(int argc, char *argv[])
     6 O- J" _/ E0 o
226. {
     " I8 x# T( ]3 R
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. 
     " T4 S0 M7 |6 K( x- \8 v# N* c3 E
232.     /* 查找定时器设备 */
     2 i. u9 L' Q# O3 w- o. A- G
233.     hw_dev = rt_device_find("timer4");
     
234.     /* 以读写方式打开设备 */
     3 ?  t( Z7 p1 ^, m4 h. U
235.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     / g6 l* D. j/ q
236.     /* 设置超时回调函数 */
     - o9 o7 N) y5 r! w1 U' m: y( ]2 D
237.     rt_device_set_rx_indicate(hw_dev, timeout_cb4);
     
238.     /* 设置模式为周期性定时器 */
     / ^8 C1 F  @& J! u7 J$ X& _
239.     mode = HWTIMER_MODE_PERIOD;
     $ D9 j5 O5 ]4 V: F! E
240.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
241.     /* 设置定时器超时值为5s并启动定时器 */
     
242.     timeout_s.sec = 1;      /* 秒 */
     3 m& z. _7 H. [7 N
243.     timeout_s.usec = 0;     /* 微秒 */
     
244.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     
245.     {
     
246.         rt_kprintf("set timeout value failed\n");
     
247.         return RT_ERROR;
     
248.     }
     
249.     return ret;
     
250. }
     2 s) g$ P8 h$ f. x
251. MSH_CMD_EXPORT(hw4timer_sample, hw4timer_sample);
     
252. 
     ! [5 S: `  M# e; Q) O2 e
253. static int hw5timer_sample(int argc, char *argv[])
     
254. {
     - [1 s* }" [$ R% M1 O
255.     rt_err_t ret = RT_EOK;
     / V( \1 D) N1 [" G: H
256.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     6 M! [, k& s6 w. e  d( O$ \8 }
257.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
258.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     , i! ?8 C! S) u! G- ^+ e5 P
259. 
     4 I4 z' _6 x( ^: D' T) n7 q& {
260.     /* 查找定时器设备 */
     ! J3 u+ ?# l  u- J
261.     hw_dev = rt_device_find("timer5");
     
262.     /* 以读写方式打开设备 */
     ; l, @" `% j9 J! n9 W8 K
263.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     % o8 Y: O' y2 A9 c( S0 J- ^
264.     /* 设置超时回调函数 */
     
265.     rt_device_set_rx_indicate(hw_dev, timeout_cb5);
     
266.     /* 设置模式为周期性定时器 */
     
267.     mode = HWTIMER_MODE_PERIOD;
     3 v. U6 d1 h0 ?3 o, J6 O' [7 i1 A- P* s
268.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     , E1 x" q# _: d: Q  d5 y& C: }
269.     /* 设置定时器超时值为5s并启动定时器 */
     
270.     timeout_s.sec = 1;      /* 秒 */
     $ u3 g9 V9 W" j& `
271.     timeout_s.usec = 0;     /* 微秒 */
     
272.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     9 f, ^- N' ^9 v- d  X. b' k
273.     {
     
274.         rt_kprintf("set timeout value failed\n");
     + X( C3 d% r5 O0 x2 ?
275.         return RT_ERROR;
     5 e, E, c, R" ?; w# I  Y* Q
276.     }
     
277.     return ret;
     
278. }
     
279. MSH_CMD_EXPORT(hw5timer_sample, hw5timer_sample);
     8 M1 M: _9 G/ d3 [  n
280. 
     8 ~& |3 r' u, H# v2 W  w
281. static int hw9timer_sample(int argc, char *argv[])
     * o5 U" P% B) G5 v6 P
282. {
     4 i6 b7 x# _$ w  K
283.     rt_err_t ret = RT_EOK;
     ; B7 |; z1 u0 m# G3 G2 g, F
284.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
285.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     4 u2 ?) n* I; `; v, Q8 v/ n
286.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     , k+ H, T  Z9 Y% u' v
287. 
     . ^" A# l2 K1 t' J& Y$ R, O! {
288.     /* 查找定时器设备 */
     
289.     hw_dev = rt_device_find("timer9");
     ; }- M# P. z6 d( ?) I9 D
290.     /* 以读写方式打开设备 */
     
291.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     $ f" A" D  S/ ^$ c! N% K
292.     /* 设置超时回调函数 */
     
293.     rt_device_set_rx_indicate(hw_dev, timeout_cb9);
     
294.     /* 设置模式为周期性定时器 */
     1 q9 D! l5 v; O1 K) C) X. E
295.     mode = HWTIMER_MODE_PERIOD;
     
296.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
297.     /* 设置定时器超时值为5s并启动定时器 */
     
298.     timeout_s.sec = 1;      /* 秒 */
     
299.     timeout_s.usec = 0;     /* 微秒 */
     2 U- H, [8 R& `& K' q) F; \
300.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     ) k/ B" x9 {% G% H
301.     {
     . s4 H3 m  ?" o4 q
302.         rt_kprintf("set timeout value failed\n");
     
303.         return RT_ERROR;
     
304.     }
     ! t2 j2 ~+ B# M3 v
305.     return ret;
     * d) r6 n; F0 ]& N% N
306. }
     1 h7 R' L/ |! }3 v
307. MSH_CMD_EXPORT(hw9timer_sample, hw9timer_sample);
     8 l6 }; W, N0 \3 D  H/ C
308. 
     : F' D7 P& ^% \4 G3 L/ X2 L1 s
309. static int hw10timer_sample(int argc, char *argv[])
     % a* ?8 b5 T3 K% g/ I
310. {
     ' C- X# @/ I1 r5 C
311.     rt_err_t ret = RT_EOK;
     3 u- q3 b4 F8 m9 _
312.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     + R( d4 U6 Y3 Y/ W5 Y' f0 p& z# g% J
313.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
314.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
315. 
     
316.     /* 查找定时器设备 */
     
317.     hw_dev = rt_device_find("timer10");
     : Z1 w+ B( s! d, g8 X. d8 c2 A$ n* i
318.     /* 以读写方式打开设备 */
     
319.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
320.     /* 设置超时回调函数 */
     
321.     rt_device_set_rx_indicate(hw_dev, timeout_cb10);
     ! Z9 k! n3 A' d
322.     /* 设置模式为周期性定时器 */
     & c) T8 f1 E% U) R$ G  c4 h( s
323.     mode = HWTIMER_MODE_PERIOD;
     
324.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
325.     /* 设置定时器超时值为5s并启动定时器 */
     5 X; L$ I/ t7 E( |
326.     timeout_s.sec = 1;      /* 秒 */
     * p$ M) J; X- J( g1 K. c- C
327.     timeout_s.usec = 0;     /* 微秒 */
     , S. h7 x  W3 b. [, _, \" K: f, L
328.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     ' ~: Q( g; z( s, L$ u, [" y3 I
329.     {
     
330.         rt_kprintf("set timeout value failed\n");
     
331.         return RT_ERROR;
     0 B/ U  G0 _0 s/ L, G: C3 Z  P+ u
332.     }
     
333.     return ret;
     
334. }
     1 k; C" o8 K5 Q
335. MSH_CMD_EXPORT(hw10timer_sample, hw10timer_sample);
     
336. 
     
337. static int hw11timer_sample(int argc, char *argv[])
     ; @- C- a) \; P, t; b, F2 \0 `
338. {
     
339.     rt_err_t ret = RT_EOK;
     ) O+ f+ |" x9 b. C
340.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
341.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
342.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     / c3 K' u* c. N1 C' o
343. 
     * C$ `/ d& G% G3 f& b2 W* U! h8 v
344.     /* 查找定时器设备 */
     9 w5 n0 p4 A4 ?1 a
345.     hw_dev = rt_device_find("timer11");
     
346.     /* 以读写方式打开设备 */
     
347.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     2 K  e, }$ I) n
348.     /* 设置超时回调函数 */
     4 L3 Q2 ]7 K; B: K4 b
349.     rt_device_set_rx_indicate(hw_dev, timeout_cb11);
     
350.     /* 设置模式为周期性定时器 */
     
351.     mode = HWTIMER_MODE_PERIOD;
     
352.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
353.     /* 设置定时器超时值为5s并启动定时器 */
     
354.     timeout_s.sec = 1;      /* 秒 */
     ( t- l/ s* }) O
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;
     + v% s' w' L+ a2 q/ D
362. }
     
363. MSH_CMD_EXPORT(hw11timer_sample, hw11timer_sample);
     ) }7 }! ^7 ], \/ M- S
364. 
     

复制代码

4 P+ |! W6 z4 M8 h注意，定时器1的定时会快一倍（这里是1s的间隔，但定时器1会500ms进一次中断），尚不清楚是rt-thread的库造成的还是硬件本身时钟相关的原因，后续在研究。
$ z/ H/ }( y+ m( _9 i————————————————
+ \- U4 P% ?/ s4 a* l$ V版权声明：小盼你最萌哒
- b9 @, B/ z5 x' C8 X( a如有侵权请联系删除
/ ~0 B, C8 J0 t3 l5 V1 O
9 Z- g, Q2 I8 k5 S  d0 d4 b