ozone_cp/APP/key.c

#include "key.h"
static zkey_t s_keys[] = {
    ZKEY_INIT("timerkey", port_gpio_get_timer_key_state),
    ZKEY_INIT("gearskey", port_gpio_get_gears_key_state),
    // ZKEY_INIT("intervaey", port_gpio_get_interval_key_state),
};
zkey_module_t key_module = ZMODULE_INIT(s_keys, onkey);


void zkey_init(zkey_module_t *module) {
  /**
   * @brief ������ʼ��������״̬�ij�ʼ����֮ǰ�ģ����ڵģ�֮����
   *
   */
  s_module = module;
  s_inited = true; //��־λ˵��������ʼ������

  for (int i = 0; i < s_module->nkey; i++) {
    s_module->keys[i].cur_state = zks_keep;
    s_module->keys[i].last_io_state = s_module->keys[i].get_key_state();
    s_module->keys[i].after_filter_state = s_module->keys[i].get_key_state();
  }
}

void zkey_do_loop_in_each_period(void *_null) { /**
                                                 * @brief ѭ����ѯ������״̬
                                                 *
                                                 */
  if (!s_inited)
    return;
  for (int i = 0; i < s_module->nkey; i++) //��ʼ��ÿ���������в�ѯ
  {
    zkey_process_each(&s_module->keys[i]);
  }
}

void zkey_process_each(zkey_t *each) {
  /**
   * @brief �����Ƿ������任��û�任��ʱ������ʱ����¼
   *
   * @param each
   */
  each->keep_state_count++;

  bool now_io_state = each->get_key_state(); //��ȡ���ڵİ���io״̬
  if (each->currentstatekeep_count < 1000) {
    each->currentstatekeep_count++;
  }
  if (now_io_state != each->last_real_state) //�����任
  {
    each->currentstatekeep_count = 0;
  }
  if (each->currentstatekeep_count >= 1) //����״̬����ʱ������20ms,���°���״̬
  {
    each->after_filter_state = now_io_state;
  }
  each->last_real_state = now_io_state;
  zkey_process_each_after_filter(each, each->after_filter_state);
}

void zkey_process_each_after_filter(zkey_t *each, bool now_io_state) {
  if (now_io_state != each->last_io_state) {
    if (now_io_state) {
      each->keep_state_count = 0;
      each->hasProcessed = false;
      each->cur_state = zks_rising_edge;
      s_module->onkey(each, each->cur_state);
    } else {
      each->cur_state = zks_falling_edge;
      s_module->onkey(each, each->cur_state);
      each->keep_state_count = 0;
    }
    each->last_io_state = now_io_state;
  } else {
    each->cur_state = zks_keep;
    if (now_io_state) {
      s_module->onkey(each, each->cur_state);
    }
  }
}
//############################### ԭ����main�еķ��� ���¶��� ###############################//
extern uint32_t g_frequency;
extern uint32_t g_duty[4];
extern int g_ozen_gears;
extern uint32_t g_count_down_begin_sys_time;
extern int time_key_press_frequency; //ÿ����4�ν�����0
extern uint32_t g_ozone_work_time;




void onkey(zkey_t *key, zkey_state_t key_state) {
  /**
   * @brief  �ж�ÿ������������״̬
   *
   * @param key
   * @param key_state
   */
  if (key == &s_keys[0] &&          //��ʱ����
      key->cur_state == zks_keep && //����
      !key->hasProcessed &&         //û�б�������
      key->keep_state_count >=
          POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) //���³���ʱ������3s
  {
    key->hasProcessed = true;
    printf("key0 zks_keep\r\n");
    // stop_ozone_work();
  } else if (key == &s_keys[0] &&                  //��ʱ����
             key->cur_state == zks_falling_edge && //�½��ش���
             !key->hasProcessed &&
             key->keep_state_count <=
                 POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) //��3s
  {
    key->hasProcessed = true;
    printf("key0 zks_falling_edge\r\n");
    set_ozone_work_time();
    // set_timing_time(running_time.timing_time_state);
  } else if (key == &s_keys[1] &&                 //�ߵ͵�λѡ��
             key->cur_state == zks_rising_edge && //
             !key->hasProcessed &&                //
             key->keep_state_count <=
                 POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
    key->hasProcessed = true;
    // key_control_switch_gears(g_switch_gears);
    printf("key1 zks_rising_edge\r\n");
    set_ozen_gears(g_ozen_gears);
  } else if (key == &s_keys[2] &&                 //��Ъʱ��ѡ��
             key->cur_state == zks_rising_edge && //
             !key->hasProcessed &&                //
             key->keep_state_count <=
                 POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
    key->hasProcessed = true;
    printf("key2 zks_rising_edge\r\n");
    // set_interval_time(running_time.interval_time_state);
  }
}
void port_key_state(void) {
  static uint32_t keylastprocess = 0;
  if (port_haspassedms(keylastprocess) > 20) {
    keylastprocess = get_sys_ticket();
    zkey_do_loop_in_each_period(NULL);
  }
}