You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

480 lines
20 KiB

3 years ago
3 years ago
3 years ago
  1. // #if 0
  2. // /*********************************************************
  3. // *Copyright (C), 2017, Shanghai Eastsoft Microelectronics Co., Ltd
  4. // *文件名: main.c
  5. // *作 者: AE Team
  6. // *版 本: V1.00
  7. // *日 期: 2021/05/13
  8. // *描 述: GPIO模块示例程序
  9. // * 定时扫描GPIO_PA2的电平状态,高电平点亮LED1,低电平熄灭LED1
  10. // *备 注:
  11. // *本软件仅供学习和演示使用,对用户直接引用代码所带来的风险或后果不承担任何法律责任。
  12. // **********************************************************/
  13. // #include "main.h"
  14. // #include <stdbool.h> //定义布尔
  15. // // extern ozone_message_t ozone_message;
  16. // extern zkey_module_t key_module;
  17. // bool rgb_flicker_state = false;
  18. // extern rgb_message_t rgb_message;
  19. // /***********************************************************************************************************************
  20. // * =====================================================看门狗======================================================
  21. // **
  22. // ***********************************************************************************************************************/
  23. // void iwdt_init(void) {
  24. // /**
  25. // * @brief 看门狗介绍:当计数到0时,窗口计数器+1
  26. // * 当窗口计数为“2”的时候,产生中断
  27. // * 当窗口计数器为“4”的之前没有进行喂狗操作,产生复位
  28. // *
  29. // */
  30. // IWDT_InitStruType x;
  31. // x.WDT_Tms = 4000;
  32. // x.WDT_IE = Enable; /* IWDT中断使能 */
  33. // x.WDT_Rst = Enable; /* IWDT复位使能 */
  34. // x.WDT_Clock = IWDT_CLOCK_WDT; /* LRC */
  35. // IWDT_Init(&x);
  36. // /* 使能IWDT */
  37. // IWDT_Enable();
  38. // }
  39. // void feed_iwdt(void) {
  40. // //喂狗
  41. // if (0x01 == IWDT_GetFlagStatus()) //产生中断
  42. // {
  43. // IWDT_Clear();
  44. // // printf("喂狗\r\n");
  45. // }
  46. // }
  47. // //############### 测试一下看门狗 ##############//
  48. // /**
  49. // * @brief 上电臭氧工作情况,设备中设置有开关机按键,所以外部上电后,不让设备工作
  50. // *
  51. // */
  52. // void power_on_ozone_working_status(void) {
  53. // // PWM频率1Khz,占空比0,占空比低有效,设置占空比为100,pwm一直输出低电平
  54. // HOOK_pwm_module_set_pwm_duty(1, 100);
  55. // light_module_set_timing_light_mode(CLOSE_ALL_LED);
  56. // light_module_set_rgb_mode(RGB_COLOR_RED);
  57. // port_fan_set(false); //打开你风扇
  58. // }
  59. // /***********************************************************************************************************************
  60. // * ======================================================主函数=======================================================
  61. // **
  62. // ***********************************************************************************************************************/
  63. // int main(void) {
  64. // HRC_Config(Enable, SCU_HRC_48M, Enable); //时钟源SCU_CLK_HRC
  65. // SystemInit();
  66. // DeviceClockAllEnable(); //打开所有外设时钟
  67. // User_SysTickInit(); //滴答定时器初始化为(配置为1ms中断)
  68. // SysTick_Enable();
  69. // uart0_init();
  70. // gpio_init();
  71. // zkey_init(&key_module);
  72. // t16n0_1_init(); //配置PA4输出pwm
  73. // // iwdt_init();
  74. // power_on_ozone_working_status();
  75. // // power_on_ozone_work_state(); //上电工作情况
  76. // // ADCInit("A",4);
  77. // // printf("Initialization completed\r\n");
  78. // while (1) {
  79. // // port_do_debug_light_state();
  80. // port_key_state();
  81. // // if (get_ozone_starting_up_state() == true) { //开机中
  82. // // // if (ozone_message.ozone_work_state == 2)
  83. // // // is_ozone_work_time_over();
  84. // // // if (ozone_message.ozone_interva_state == true) {
  85. // // // set_rgb_flicker(); //间歇状态下rgb亮3灭1
  86. // // // is_ozone_interva_time_over();
  87. // // // }
  88. // // pwm_module_loop();
  89. // // if (rgb_message.rgb_flicker_mode == true) {
  90. // // process_rgb_flicker_mode();
  91. // // rgb_message.already_set_rgb_mode = false;
  92. // // } else if (rgb_message.rgb_flicker_mode == false) {
  93. // // if (rgb_message.already_set_rgb_mode == false)
  94. // // light_module_set_rgb_mode(rgb_message.turn_off_the_mode_before_rgb);
  95. // // rgb_message.already_set_rgb_mode = true;
  96. // // }
  97. // adc_loop_gather();
  98. // // } else if (get_ozone_starting_up_state() == false) { //关机
  99. // // }
  100. // // test_iwdt();
  101. // // feed_iwdt(); //当产生中断的时候进行喂狗操作
  102. // }
  103. // }
  104. // #endif
  105. // #include <stdbool.h> //定义布尔
  106. // #include "main.h"
  107. // #define INTERVAL_PERIOD 20000
  108. // #define TIMING_TICK 20000
  109. // uint32_t g_interval_period = 20000; //现在项目需求只有一种间歇时间,所以这里用这个变量来修改间歇的周期
  110. // uint32_t g_interval_duty = 100;
  111. // bool starting_up_state = false;
  112. // RGB_MODE_T now_rgb_color;
  113. // RGB_MODE_T shutdown_front_rgb_color;
  114. // uint32_t timing_time;
  115. // bool timing_function_enable_falg;
  116. // static uint32_t timing_shutdown_begin_ticket = 0;
  117. // uint8_t now_pwm_duty; //记录硬件的pwm占空比
  118. // extern uint32_t begin_ticket;
  119. // /**
  120. // * @brief 间歇功能当定时功能使能的时候,间歇功能开始工作,当定时功能未使能时间歇功能不工作
  121. // *
  122. // */
  123. // void update_interval_period_duty(void) {
  124. // static uint8_t interval_key_press_count = 0;
  125. // interval_key_press_count++;
  126. // if (interval_key_press_count == 1) {
  127. // printf("duty 50\r\n");
  128. // g_interval_period = INTERVAL_PERIOD;
  129. // g_interval_duty = 50;
  130. // } else if (interval_key_press_count == 2) {
  131. // printf("duty 100\r\n");
  132. // interval_key_press_count = 0;
  133. // g_interval_period = timing_time;
  134. // g_interval_duty = 100;
  135. // }
  136. // ozone_pwm_control_module_set_pwm_output_1(g_interval_period, g_interval_duty);
  137. // }
  138. // /**
  139. // * @brief 根据现在的时间进行更改
  140. // *
  141. // */
  142. // void updae_led_light_mode(void) {
  143. // if ((timing_time / TIMING_TICK) == 0) {
  144. // light_module_set_timing_light_mode(CLOSE_ALL_LED);
  145. // } else if ((timing_time / TIMING_TICK) == 1) {
  146. // light_module_set_timing_light_mode(OPEN_ONE_LED);
  147. // } else if ((timing_time / TIMING_TICK) == 2) {
  148. // light_module_set_timing_light_mode(OPEN_TWO_LED);
  149. // } else if ((timing_time / TIMING_TICK) == 3) {
  150. // light_module_set_timing_light_mode(OPEN_THREE_LED);
  151. // } else if ((timing_time / TIMING_TICK) == 4) {
  152. // light_module_set_timing_light_mode(OPEN_FOUR_LED);
  153. // }
  154. // }
  155. // void process_gearskey_press_even_1(void) {
  156. // static uint8_t gearskey_press_count;
  157. // gearskey_press_count++;
  158. // if (gearskey_press_count == 1) {
  159. // update_pwm_output_duty(50);
  160. // update_rgb_color(RGB_COLOR_BLUE);
  161. // } else if (gearskey_press_count == 2) {
  162. // update_pwm_output_duty(25);
  163. // update_rgb_color(RGB_COLOR_GERRN);
  164. // } else if (gearskey_press_count == 3) {
  165. // gearskey_press_count = 0;
  166. // update_pwm_output_duty(100);
  167. // update_rgb_color(RGB_COLOR_RED);
  168. // }
  169. // }
  170. // void update_rgb_color(uint8_t color) {
  171. // if (color == RGB_CLOSE) {
  172. // now_rgb_color = RGB_COLOR_RED;
  173. // light_module_set_rgb_mode(RGB_CLOSE);
  174. // } else if (color == RGB_COLOR_RED) {
  175. // now_rgb_color = RGB_COLOR_RED;
  176. // light_module_set_rgb_mode(RGB_COLOR_RED);
  177. // } else if (color == RGB_COLOR_BLUE) {
  178. // now_rgb_color = RGB_COLOR_BLUE;
  179. // light_module_set_rgb_mode(RGB_COLOR_BLUE);
  180. // } else if (color == RGB_COLOR_GERRN) {
  181. // now_rgb_color = RGB_COLOR_GERRN;
  182. // light_module_set_rgb_mode(RGB_COLOR_GERRN);
  183. // }
  184. // }
  185. // void update_pwm_output_duty(uint8_t pwm_duty) {
  186. // if (pwm_duty == 100) {
  187. // ozone_pwm_control_module_set_pwm_output_2(1, 100, g_interval_period, g_interval_duty);
  188. // now_pwm_duty = 100;
  189. // } else if (pwm_duty == 50) {
  190. // ozone_pwm_control_module_set_pwm_output_2(1, 50, g_interval_period, g_interval_duty);
  191. // now_pwm_duty = 50;
  192. // } else if (pwm_duty == 25) {
  193. // ozone_pwm_control_module_set_pwm_output_2(1, 25, g_interval_period, g_interval_duty);
  194. // now_pwm_duty = 25;
  195. // } else if (pwm_duty == 0) {
  196. // ozone_pwm_control_module_set_pwm_output_2(1, 0, g_interval_period, g_interval_duty);
  197. // now_pwm_duty = 0;
  198. // }
  199. // }
  200. // /***********************************************************************************************************************
  201. // * =====================================================开机关机====================================================== *
  202. // ***********************************************************************************************************************/
  203. // void shutdown(void) {
  204. // starting_up_state = false;
  205. // shutdown_front_rgb_color = now_rgb_color;
  206. // ozone_pwm_control_module_set_pwm_output_2(1, 0, 0, 0);
  207. // update_rgb_color(RGB_CLOSE);
  208. // light_module_set_timing_light_mode(CLOSE_ALL_LED);
  209. // port_fan_set(false); //关闭风扇
  210. // }
  211. // void starting_up(void) {
  212. // // starting_up_state = true;
  213. // // // PWM频率1Khz,占空比0,占空比低有效,设置占空比为100,pwm一直输出低电平
  214. // // if (shutdown_front_rgb_color == RGB_CLOSE) {
  215. // // update_rgb_color(RGB_COLOR_RED);
  216. // // } else {
  217. // // update_rgb_color(now_rgb_color); // last_rgb_mode
  218. // // }
  219. // // if (now_pwm_duty == 0) {
  220. // // now_pwm_duty = 100;
  221. // // }
  222. // // update_pwm_output_duty(now_pwm_duty);
  223. // port_fan_set(true); //打开你风扇
  224. // }
  225. // void process_switchkey(void) {
  226. // static bool switchkey_press_count = 0;
  227. // switchkey_press_count = !switchkey_press_count;
  228. // if (switchkey_press_count) { //开机
  229. // starting_up();
  230. // } else { //关机
  231. // shutdown();
  232. // }
  233. // }
  234. // /***********************************************************************************************************************
  235. // * =================================================按键初始化和处理================================================== *
  236. // ***********************************************************************************************************************/
  237. // static zkey_t s_keys[] = {
  238. // ZKEY_INIT("timerkey", port_gpio_get_timer_key_state),
  239. // ZKEY_INIT("gearskey", port_gpio_get_gears_key_state),
  240. // ZKEY_INIT("intervalkey", port_gpio_get_interval_key_state),
  241. // ZKEY_INIT("switchkey", port_gpio_get_switch_key_state),
  242. // };
  243. // zkey_module_t key_module = ZMODULE_INIT(s_keys, onkey);
  244. // void onkey(zkey_t *key, zkey_state_t key_state) {
  245. // /**
  246. // * @brief 判断每个按键触发的状态
  247. // *
  248. // * @param key
  249. // * @param key_state
  250. // */
  251. // if (starting_up_state) { //开机中
  252. // if (key == &s_keys[0] && //定时按键
  253. // key->cur_state == zks_keep && //长按
  254. // !key->hasProcessed && //没有被处理过
  255. // key->keep_state_count >= POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) //按下持续时间大于3s
  256. // {
  257. // key->hasProcessed = true;
  258. // } else if (key == &s_keys[0] && //定时按键
  259. // key->cur_state == zks_falling_edge && //下降沿触发
  260. // !key->hasProcessed && key->keep_state_count <= POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) //小于3s
  261. // {
  262. // key->hasProcessed = true;
  263. // printf("key0 zks_falling_edge\r\n");
  264. // update_timing_time();
  265. // updae_led_light_mode();
  266. // } else if (key == &s_keys[1] && //高低档位选择
  267. // key->cur_state == zks_rising_edge && //
  268. // !key->hasProcessed && //
  269. // key->keep_state_count <= POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
  270. // key->hasProcessed = true;
  271. // printf("key1 zks_rising_edge\r\n");
  272. // // update_rgb_mode(0, now_rgb_mode);
  273. // // update_pwm_output_duty(0);
  274. // process_gearskey_press_even();
  275. // } else if (key == &s_keys[2] && //间歇时间选择
  276. // key->cur_state == zks_rising_edge && //
  277. // !key->hasProcessed && //
  278. // key->keep_state_count <= POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
  279. // key->hasProcessed = true;
  280. // printf("key2 zks_rising_edge\r\n");
  281. // update_interval_period_duty();
  282. // } else if (key == &s_keys[3] && //开关
  283. // key->cur_state == zks_rising_edge && //
  284. // !key->hasProcessed && //
  285. // key->keep_state_count <= POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
  286. // key->hasProcessed = true;
  287. // printf("key2 zks_rising_edge\r\n");
  288. // shutdown();
  289. // }
  290. // } else { //关机中
  291. // if (key == &s_keys[3] && //开关
  292. // key->cur_state == zks_rising_edge && //
  293. // !key->hasProcessed && //
  294. // key->keep_state_count <= POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
  295. // key->hasProcessed = true;
  296. // printf("key zks_rising_edge\r\n");
  297. // starting_up();
  298. // }
  299. // }
  300. // }
  301. // /***********************************************************************************************************************
  302. // * =====================================================HOOK实现====================================================== *
  303. // ***********************************************************************************************************************/
  304. // bool pwm_modble_enable_falg;
  305. // void HOOK_pwm_module_set_pwm_duty(uint32_t frequency, uint32_t duty) {
  306. // set_pwm_modbul_freq_duty(frequency, duty);
  307. // port_fan_set(true); //打开风扇
  308. // pwm_modble_enable_falg = true;
  309. // printf("work\r\n");
  310. // }
  311. // void HOOK_pwm_stop(void) {
  312. // set_pwm_modbul_freq_duty(1, 0); //关闭PWM输出
  313. // port_fan_set(false); //风扇结束工作
  314. // pwm_modble_enable_falg = false;
  315. // printf("rest\r\n");
  316. // }
  317. // bool HOOK_pwm_is_enable(void) { return pwm_modble_enable_falg; }
  318. // /***********************************************************************************************************************
  319. // * =====================================================定时功能====================================================== *
  320. // ***********************************************************************************************************************/
  321. // /**
  322. // * @brief 每次按键按下时间timing_time=timing_time+TIMING_TICK
  323. // * 当timing_time==timing_time = 4 * TIMING_TICK;
  324. // * timing_time = 0;
  325. // *
  326. // */
  327. // void update_timing_time(void) {
  328. // timing_shutdown_begin_ticket = get_sys_ticket(); //更新定时关机开始的时间
  329. // begin_ticket = get_sys_ticket(); //更新间歇开始的时间
  330. // timing_function_enable_falg = true; //使能定时功能
  331. // if (timing_time == 0) {
  332. // timing_time = 1 * TIMING_TICK;
  333. // } else if ((timing_time / TIMING_TICK) == 1) {
  334. // timing_time = 2 * TIMING_TICK;
  335. // } else if ((timing_time / TIMING_TICK) == 2) {
  336. // timing_time = 3 * TIMING_TICK;
  337. // } else if ((timing_time / TIMING_TICK) == 3) {
  338. // timing_time = 4 * TIMING_TICK;
  339. // } else if ((timing_time / TIMING_TICK) == 4) {
  340. // timing_time = 0 * TIMING_TICK;
  341. // timing_function_enable_falg = false;
  342. // }
  343. // printf("timing time:%d\r\n", timing_time);
  344. // }
  345. // /**
  346. // * @brief 定时每过TIMING_TICK timing_time=timing_time-TIMING_TICK
  347. // * 当TIMING_TICK==0的时候关机
  348. // *
  349. // */
  350. // void try_shutdown(void) {
  351. // if (port_haspassedms(timing_shutdown_begin_ticket) > TIMING_TICK) {
  352. // timing_shutdown_begin_ticket = get_sys_ticket();
  353. // printf("time minus %dms", TIMING_TICK);
  354. // timing_time -= TIMING_TICK;
  355. // updae_led_light_mode();
  356. // }
  357. // if (timing_time == 0) { //定时时间到
  358. // timing_function_enable_falg = false; //使能定时功能
  359. // shutdown();
  360. // }
  361. // }
  362. // bool timing_function_is_enable(void) { return timing_function_enable_falg; }
  363. // /***********************************************************************************************************************
  364. // * =======================================================测试========================================================
  365. // **
  366. // ***********************************************************************************************************************/
  367. // void test(void) {
  368. // light_module_set_rgb_mode(RGB_CLOSE);
  369. // light_module_set_timing_light_mode(CLOSE_ALL_LED);
  370. // // PWM频率1Khz,占空比100,占空比高有效,设置占空比为0,pwm一直输出高电平
  371. // HOOK_pwm_module_set_pwm_duty(1, 0);
  372. // // printf("100\r\n");
  373. // // Delayms(30000);
  374. // // HOOK_pwm_module_set_pwm_duty(1, 25); //电压为25%
  375. // // Delayms(30000);
  376. // // HOOK_pwm_module_set_pwm_duty(1, 50); //电压为50%
  377. // // Delayms(30000);
  378. // // HOOK_pwm_module_set_pwm_duty(1, 100); //电压为100%
  379. // // Delayms(30000);
  380. // HOOK_pwm_module_set_pwm_duty(1, 50); //电压为50%
  381. // ozone_pwm_control_module_set_pwm_output_2(1, 50, 10000, 50); //这样设置现象应该是,pwm输出50%,定时10s,间歇5s
  382. // // update_timing_time();
  383. // }
  384. // /**
  385. // * @brief 上电臭氧工作情况,设备中设置有开关机按键,所以外部上电后,不让设备工作
  386. // *
  387. // */
  388. // void power_on_ozone_working_status(void) {
  389. // // PWM频率1Khz,占空比0,占空比低有效,设置占空比为100,pwm一直输出低电平
  390. // // update_pwm_output_duty(1);
  391. // // update_pwm_output_duty(now_pwm_duty);
  392. // // update_rgb_color(RGB_CLOSE);
  393. // light_module_set_timing_light_mode(CLOSE_ALL_LED);
  394. // port_fan_set(false); //关闭风扇
  395. // }
  396. // /***********************************************************************************************************************
  397. // * ======================================================主函数=======================================================
  398. // **
  399. // ***********************************************************************************************************************/
  400. // int main(void) {
  401. // HRC_Config(Enable, SCU_HRC_48M, Enable); //时钟源SCU_CLK_HRC
  402. // SystemInit();
  403. // DeviceClockAllEnable(); //打开所有外设时钟
  404. // User_SysTickInit(); //滴答定时器初始化为(配置为1ms中断)
  405. // SysTick_Enable();
  406. // uart0_init();
  407. // gpio_init();
  408. // zkey_init(&key_module);
  409. // t16_pa4_init();
  410. // power_on_ozone_working_status();
  411. // // test();
  412. // // printf("%d\r\n", (10000 % 60000));
  413. // // printf("%d\r\n", (20000 % 60000));
  414. // // printf("%d\r\n", (30000 % 60000));
  415. // // printf("%d\r\n", (40000 % 60000));
  416. // // ozone_pwm_control_module_set_pwm_output_2(1, 50, 10000, 50); //这样设置现象是,pwm输出50%,定时10s,间歇5s
  417. // while (1) {
  418. // static uint32_t keylastprocess = 0;
  419. // if (port_haspassedms(keylastprocess) > 20) {
  420. // keylastprocess = get_sys_ticket();
  421. // zkey_do_loop_in_each_period(NULL);
  422. // }
  423. // if (starting_up_state) { //开机中
  424. // port_do_debug_light_state();
  425. // if (timing_function_is_enable()) { //定时功能是开启的
  426. // ozone_pwm_control_module_loop();
  427. // try_shutdown();
  428. // }
  429. // } else { //关机中
  430. // }
  431. // }
  432. // }
  433. // /***********************************************************************************************************************
  434. // * =====================================================测试结果======================================================
  435. // **
  436. // ***********************************************************************************************************************/
  437. // /**
  438. // * 按键测试通过
  439. // * HOOK_pwm_module_set_pwm_duty()小周期(设置硬件PWM)测试通过
  440. // * 测试间歇PWM通过
  441. // *
  442. // **/
  443. // /**
  444. // * 关机工作
  445. // * 1.PWM输出0
  446. // * 2.RGB关闭
  447. // * 3.定时灯关闭
  448. // * 4.风扇关闭
  449. // *
  450. // */