beep.c 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336
  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-05-23 Administrator the first version
  9. */
  10. #include <rtdevice.h> //使用 RT-Thread 的设备需要包含此头文件
  11. #include <beep.h>
  12. #include <control.h>
  13. #include "hmi.h"
  14. #define HWTIMER_DEV_NAME "timer2" /* 定时器名称 */
  15. Device_Status_typedef device_status;
  16. struct rt_device_pwm *pwm_device = RT_NULL; //定义 pwm 设备指针
  17. struct rt_device_pwm *pwm_tim8 = RT_NULL; //定义 pwm 设备指针
  18. /* 定时器超时回调函数 */
  19. static rt_err_t timeout_cb(rt_device_t dev, rt_size_t size)
  20. {
  21. rt_kprintf("this is hwtimer timeout callback fucntion!\n");
  22. rt_kprintf("tick is :%d !\n", rt_tick_get());
  23. rt_pwm_disable(pwm_device, BEEP_PWM_CH);
  24. rt_device_close(dev);
  25. return 0;
  26. }
  27. rt_device_t hw_dev = RT_NULL; /* 定时器设备句柄 */
  28. static int hwtimer_sample(int argc, char *argv[])
  29. {
  30. rt_err_t ret = RT_EOK;
  31. rt_hwtimerval_t timeout_s; /* 定时器超时值 */
  32. rt_device_t hw_dev = RT_NULL; /* 定时器设备句柄 */
  33. rt_hwtimer_mode_t mode; /* 定时器模式 */
  34. rt_uint32_t freq = 10000; /* 计数频率 */
  35. /* 查找定时器设备 */
  36. hw_dev = rt_device_find(HWTIMER_DEV_NAME);
  37. if (hw_dev == RT_NULL)
  38. {
  39. rt_kprintf("hwtimer sample run failed! can't find %s device!\n", HWTIMER_DEV_NAME);
  40. return RT_ERROR;
  41. }
  42. /* 以读写方式打开设备 */
  43. ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
  44. if (ret != RT_EOK)
  45. {
  46. rt_kprintf("open %s device failed!\n", HWTIMER_DEV_NAME);
  47. return ret;
  48. }
  49. /* 设置超时回调函数 */
  50. rt_device_set_rx_indicate(hw_dev, timeout_cb);
  51. /* 设置计数频率(若未设置该项,默认为1Mhz 或 支持的最小计数频率) */
  52. rt_device_control(hw_dev, HWTIMER_CTRL_FREQ_SET, &freq);
  53. /* 设置模式为周期性定时器(若未设置,默认是HWTIMER_MODE_ONESHOT)*/
  54. mode = HWTIMER_MODE_PERIOD; //HWTIMER_MODE_ONESHOT;
  55. ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
  56. if (ret != RT_EOK)
  57. {
  58. rt_kprintf("set mode failed! ret is :%d\n", ret);
  59. return ret;
  60. }
  61. /* 设置定时器超时值为5s并启动定时器 */
  62. timeout_s.sec = 10; /* 秒 */
  63. timeout_s.usec = 0; /* 微秒 */
  64. if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
  65. {
  66. rt_kprintf("set timeout value failed\n");
  67. return RT_ERROR;
  68. }
  69. //beep_init();
  70. hwtimer2_pwm3_output(0,20000,1,1);
  71. return ret;
  72. }
  73. /*初始化蜂鸣器*/
  74. int beep_init(void)
  75. {
  76. /*查找PWM设备*/
  77. pwm_device = (struct rt_device_pwm *)rt_device_find(BEEP_PWM_DEVICE);
  78. if(pwm_device==RT_NULL)
  79. {
  80. rt_kprintf("pwm device %s not found!\n", BEEP_PWM_DEVICE);
  81. return -RT_ERROR;
  82. }
  83. return 0;
  84. }
  85. static int init_pwm3(void)
  86. {
  87. /*查找PWM设备*/
  88. pwm_device = (struct rt_device_pwm *)rt_device_find(BEEP_PWM_DEVICE);
  89. if(pwm_device==RT_NULL)
  90. {
  91. rt_kprintf("pwm device %s not found!\n", BEEP_PWM_DEVICE);
  92. return -RT_ERROR;
  93. }
  94. return 0;
  95. }
  96. static int init_tim2(void)
  97. {
  98. rt_err_t ret = RT_EOK;
  99. rt_hwtimerval_t timeout_s; /* 定时器超时值 */
  100. rt_device_t hw_dev = RT_NULL; /* 定时器设备句柄 */
  101. rt_hwtimer_mode_t mode; /* 定时器模式 */
  102. rt_uint32_t freq = 10000; /* 计数频率 */
  103. /* 查找定时器设备 */
  104. hw_dev = rt_device_find(HWTIMER_DEV_NAME);
  105. if (hw_dev == RT_NULL)
  106. {
  107. rt_kprintf("hwtimer sample run failed! can't find %s device!\n", HWTIMER_DEV_NAME);
  108. return RT_ERROR;
  109. }
  110. /* 以读写方式打开设备 */
  111. ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
  112. if (ret != RT_EOK)
  113. {
  114. rt_kprintf("open %s device failed!\n", HWTIMER_DEV_NAME);
  115. return ret;
  116. }
  117. /* 设置超时回调函数 */
  118. rt_device_set_rx_indicate(hw_dev, timeout_cb);
  119. /* 设置计数频率(若未设置该项,默认为1Mhz 或 支持的最小计数频率) */
  120. rt_device_control(hw_dev, HWTIMER_CTRL_FREQ_SET, &freq);
  121. /* 设置模式为周期性定时器(若未设置,默认是HWTIMER_MODE_ONESHOT)*/
  122. mode = HWTIMER_MODE_ONESHOT; //HWTIMER_MODE_ONESHOT;
  123. ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
  124. if (ret != RT_EOK)
  125. {
  126. rt_kprintf("set mode failed! ret is :%d\n", ret);
  127. return ret;
  128. }
  129. /* 设置定时器超时值为5s并启动定时器 */
  130. timeout_s.sec = 0; /* 秒 */
  131. timeout_s.usec = 500000; /* 微秒 */ //100ms
  132. if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
  133. {
  134. rt_kprintf("set timeout value failed\n");
  135. return RT_ERROR;
  136. }
  137. return 0;
  138. }
  139. int hwtimer2_pwm3_output(rt_uint32_t time,rt_uint32_t freq,uint8_t EN,uint8_t DIR)
  140. {
  141. ctr_Motor_Driver_Power(ON);
  142. rt_thread_delay(100);
  143. rt_pin_mode(Motor_EN, PIN_MODE_OUTPUT);
  144. rt_pin_mode(Motor_DIR, PIN_MODE_OUTPUT);
  145. rt_pin_write(Motor_EN, EN);
  146. rt_thread_delay(1);
  147. rt_pin_write(Motor_DIR, DIR);
  148. init_pwm3();
  149. rt_pwm_set(pwm_device, BEEP_PWM_CH, freq, freq/2);//channel,period,pulse
  150. if(init_tim2()==0)
  151. rt_pwm_enable(pwm_device, BEEP_PWM_CH); //使能蜂鸣器对应的 PWM 通道
  152. return 0;
  153. }
  154. static void stop_motor_86(void)
  155. {
  156. rt_kprintf("stop_motor_86!\n");
  157. rt_pwm_disable(pwm_device, BEEP_PWM_CH);
  158. }
  159. void pin_motor_86_bind(void)
  160. {
  161. rt_pin_mode(MOTOR_86, PIN_MODE_INPUT);
  162. /* 绑定中断,下降沿模式,回调函数名为 */
  163. rt_pin_attach_irq(MOTOR_86, PIN_IRQ_MODE_FALLING, stop_motor_86, RT_NULL);
  164. /* 使能中断 */
  165. rt_pin_irq_enable(MOTOR_86, PIN_IRQ_ENABLE);
  166. }
  167. void pin_motor_86_unbind(void)
  168. {
  169. rt_pin_detach_irq(MOTOR_86);
  170. }
  171. /*打开蜂鸣器*/
  172. int pwm_on(uint8_t pwn_ch,rt_uint32_t pwm_freq)
  173. {
  174. rt_pwm_set(pwm_device, pwn_ch, pwm_freq, pwm_freq/2);
  175. rt_pwm_enable(pwm_device, pwn_ch); //使能蜂鸣器对应的 PWM 通道
  176. return 0;
  177. }
  178. /*关闭蜂鸣器*/
  179. int pwm_off(uint8_t pwn_ch,rt_uint32_t pwm_freq)
  180. {
  181. rt_pwm_set(pwm_device, pwn_ch, pwm_freq, 0);
  182. rt_pwm_disable(pwm_device, pwn_ch); //使能蜂鸣器对应的 PWM 通道
  183. return 0;
  184. }
  185. int pwm8_init(void)
  186. {
  187. pwm_tim8 = (struct rt_device_pwm *)rt_device_find("pwm8");
  188. if(pwm_tim8==RT_NULL)
  189. {
  190. rt_kprintf("pwm device pwm8 not found!\n");
  191. return -RT_ERROR;
  192. }
  193. return 0;
  194. }
  195. /*打开蜂鸣器*/
  196. int beep_on(void)
  197. {
  198. rt_pwm_enable(pwm_device, BEEP_PWM_CH); //使能蜂鸣器对应的 PWM 通道
  199. return 0;
  200. }
  201. /*关闭蜂鸣器*/
  202. int beep_off(void)
  203. {
  204. rt_pwm_disable(pwm_device, BEEP_PWM_CH); //失能蜂鸣器对应的 PWM 通道
  205. return 0;
  206. }
  207. /*在蜂鸣器设定函数里需要设定 蜂鸣器的频率和音量。PWM 设备设定的 API 是设定 周期 和 脉宽 的,
  208. * 因此我们需要转换一下,将频率装换成周期,将音量大小(占空比)转换成脉宽。这里的周期的单位是 ns,
  209. * 因此转换成的 秒 之后还要乘以 10^9 。由于无源蜂鸣器一般是低电平触发的,因此音量越大对应的脉宽就要越小。
  210. * 然后,将转换后的数据传入 rt_pwm_set 来设置 PWM 设备的参数。
  211. *
  212. */
  213. void beep_set(uint32_t freq, uint32_t volume)
  214. {
  215. rt_uint32_t period, pulse;
  216. beep_init();
  217. /* 将频率转化为周期 周期单位:ns 频率单位:HZ */
  218. //period = 1000000000 / freq; //unit:ns 1/HZ*10^9 = ns
  219. period = freq; /* 周期为0.5ms,单位为纳秒500000ns-200k */
  220. /* 根据声音大小计算占空比 蜂鸣器低电平触发 */
  221. pulse = volume; //5000
  222. if(freq==0)
  223. {
  224. rt_pwm_disable(pwm_device, BEEP_PWM_CH);
  225. }else {
  226. /* 利用 PWM API 设定 周期和占空比 */
  227. rt_pwm_set(pwm_device, BEEP_PWM_CH, period, pulse);//channel,period,pulse
  228. rt_pwm_enable(pwm_device, BEEP_PWM_CH);
  229. }
  230. }
  231. void Beep_Tip(uint16_t volnum)
  232. {
  233. rt_pin_mode(Beep, PIN_MODE_OUTPUT);
  234. rt_pin_write(Beep, 1);
  235. rt_thread_mdelay(volnum);
  236. rt_pin_write(Beep, 0);
  237. }
  238. void Motor_Juandai(uint8_t on_off)
  239. {
  240. pwm8_init();
  241. rt_pwm_set(pwm_tim8, PC7_TIM3_CH, 200000, 100000);//channel,period,pulse
  242. //
  243. if(on_off==ON){
  244. rt_pwm_enable(pwm_tim8, PC7_TIM3_CH);
  245. }
  246. else {
  247. rt_pwm_disable(pwm_tim8, PC7_TIM3_CH);
  248. }
  249. }
  250. void Motor_Qingsao_R_PWM(uint8_t on_off)
  251. {
  252. pwm8_init();
  253. rt_pwm_set(pwm_tim8, PC7_TIM3_CH, 200000, 150000);//channel,period,pulse
  254. if(on_off==ON){
  255. rt_pwm_enable(pwm_tim8, PC7_TIM3_CH);
  256. }
  257. else {
  258. rt_pwm_disable(pwm_tim8, PC7_TIM3_CH);
  259. }
  260. }
  261. void Motor_Qingsao_L_PWM(uint8_t on_off)
  262. {
  263. pwm8_init();
  264. rt_pwm_set(pwm_tim8, PC8_TIM3_CH, 200000, 150000);//channel,period,pulse
  265. if(on_off==ON)
  266. {
  267. rt_pwm_enable(pwm_tim8, PC8_TIM3_CH);
  268. }
  269. else {
  270. rt_pwm_disable(pwm_tim8, PC8_TIM3_CH);
  271. }
  272. }
  273. void Motor_shake(uint8_t status_shake,uint16_t shake_sec)
  274. {
  275. beep_init();
  276. rt_pwm_set(pwm_device, PB1_TIM3_CH, 200000, 150000);//channel,period,pulse
  277. if(status_shake==ON)
  278. {
  279. rt_pwm_enable(pwm_device, PB1_TIM3_CH);
  280. if(shake_sec!=0)
  281. {
  282. rt_thread_delay(shake_sec*1000);
  283. rt_pwm_disable(pwm_device, PB1_TIM3_CH);
  284. HMI_WRITE("cangWei.switchShake.val=%d",0);
  285. }
  286. }
  287. else {
  288. rt_pwm_disable(pwm_device, PB1_TIM3_CH);
  289. HMI_WRITE("cangWei.switchShake.val=%d",0);
  290. }
  291. }
  292. /* 导出到 msh 命令列表中 */
  293. MSH_CMD_EXPORT(hwtimer_sample, hwtimer sample);