beep.c 10 KB

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