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
7.5 KiB

3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
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. // }