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.

194 lines
6.9 KiB

3 years ago
  1. #include "key.h"
  2. static zkey_t s_keys[] = {
  3. ZKEY_INIT("timerkey", port_gpio_get_timer_key_state),
  4. ZKEY_INIT("gearskey", port_gpio_get_gears_key_state),
  5. ZKEY_INIT("intervalkey", port_gpio_get_interval_key_state),
  6. ZKEY_INIT("switchkey", port_gpio_get_switch_key_state),
  7. };
  8. zkey_module_t key_module = ZMODULE_INIT(s_keys, onkey);
  9. void zkey_init(zkey_module_t *module) {
  10. /**
  11. * @brief ʼ״̬ijʼ֮ǰģڵģ֮
  12. *
  13. */
  14. s_module = module;
  15. s_inited = true; //��־λ˵��������ʼ������
  16. for (int i = 0; i < s_module->nkey; i++) {
  17. s_module->keys[i].cur_state = zks_keep;
  18. s_module->keys[i].last_io_state = s_module->keys[i].get_key_state();
  19. s_module->keys[i].after_filter_state = s_module->keys[i].get_key_state();
  20. }
  21. }
  22. void zkey_do_loop_in_each_period(void *_null) { /**
  23. * @brief ѭѯ״̬
  24. *
  25. */
  26. if (!s_inited)
  27. return;
  28. for (int i = 0; i < s_module->nkey; i++) //��ʼ��ÿ���������в�ѯ
  29. {
  30. zkey_process_each(&s_module->keys[i]);
  31. }
  32. }
  33. void zkey_process_each(zkey_t *each) {
  34. /**
  35. * @brief Ƿûʱʱ¼
  36. *
  37. * @param each
  38. */
  39. each->keep_state_count++;
  40. bool now_io_state = each->get_key_state(); //��ȡ���ڵİ���io״̬
  41. if (each->currentstatekeep_count < 1000) {
  42. each->currentstatekeep_count++;
  43. }
  44. if (now_io_state != each->last_real_state) //�����任
  45. {
  46. each->currentstatekeep_count = 0;
  47. }
  48. if (each->currentstatekeep_count >= 1) //����״̬����ʱ������20ms,���°���״̬
  49. {
  50. each->after_filter_state = now_io_state;
  51. }
  52. each->last_real_state = now_io_state;
  53. zkey_process_each_after_filter(each, each->after_filter_state);
  54. }
  55. void zkey_process_each_after_filter(zkey_t *each, bool now_io_state) {
  56. if (now_io_state != each->last_io_state) {
  57. if (now_io_state) {
  58. each->keep_state_count = 0;
  59. each->hasProcessed = false;
  60. each->cur_state = zks_rising_edge;
  61. s_module->onkey(each, each->cur_state);
  62. } else {
  63. each->cur_state = zks_falling_edge;
  64. s_module->onkey(each, each->cur_state);
  65. each->keep_state_count = 0;
  66. }
  67. each->last_io_state = now_io_state;
  68. } else {
  69. each->cur_state = zks_keep;
  70. if (now_io_state) {
  71. s_module->onkey(each, each->cur_state);
  72. }
  73. }
  74. }
  75. //############################### ԭ����main�еķ��� ���¶���
  76. //###############################//
  77. extern uint32_t g_frequency;
  78. extern uint32_t g_duty[4];
  79. extern int g_ozen_gears;
  80. extern uint32_t g_count_down_begin_sys_time;
  81. extern int time_key_press_frequency; //ÿ����4�ν�����0
  82. extern uint32_t g_ozone_work_time;
  83. //##############�µ�############
  84. extern pwm_message_t pwm_message;
  85. extern rgb_message_t rgb_message;
  86. shutdown_before_message_t shutdown_before_message;
  87. void process_switchkey(void) {
  88. static uint8_t switchkey_press_conut = 0;
  89. switchkey_press_conut++;
  90. switch (switchkey_press_conut) {
  91. case 1: //����������ģʽΪ�ػ�ǰ�Ĺ���ģʽ,�޶�ʱ�޼�Ъ
  92. pwm_module_set_pwm_output_2(
  93. shutdown_before_message.hardware_frequency, shutdown_before_message.hardware_duty,
  94. shutdown_before_message.large_period, shutdown_before_message.large_duty);
  95. light_module_set_rgb_mode(rgb_message.turn_off_the_mode_before_rgb);
  96. port_fan_set(true);
  97. break;
  98. case 2: //�ػ�
  99. switchkey_press_conut = 0;
  100. shutdown_before_message.hardware_duty=pwm_message.s_hardware_duty;
  101. shutdown_before_message.hardware_frequency=pwm_message.s_hardware_frequency;
  102. shutdown_before_message.large_duty=pwm_message.s_large_duty;
  103. shutdown_before_message.large_period=pwm_message.s_large_period;
  104. light_module_set_rgb_mode(RGB_CLOSE);
  105. light_module_set_timing_light_mode(CLOSE_ALL_LED);
  106. pwm_module_set_pwm_output_2(1,100,0,0);
  107. port_fan_set(false);
  108. break;
  109. }
  110. }
  111. void onkey(zkey_t *key, zkey_state_t key_state) {
  112. /**
  113. * @brief жÿ״̬
  114. *
  115. * @param key
  116. * @param key_state
  117. */
  118. if (get_ozone_starting_up_state()) { //������
  119. if (key == &s_keys[0] && //��ʱ����
  120. key->cur_state == zks_keep && //����
  121. !key->hasProcessed && //û�б�������
  122. key->keep_state_count >=
  123. POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) //���³���ʱ������3s
  124. {
  125. key->hasProcessed = true;
  126. // printf("key0 zks_keep\r\n");
  127. // stop_ozone_work();
  128. } else if (key == &s_keys[0] && //��ʱ����
  129. key->cur_state == zks_falling_edge && //�½��ش���
  130. !key->hasProcessed &&
  131. key->keep_state_count <=
  132. POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) //��3s
  133. {
  134. key->hasProcessed = true;
  135. printf("key0 zks_falling_edge\r\n");
  136. // set_ozone_work_time();
  137. // set_timing_time(running_time.timing_time_state);
  138. } else if (key == &s_keys[1] && //�ߵ͵�λѡ��
  139. key->cur_state == zks_rising_edge && //
  140. !key->hasProcessed && //
  141. key->keep_state_count <=
  142. POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
  143. key->hasProcessed = true;
  144. // key_control_switch_gears(g_switch_gears);
  145. printf("key1 zks_rising_edge\r\n");
  146. // set_ozen_gears(g_ozen_gears);
  147. } else if (key == &s_keys[2] && //��Ъʱ��ѡ��
  148. key->cur_state == zks_rising_edge && //
  149. !key->hasProcessed && //
  150. key->keep_state_count <=
  151. POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
  152. key->hasProcessed = true;
  153. printf("key2 zks_rising_edge\r\n");
  154. // set_interval_time();
  155. // set_interval_time(running_time.interval_time_state);
  156. }
  157. // else if (key == &s_keys[3] && //����
  158. // key->cur_state == zks_rising_edge && //
  159. // !key->hasProcessed && //
  160. // key->keep_state_count <=
  161. // POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
  162. // key->hasProcessed = true;
  163. // printf("key3 zks_rising_edge\r\n");
  164. // process_switch_key();
  165. // // set_interval_time(running_time.interval_time_state);
  166. // }
  167. }
  168. // else {
  169. if (key == &s_keys[3] && //����
  170. key->cur_state == zks_rising_edge && //
  171. !key->hasProcessed && //
  172. key->keep_state_count <= POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
  173. key->hasProcessed = true;
  174. printf("key zks_rising_edge\r\n");
  175. // process_switch_key();
  176. process_switchkey();
  177. // set_interval_time(running_time.interval_time_state);
  178. }
  179. // }
  180. }
  181. void port_key_state(void) {
  182. static uint32_t keylastprocess = 0;
  183. if (port_haspassedms(keylastprocess) > 20) {
  184. keylastprocess = get_sys_ticket();
  185. zkey_do_loop_in_each_period(NULL);
  186. }
  187. }