创建基于F411的芯片空工程。
启用hwtimer：



拷贝以下三个文件到drivers目录，路径分别为
C:\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 。



注释掉drv_hwtimer.c中的#include "drv_config.h"。
取消注释stm32f4xx_hal_conf.h中的#define HAL_TIM_MODULE_ENABLED。
向tim_config.h添加#include <board.h>。
向drv_hwtimer.c添加#include <rtdevice.h>。
向drv_hwtimer.c添加#include <tim_config.h>。

在board.h中定义需要使用的定时器：



根据要使用的定时器，修改tim_config.h：

1. /*
   
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   
3. *
   
4. * SPDX-License-Identifier: Apache-2.0
   
5. *
   
6. * Change Logs:
   
7. * Date           Author       Notes
   
8. * 2018-12-11     zylx         first version
   
9. */
   
10. 
    
11. #ifndef __TIM_CONFIG_H__
    
12. #define __TIM_CONFIG_H__
    
13. 
    
14. #include <rtthread.h>
    
15. #include <board.h>
    
16. #ifdef __cplusplus
    
17. extern "C" {
    
18. #endif
    
19. 
    
20. #ifndef TIM_DEV_INFO_CONFIG
    
21. #define TIM_DEV_INFO_CONFIG                     \
    
22.     {                                           \
    
23.         .maxfreq = 1000000,                     \
    
24.         .minfreq = 3000,                        \
    
25.         .maxcnt  = 0xFFFF,                      \
    
26.         .cntmode = HWTIMER_CNTMODE_UP,          \
    
27.     }
    
28. #endif /* TIM_DEV_INFO_CONFIG */
    
29. 
    
30. 
    
31. #ifdef BSP_USING_TIM1
    
32. #ifndef TIM1_CONFIG
    
33. #define TIM1_CONFIG                                        \
    
34.     {                                                       \
    
35.        .tim_handle.Instance     = TIM1,                    \
    
36.        .tim_irqn                = TIM1_UP_TIM10_IRQn,  \
    
37.        .name                    = "timer1",                \
    
38.     }
    
39. #endif /* TIM11_CONFIG */
    
40. #endif /* BSP_USING_TIM11 */
    
41. 
    
42. 
    
43. 
    
44. #ifdef BSP_USING_TIM2
    
45. #ifndef TIM2_CONFIG
    
46. #define TIM2_CONFIG                                        \
    
47.     {                                                       \
    
48.        .tim_handle.Instance     = TIM2,                    \
    
49.        .tim_irqn                = TIM2_IRQn,  \
    
50.        .name                    = "timer2",                \
    
51.     }
    
52. #endif /* TIM11_CONFIG */
    
53. #endif /* BSP_USING_TIM11 */
    
54. 
    
55. 
    
56. 
    
57. #ifdef BSP_USING_TIM3
    
58. #ifndef TIM3_CONFIG
    
59. #define TIM3_CONFIG                                        \
    
60.     {                                                       \
    
61.        .tim_handle.Instance     = TIM3,                    \
    
62.        .tim_irqn                = TIM3_IRQn,  \
    
63.        .name                    = "timer3",                \
    
64.     }
    
65. #endif /* TIM11_CONFIG */
    
66. #endif /* BSP_USING_TIM11 */
    
67. 
    
68. 
    
69. 
    
70. 
    
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",                \
    
78.     }
    
79. #endif /* TIM11_CONFIG */
    
80. #endif /* BSP_USING_TIM11 */
    
81. 
    
82. #ifdef BSP_USING_TIM5
    
83. #ifndef TIM5_CONFIG
    
84. #define TIM5_CONFIG                                        \
    
85.     {                                                       \
    
86.        .tim_handle.Instance     = TIM5,                    \
    
87.        .tim_irqn                = TIM5_IRQn,  \
    
88.        .name                    = "timer5",                \
    
89.     }
    
90. #endif /* TIM11_CONFIG */
    
91. #endif /* BSP_USING_TIM11 */
    
92. 
    
93. #ifdef BSP_USING_TIM9
    
94. #ifndef TIM9_CONFIG
    
95. #define TIM9_CONFIG                                        \
    
96.     {                                                       \
    
97.        .tim_handle.Instance     = TIM9,                    \
    
98.        .tim_irqn                = TIM1_BRK_TIM9_IRQn,  \
    
99.        .name                    = "timer9",                \
    
100.     }
     
101. #endif /* TIM11_CONFIG */
     
102. #endif /* BSP_USING_TIM11 */
     
103. 
     
104. #ifdef BSP_USING_TIM10
     
105. #ifndef TIM10_CONFIG
     
106. #define TIM10_CONFIG                                        \
     
107.     {                                                       \
     
108.        .tim_handle.Instance     = TIM10,                    \
     
109.        .tim_irqn                = TIM1_UP_TIM10_IRQn,  \
     
110.        .name                    = "timer10",                \
     
111.     }
     
112. #endif /* TIM11_CONFIG */
     
113. #endif /* BSP_USING_TIM11 */
     
114. 
     
115. #ifdef BSP_USING_TIM11
     
116. #ifndef TIM11_CONFIG
     
117. #define TIM11_CONFIG                                        \
     
118.     {                                                       \
     
119.        .tim_handle.Instance     = TIM11,                    \
     
120.        .tim_irqn                = TIM1_TRG_COM_TIM11_IRQn,  \
     
121.        .name                    = "timer11",                \
     
122.     }
     
123. #endif /* TIM11_CONFIG */
     
124. #endif /* BSP_USING_TIM11 */
     
125. 
     
126. 
     
127. 
     
128. #ifdef __cplusplus
     
129. }
     
130. #endif
     
131. 
     
132. #endif /* __TIM_CONFIG_H__ */
     

复制代码

在drv_hwtimer.h中增加CubeMX生成的底层代码：

1. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
   
2. {
   
3.     if (htim_base->Instance == TIM1)
   
4.     {
   
5.         __HAL_RCC_TIM1_CLK_ENABLE();
   
6.     }
   
7.     else if (htim_base->Instance == TIM2)
   
8.     {
   
9.         __HAL_RCC_TIM2_CLK_ENABLE();
   
10.     }
    
11.     else if (htim_base->Instance == TIM3)
    
12.     {
    
13.         __HAL_RCC_TIM3_CLK_ENABLE();
    
14.     }
    
15.     else if (htim_base->Instance == TIM4)
    
16.     {
    
17.         __HAL_RCC_TIM4_CLK_ENABLE();
    
18.     }
    
19.     else if (htim_base->Instance == TIM5)
    
20.     {
    
21.         __HAL_RCC_TIM5_CLK_ENABLE();
    
22.     }
    
23.     else if (htim_base->Instance == TIM9)
    
24.     {
    
25.         __HAL_RCC_TIM9_CLK_ENABLE();
    
26.     }
    
27.     else if (htim_base->Instance == TIM10)
    
28.     {
    
29.         __HAL_RCC_TIM10_CLK_ENABLE();
    
30.     }
    
31.     else if (htim_base->Instance == TIM11)
    
32.     {
    
33.         __HAL_RCC_TIM11_CLK_ENABLE();
    
34.     }
    
35. }
    

复制代码

修改drv_hwtimer.h中HAL_TIM_PeriodElapsedCallback，为使用的定时器添加回调函数：

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
2. {
   
3. #ifdef BSP_USING_TIM1
   
4. if (htim->Instance == TIM1)
   
5. {
   
6.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM1_INDEX].time_device);
   
7. }
   
8. #endif
   
9. #ifdef BSP_USING_TIM2
   
10. if (htim->Instance == TIM2)
    
11. {
    
12.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM2_INDEX].time_device);
    
13. }
    
14. #endif
    
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
    
21. #ifdef BSP_USING_TIM4
    
22. if (htim->Instance == TIM4)
    
23. {
    
24.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM4_INDEX].time_device);
    
25. }
    
26. #endif
    
27. #ifdef BSP_USING_TIM5
    
28. if (htim->Instance == TIM5)
    
29. {
    
30.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM5_INDEX].time_device);
    
31. }
    
32. #endif
    
33. #ifdef BSP_USING_TIM9
    
34. if (htim->Instance == TIM9)
    
35. {
    
36.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM9_INDEX].time_device);
    
37. }
    
38. #endif
    
39. #ifdef BSP_USING_TIM10
    
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. {
    
48.     rt_device_hwtimer_isr(&stm32_hwtimer_obj[TIM11_INDEX].time_device);
    
49. }
    
50. #endif
    
51. }
    

复制代码

添加中断函数入口：

1. #ifdef BSP_USING_TIM2
   
2. void TIM2_IRQHandler(void)
   
3. {
   
4. /* enter interrupt */
   
5. rt_interrupt_enter();
   
6. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM2_INDEX].tim_handle);
   
7. /* leave interrupt */
   
8. rt_interrupt_leave();
   
9. }
   
10. #endif
    
11. #ifdef BSP_USING_TIM3
    
12. void TIM3_IRQHandler(void)
    
13. {
    
14. /* enter interrupt */
    
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
    
21. #ifdef BSP_USING_TIM4
    
22. void TIM4_IRQHandler(void)
    
23. {
    
24. /* enter interrupt */
    
25. rt_interrupt_enter();
    
26. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM4_INDEX].tim_handle);
    
27. /* leave interrupt */
    
28. rt_interrupt_leave();
    
29. }
    
30. #endif
    
31. #ifdef BSP_USING_TIM5
    
32. void TIM5_IRQHandler(void)
    
33. {
    
34. /* enter interrupt */
    
35. rt_interrupt_enter();
    
36. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM5_INDEX].tim_handle);
    
37. /* leave interrupt */
    
38. rt_interrupt_leave();
    
39. }
    
40. #endif
    
41. #ifdef BSP_USING_TIM11
    
42. void TIM1_BRK_TIM9_IRQHandler(void)
    
43. {
    
44. /* enter interrupt */
    
45. rt_interrupt_enter();
    
46. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM9_INDEX].tim_handle);
    
47. /* leave interrupt */
    
48. rt_interrupt_leave();
    
49. }
    
50. #endif
    
51. 
    
52. #if defined( BSP_USING_TIM1) ||defined(BSP_USING_TIM10)
    
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)
    
59.     HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM1_INDEX].tim_handle);
    
60. #endif
    
61. #ifdef BSP_USING_TIM10
    
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 */
    
67. rt_interrupt_leave();
    
68. }
    
69. #endif
    
70. 
    
71. #ifdef BSP_USING_TIM11
    
72. void TIM1_TRG_COM_TIM11_IRQHandler(void)
    
73. {
    
74. /* enter interrupt */
    
75. rt_interrupt_enter();
    
76. HAL_TIM_IRQHandler(&stm32_hwtimer_obj[TIM11_INDEX].tim_handle);
    
77. /* leave interrupt */
    
78. rt_interrupt_leave();
    
79. }
    
80. #endif
    

复制代码

新建一个usertimer.c，添加示例代码，通过msh调用即可看到效果：

1. /*
   
2. * Copyright (c) 2006-2020, RT-Thread Development Team
   
3. *
   
4. * SPDX-License-Identifier: Apache-2.0
   
5. *
   
6. * Change Logs:
   
7. * Date           Author       Notes
   
8. * 2020-03-23     ShineRoyal       the first version
   
9. */
   
10. #include <rtthread.h>
    
11. #include <board.h>
    
12. #include <rtdevice.h>
    
13. 
    
14. #define DBG_TAG "user"
    
15. #define DBG_LVL DBG_LOG
    
16. #include <rtdbg.h>
    
17. 
    
18. #define LED0_PIN    GET_PIN(C, 0)
    
19. #define LED1_PIN    GET_PIN(C, 1)
    
20. #define LED2_PIN    GET_PIN(C, 2)
    
21. #define LED3_PIN    GET_PIN(C, 3)
    
22. #define LED4_PIN    GET_PIN(C, 4)
    
23. #define LED5_PIN    GET_PIN(C, 5)
    
24. #define LED6_PIN    GET_PIN(C, 6)
    
25. #define LED7_PIN    GET_PIN(C, 7)
    
26. 
    
27. 
    
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);
    
32.     rt_pin_mode(LED2_PIN, PIN_MODE_OUTPUT);
    
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);
    
37.     rt_pin_mode(LED7_PIN, PIN_MODE_OUTPUT);
    
38.     return 0;
    
39. }
    
40. INIT_BOARD_EXPORT(rt_hw_pin_init);
    
41. 
    
42. /* 定时器超时回调函数 */
    
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);
    
49.     else
    
50.         rt_pin_write(LED0_PIN, PIN_HIGH);
    
51.     LOG_D("%d",i);
    
52.     return 0;
    
53. }
    
54. 
    
55. /* 定时器超时回调函数 */
    
56. static rt_err_t timeout_cb2(rt_device_t dev, rt_size_t size)
    
57. {
    
58.     static int i = 0;
    
59.     i++;
    
60.     if (i % 2)
    
61.         rt_pin_write(LED1_PIN, PIN_LOW);
    
62.     else
    
63.         rt_pin_write(LED1_PIN, PIN_HIGH);
    
64.     return 0;
    
65. }
    
66. 
    
67. /* 定时器超时回调函数 */
    
68. static rt_err_t timeout_cb3(rt_device_t dev, rt_size_t size)
    
69. {
    
70.     static int i = 0;
    
71.     i++;
    
72.     if (i % 2)
    
73.         rt_pin_write(LED2_PIN, PIN_LOW);
    
74.     else
    
75.         rt_pin_write(LED2_PIN, PIN_HIGH);
    
76.     return 0;
    
77. }
    
78. 
    
79. /* 定时器超时回调函数 */
    
80. static rt_err_t timeout_cb4(rt_device_t dev, rt_size_t size)
    
81. {
    
82.     static int i = 0;
    
83.     i++;
    
84.     if (i % 2)
    
85.         rt_pin_write(LED3_PIN, PIN_LOW);
    
86.     else
    
87.         rt_pin_write(LED3_PIN, PIN_HIGH);
    
88.     return 0;
    
89. }
    
90. 
    
91. /* 定时器超时回调函数 */
    
92. static rt_err_t timeout_cb5(rt_device_t dev, rt_size_t size)
    
93. {
    
94.     static int i = 0;
    
95.     i++;
    
96.     if (i % 2)
    
97.         rt_pin_write(LED4_PIN, PIN_LOW);
    
98.     else
    
99.         rt_pin_write(LED4_PIN, PIN_HIGH);
    
100.     return 0;
     
101. }
     
102. 
     
103. 
     
104. /* 定时器超时回调函数 */
     
105. static rt_err_t timeout_cb9(rt_device_t dev, rt_size_t size)
     
106. {
     
107.     static int i = 0;
     
108.     i++;
     
109.     if (i % 2)
     
110.         rt_pin_write(LED5_PIN, PIN_LOW);
     
111.     else
     
112.         rt_pin_write(LED5_PIN, PIN_HIGH);
     
113.     return 0;
     
114. }
     
115. 
     
116. /* 定时器超时回调函数 */
     
117. static rt_err_t timeout_cb10(rt_device_t dev, rt_size_t size)
     
118. {
     
119.     static int i = 0;
     
120.     i++;
     
121.     if (i % 2)
     
122.         rt_pin_write(LED6_PIN, PIN_LOW);
     
123.     else
     
124.         rt_pin_write(LED6_PIN, PIN_HIGH);
     
125.     return 0;
     
126. }
     
127. 
     
128. /* 定时器超时回调函数 */
     
129. static rt_err_t timeout_cb11(rt_device_t dev, rt_size_t size)
     
130. {
     
131.     static int i = 0;
     
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;
     
138. }
     
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.     /* 查找定时器设备 */
     
149.     hw_dev = rt_device_find("timer1");
     
150.     /* 以读写方式打开设备 */
     
151.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
152.     /* 设置超时回调函数 */
     
153.     rt_device_set_rx_indicate(hw_dev, timeout_cb1);
     
154.     /* 设置模式为周期性定时器 */
     
155.     mode = HWTIMER_MODE_PERIOD;
     
156.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
157.     /* 设置定时器超时值为5s并启动定时器 */
     
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))
     
161.     {
     
162.         rt_kprintf("set timeout value failed\n");
     
163.         return RT_ERROR;
     
164.     }
     
165.     return ret;
     
166. }
     
167. MSH_CMD_EXPORT(hw1timer_sample, hw1timer_sample);
     
168. 
     
169. static int hw2timer_sample(int argc, char *argv[])
     
170. {
     
171.     rt_err_t ret = RT_EOK;
     
172.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
173.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
174.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
175. 
     
176.     /* 查找定时器设备 */
     
177.     hw_dev = rt_device_find("timer2");
     
178.     /* 以读写方式打开设备 */
     
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;      /* 秒 */
     
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.     }
     
193.     return ret;
     
194. }
     
195. MSH_CMD_EXPORT(hw2timer_sample, hw2timer_sample);
     
196. 
     
197. static int hw3timer_sample(int argc, char *argv[])
     
198. {
     
199.     rt_err_t ret = RT_EOK;
     
200.     rt_hwtimerval_t timeout_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.     /* 以读写方式打开设备 */
     
207.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
208.     /* 设置超时回调函数 */
     
209.     rt_device_set_rx_indicate(hw_dev, timeout_cb3);
     
210.     /* 设置模式为周期性定时器 */
     
211.     mode = HWTIMER_MODE_PERIOD;
     
212.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
213.     /* 设置定时器超时值为5s并启动定时器 */
     
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;
     
220.     }
     
221.     return ret;
     
222. }
     
223. MSH_CMD_EXPORT(hw3timer_sample, hw3timer_sample);
     
224. 
     
225. static int hw4timer_sample(int argc, char *argv[])
     
226. {
     
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");
     
234.     /* 以读写方式打开设备 */
     
235.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
236.     /* 设置超时回调函数 */
     
237.     rt_device_set_rx_indicate(hw_dev, timeout_cb4);
     
238.     /* 设置模式为周期性定时器 */
     
239.     mode = HWTIMER_MODE_PERIOD;
     
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))
     
245.     {
     
246.         rt_kprintf("set timeout value failed\n");
     
247.         return RT_ERROR;
     
248.     }
     
249.     return ret;
     
250. }
     
251. MSH_CMD_EXPORT(hw4timer_sample, hw4timer_sample);
     
252. 
     
253. static int hw5timer_sample(int argc, char *argv[])
     
254. {
     
255.     rt_err_t ret = RT_EOK;
     
256.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
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.     /* 设置超时回调函数 */
     
265.     rt_device_set_rx_indicate(hw_dev, timeout_cb5);
     
266.     /* 设置模式为周期性定时器 */
     
267.     mode = HWTIMER_MODE_PERIOD;
     
268.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
269.     /* 设置定时器超时值为5s并启动定时器 */
     
270.     timeout_s.sec = 1;      /* 秒 */
     
271.     timeout_s.usec = 0;     /* 微秒 */
     
272.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     
273.     {
     
274.         rt_kprintf("set timeout value failed\n");
     
275.         return RT_ERROR;
     
276.     }
     
277.     return ret;
     
278. }
     
279. MSH_CMD_EXPORT(hw5timer_sample, hw5timer_sample);
     
280. 
     
281. static int hw9timer_sample(int argc, char *argv[])
     
282. {
     
283.     rt_err_t ret = RT_EOK;
     
284.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
285.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
286.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
287. 
     
288.     /* 查找定时器设备 */
     
289.     hw_dev = rt_device_find("timer9");
     
290.     /* 以读写方式打开设备 */
     
291.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
292.     /* 设置超时回调函数 */
     
293.     rt_device_set_rx_indicate(hw_dev, timeout_cb9);
     
294.     /* 设置模式为周期性定时器 */
     
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;     /* 微秒 */
     
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");
     
303.         return RT_ERROR;
     
304.     }
     
305.     return ret;
     
306. }
     
307. MSH_CMD_EXPORT(hw9timer_sample, hw9timer_sample);
     
308. 
     
309. static int hw10timer_sample(int argc, char *argv[])
     
310. {
     
311.     rt_err_t ret = RT_EOK;
     
312.     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
     
313.     rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     
314.     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     
315. 
     
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.     /* 设置模式为周期性定时器 */
     
323.     mode = HWTIMER_MODE_PERIOD;
     
324.     ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
     
325.     /* 设置定时器超时值为5s并启动定时器 */
     
326.     timeout_s.sec = 1;      /* 秒 */
     
327.     timeout_s.usec = 0;     /* 微秒 */
     
328.     if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
     
329.     {
     
330.         rt_kprintf("set timeout value failed\n");
     
331.         return RT_ERROR;
     
332.     }
     
333.     return ret;
     
334. }
     
335. MSH_CMD_EXPORT(hw10timer_sample, hw10timer_sample);
     
336. 
     
337. static int hw11timer_sample(int argc, char *argv[])
     
338. {
     
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;         /* 定时器模式 */
     
343. 
     
344.     /* 查找定时器设备 */
     
345.     hw_dev = rt_device_find("timer11");
     
346.     /* 以读写方式打开设备 */
     
347.     ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
     
348.     /* 设置超时回调函数 */
     
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;      /* 秒 */
     
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;
     
362. }
     
363. MSH_CMD_EXPORT(hw11timer_sample, hw11timer_sample);
     
364. 
     

复制代码

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