ozone_cp/APP/main.c

#include "main.h"

#include <stdbool.h>  //���岼��
#define TIMING_TICK 20000
#define INTERVAL_PERIOD 10000
/***********************************************************************************************************************
 * =====================================================ȫ�ֱ���====================================================== *
 ***********************************************************************************************************************/
bool starting_up_state = false;  //���ػ���־λ

bool timing_function_enable_falg = false;            //��ʱ����ʹ�ܱ�־λ
static uint32_t s_timing_shutdown_begin_ticket = 0;  //��ʱ��ʼʱ����ʱ��ϵͳʱ��
static uint32_t s_timing_time;                       //��ʱʱ��

static uint32_t s_interval_period = 0;         //��Ъ���ܵ�����
static uint8_t s_now_interval_duty = 0;        //��Ъ���ܵ�ռ�ձ�
static uint8_t s_intervalkey_press_count = 0;  //��Ъ�������µĴ���

WORK_LEVEL_T now_level;              //���ڵĵ�λ
WORK_LEVEL_T shutdown_before_level;  //�ػ�ǰ�ĵ�λ

error_state_t error_state;                                   //�ĸ������¼�
static bool error_even_trigger_after_stop_ozone_work_state;  //�����¼�������ֹͣ����������־λ

static bool pwm_modble_enable_falg;  //Ӳ��pwmʹ�ܱ�־λ
//####################### HOOKʵ�� ################################//
void HOOK_pwm_module_set_pwm_duty(uint32_t frequency, uint32_t duty) {
  set_pwm_modbul_freq_duty(frequency, duty);
  port_fan_set(true);  //�򿪷���
  pwm_modble_enable_falg = true;
  printf("work\r\n");
}

void HOOK_pwm_stop(void) {
  set_pwm_modbul_freq_duty(1, 0);  //�ر�PWM����
  port_fan_set(false);             //���Ƚ�������
  pwm_modble_enable_falg = false;
  printf("rest\r\n");
}
bool HOOK_pwm_is_enable(void) { return pwm_modble_enable_falg; }
//####################### ������ ################################//
void process_intervalkey_press_even(void) {
  s_intervalkey_press_count++;
  if (s_intervalkey_press_count == 1) {
    update_interval_period_duty(50);
  } else {
    update_interval_period_duty(100);  // ����update_interval_period_duty��100������s_intervalkey_press_count=0
  }
}

/**
 * @brief
 *
 */
void update_interval_period_duty(uint8_t interval_duty) {
  if (interval_duty == 100) {  //ռ�ձ�����100һֱ����
    printf("duty 100\r\n");
    s_interval_period = 0;
    s_now_interval_duty = 100;
    s_intervalkey_press_count = 0;
    ozone_pwm_control_disable();
    restore_the_mode_before_intermittent_work();
  } else if (interval_duty == 50) {
    printf("duty 50\r\n");
    s_interval_period = INTERVAL_PERIOD;
    s_now_interval_duty = 50;
    ozone_pwm_control_enable();
  }
  ozone_pwm_control_module_set_pwm_output_1(s_interval_period, s_now_interval_duty);
}

/**
 * @brief �ָ���Ъ����ǰ�Ĺ�����λ
 *
 */
void restore_the_mode_before_intermittent_work(void) {
  if (now_level == WORK_LEVEL_LOW) {
    light_module_set_rgb_mode(RGB_COLOR_GERRN);
    set_pwm_modbul_freq_duty(1, 25);
    port_fan_set(true);  //�򿪷���
  } else if (now_level == WORK_LEVEL_MIDDLE) {
    light_module_set_rgb_mode(RGB_COLOR_BLUE);
    set_pwm_modbul_freq_duty(1, 50);
    port_fan_set(true);  //�򿪷���
  } else if (now_level == WORK_LEVEL_HIGHT) {
    light_module_set_rgb_mode(RGB_COLOR_RED);
    set_pwm_modbul_freq_duty(1, 100);
    port_fan_set(true);  //�򿪷���
  }
}
/**
 * @brief ��Ъ���ܿ���ʱ��rgb��3s��1s
 *
 */
void process_rgb_flicker(void) {
  static uint32_t rgb_ticket = 0;
  static uint8_t rgb_ticket_count = 0;
  if (port_haspassedms(rgb_ticket) > 1000) {
    rgb_ticket = get_sys_ticket();
    if (rgb_ticket_count < 3) {
      if (now_level == WORK_LEVEL_LOW) {
        light_module_set_rgb_mode(RGB_COLOR_GERRN);
      } else if (now_level == WORK_LEVEL_MIDDLE) {
        light_module_set_rgb_mode(RGB_COLOR_BLUE);
      } else if (now_level == WORK_LEVEL_HIGHT) {
        light_module_set_rgb_mode(RGB_COLOR_RED);
      }
    } else {
      light_module_set_rgb_mode(RGB_CLOSE);
      rgb_ticket_count = 0;
    }
    rgb_ticket_count++;
  }
}

/***********************************************************************************************************************
 * =======================================================����======================================================== *
 ***********************************************************************************************************************/
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("intervalkey", port_gpio_get_interval_key_state),
    ZKEY_INIT("switchkey", port_gpio_get_switch_key_state),
};

zkey_module_t key_module = ZMODULE_INIT(s_keys, onkey);
void onkey(zkey_t *key, zkey_state_t key_state) {
  /**
   * @brief  �ж�ÿ������������״̬
   *
   * @param key
   * @param key_state
   */
  if (starting_up_state) {                                                                         //������
    if (error_state.fan_error_status == false && error_state.way_circuit_error_status == false) {  //�豸���쳣
      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;
      } 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");
        update_timing_time();
        updae_led_light_mode();
      } 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;
        printf("key1 zks_rising_edge\r\n");
        process_gearskey_press_even();
      } 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");
        process_intervalkey_press_even();
      } else if (key == &s_keys[3] &&                  //���ذ���
                 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");
        shutdown();
      }
    } else if (error_state.fan_error_status == true || error_state.way_circuit_error_status == true) {  //�豸�����쳣
      if (key == &s_keys[3] &&                                                                          //���ذ���
          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");
        shutdown();
      }
    }
  } else {                                    //�ػ���
    if (key == &s_keys[3] &&                  //���ذ���
        key->cur_state == zks_rising_edge &&  //
        !key->hasProcessed &&                 //
        key->keep_state_count <= POWER_KEY_TRIGGER_TIME / KEY_SCAN_PERIOD) {
      key->hasProcessed = true;
      printf("key zks_rising_edge\r\n");
      starting_up();
    }
  }
}

/**
 * @brief �ϵ�������������,�豸���п��ػ������������ⲿ�ϵ��󣬲����豸����
 *
 */
void power_on_ozone_working_status(void) {
  update_ozone_work_gears(WORK_LEVEL_CLOSE);
  light_module_set_timing_light_mode(CLOSE_ALL_LED);
  port_fan_set(false);  //�رշ���
}

//####################### ����� #######################/
/**
 * @brief ���ݵ�λ����pwm������rgb����ɫ
 *
 * @param gears
 */
void update_ozone_work_gears(WORK_LEVEL_T level) {
  if (level == WORK_LEVEL_CLOSE) {
    ozone_pwm_control_module_set_pwm_output_2(1, 0, s_interval_period, s_now_interval_duty);
    light_module_set_rgb_mode(RGB_CLOSE);
  } else if (level == WORK_LEVEL_LOW) {
    ozone_pwm_control_module_set_pwm_output_2(1, 25, s_interval_period, s_now_interval_duty);
    light_module_set_rgb_mode(RGB_COLOR_GERRN);
  } else if (level == WORK_LEVEL_MIDDLE) {
    ozone_pwm_control_module_set_pwm_output_2(1, 50, s_interval_period, s_now_interval_duty);
    light_module_set_rgb_mode(RGB_COLOR_BLUE);
  } else if (level == WORK_LEVEL_HIGHT) {
    ozone_pwm_control_module_set_pwm_output_2(1, 100, s_interval_period, s_now_interval_duty);
    light_module_set_rgb_mode(RGB_COLOR_RED);
  }
  now_level = level;
}
void process_gearskey_press_even(void) {
  static uint8_t gearskey_press_count;
  gearskey_press_count++;
  if (gearskey_press_count == 1) {
    update_ozone_work_gears(WORK_LEVEL_MIDDLE);
  } else if (gearskey_press_count == 2) {
    update_ozone_work_gears(WORK_LEVEL_LOW);
  } else if (gearskey_press_count == 3) {
    gearskey_press_count = 0;
    update_ozone_work_gears(WORK_LEVEL_HIGHT);
  }
}
//####################### �����ػ� #######################/
void shutdown(void) {
  ozone_pwm_control_disable();
  error_state.fan_error_status = false;
  error_state.way_circuit_error_status = false;
  s_intervalkey_press_count = 0;
  shutdown_before_level = now_level;
  starting_up_state = false;
  update_ozone_work_gears(WORK_LEVEL_CLOSE);
  light_module_set_timing_light_mode(CLOSE_ALL_LED);
  port_fan_set(false);  //�رշ���
}

/**
 * @brief �����󣬸��ݹػ�ʱ�ĵ�λ�������ã������ػ�ʱ��λΪ�ر�������Ϊ�ߵ�����
 *
 */
void starting_up(void) {
  //����û�м�Ъ������������ռ�ձ�Ϊ100
  update_interval_period_duty(100);
  //����û�ж�ʱ�������Խ� timing_function_enable_falg = false;   s_timing_time = 0;
  timing_function_enable_falg = false;
  s_timing_time = 0;
  starting_up_state = true;
  if (shutdown_before_level == WORK_LEVEL_CLOSE) {
    update_ozone_work_gears(WORK_LEVEL_HIGHT);
  } else {
    update_ozone_work_gears(shutdown_before_level);
  }
  port_fan_set(true);  //����������
}

void process_switchkey(void) {
  static bool switchkey_press_count = 0;
  switchkey_press_count = !switchkey_press_count;
  if (switchkey_press_count) {  //����
    starting_up();
  } else {  //�ػ�
    shutdown();
  }
}

//####################### ��ʱ���� #######################/
/**
 * @brief �������ڵ�ʱ�����и���
 *
 */
void updae_led_light_mode(void) {
  if ((s_timing_time / TIMING_TICK) == 0) {
    light_module_set_timing_light_mode(CLOSE_ALL_LED);
  } else if ((s_timing_time / TIMING_TICK) == 1) {
    light_module_set_timing_light_mode(OPEN_ONE_LED);
  } else if ((s_timing_time / TIMING_TICK) == 2) {
    light_module_set_timing_light_mode(OPEN_TWO_LED);
  } else if ((s_timing_time / TIMING_TICK) == 3) {
    light_module_set_timing_light_mode(OPEN_THREE_LED);
  } else if ((s_timing_time / TIMING_TICK) == 4) {
    light_module_set_timing_light_mode(OPEN_FOUR_LED);
  }
}

/**
 * @brief ÿ�ΰ�������ʱ��timing_time=timing_time+TIMING_TICK
 * ��timing_time==timing_time = 4 * TIMING_TICK;
 * timing_time = 0;
 *
 */
void update_timing_time(void) {
  s_timing_shutdown_begin_ticket = get_sys_ticket();  //���¶�ʱ�ػ���ʼ��ʱ��
  update_begin_ticket();                              //���¼�Ъ��ʼ��ʱ��
  timing_function_enable_falg = true;                 //ʹ�ܶ�ʱ����
  if (s_timing_time == 0) {
    s_timing_time = 1 * TIMING_TICK;
  } else if ((s_timing_time / TIMING_TICK) == 1) {
    s_timing_time = 2 * TIMING_TICK;
  } else if ((s_timing_time / TIMING_TICK) == 2) {
    s_timing_time = 3 * TIMING_TICK;
  } else if ((s_timing_time / TIMING_TICK) == 3) {
    s_timing_time = 4 * TIMING_TICK;
  } else if ((s_timing_time / TIMING_TICK) == 4) {
    s_timing_time = 0 * TIMING_TICK;
    timing_function_enable_falg = false;
    update_interval_period_duty(100);
  }
  printf("timing time:%d\r\n", s_timing_time);
}

/**
 * @brief ��ʱÿ��TIMING_TICK timing_time=timing_time-TIMING_TICK
 * ��TIMING_TICK==0��ʱ���ػ�
 *
 */
void try_shutdown(void) {
  if (port_haspassedms(s_timing_shutdown_begin_ticket) > TIMING_TICK) {
    s_timing_shutdown_begin_ticket = get_sys_ticket();
    printf("time minus %dms", TIMING_TICK);
    s_timing_time -= TIMING_TICK;
    updae_led_light_mode();
  }
  if (s_timing_time == 0) {               //��ʱʱ�䵽
    timing_function_enable_falg = false;  //ʧ�ܶ�ʱ����
    shutdown();
  }
}
bool timing_function_is_enable(void) { return timing_function_enable_falg; }

void iwdt_init(void) {
  /**
   * @brief ���Ź����ܣ���������0ʱ�����ڼ�����+1
   * �����ڼ���Ϊ��2����ʱ�򣬲����ж�
   * �����ڼ�����Ϊ��4����֮ǰû�н���ι��������������λ
   *
   */
  IWDT_InitStruType x;

  x.WDT_Tms = 4000;
  x.WDT_IE = Enable;            /* IWDT�ж�ʹ�� */
  x.WDT_Rst = Enable;           /* IWDT��λʹ�� */
  x.WDT_Clock = IWDT_CLOCK_WDT; /* LRC */
  IWDT_Init(&x);

  /* ʹ��IWDT */
  IWDT_Enable();
}

void feed_iwdt(void) {
  //�
  if (0x01 == IWDT_GetFlagStatus())  //�����ж�
  {
    IWDT_Clear();
    // printf("�\r\n");
  }
}

void process_error_even(void) {
  if (error_state.fan_error_status == false && error_state.way_circuit_error_status == false) {  //û�д���
    return;
  } else {
    if (!error_even_trigger_after_stop_ozone_work_state) {
      error_even_trigger_after_stop_ozone_work_state = true;
      set_pwm_modbul_freq_duty(1, 0);
      light_module_set_rgb_mode(RGB_CLOSE);
      light_module_set_timing_light_mode(CLOSE_ALL_LED);
      port_fan_set(false);  //�رշ���
    }
    if (error_state.fan_error_status == true) {  //���ȵ�ѹ�쳣
      static uint32_t error_even_fan_ticket = 0;
      static uint8_t one_led_flicker_state = 1;
      if (port_haspassedms(error_even_fan_ticket) > 500) {
        error_even_fan_ticket = get_sys_ticket();
        one_led_flicker_state = !one_led_flicker_state;
        port_led0_set(one_led_flicker_state);
      }
    } else if (error_state.way_circuit_error_status == true) {  //�ܵ�·��ѹ�쳣
      static uint32_t error_even_way_circuit = 0;
      static uint8_t two_led_flicker_state = 1;
      if (port_haspassedms(error_even_way_circuit) > 500) {
        error_even_way_circuit = get_sys_ticket();
        two_led_flicker_state = !two_led_flicker_state;
        port_led0_set(two_led_flicker_state);
        port_led1_set(two_led_flicker_state);
      }
    }
  }
}

/***********************************************************************************************************************
 * =======================================================����========================================================
 **
 ***********************************************************************************************************************/
void test(void) {
  port_fan_set(false);
  Delayms(10000);
  port_fan_set(true);
  printf("open\r\n");
  Delayms(10000);
  while (1) {
    // unused_gpio_init();
    // gpio_init();
    // port_fan_set(false);
    // printf("close\r\n");
    // Delayms(30000);
    // port_fan_set(true);
    // printf("open\r\n");
    // Delayms(10000);
  }
  error_state.way_circuit_error_status = true;
  error_state.fan_error_status = true;
  // while (1) {
  //   port_fan_set(true);  //���Թرշ���
  //   printf("open\r\n");
  //   Delayms(50000);
  //   port_fan_set(false);  //���Թرշ���
  //   printf("close\r\n");
  //   Delayms(50000);
  //   port_do_debug_light_state();
  //   printf("Initialization completed\r\n");
  // }

  // while (1) {
  //   port_do_debug_light_state();
  //   printf("Initialization completed\r\n");
  // }
}
/**
 * @brief ��Ъ����ʹ�ܺ���rgb��˸
 *
 */
/***********************************************************************************************************************
 * ======================================================������=======================================================
 **
 ***********************************************************************************************************************/
int main(void) {
  HRC_Config(Enable, SCU_HRC_48M, Enable);  //ʱ��ԴSCU_CLK_HRC
  SystemInit();
  DeviceClockAllEnable();  //������������ʱ��
  User_SysTickInit();      //�δ���ʱ����ʼ��Ϊ(����Ϊ1ms�ж�)
  SysTick_Enable();

  // all_gpio_reset();
  unused_gpio_init();
  gpio_init();

  uart0_init();
  zkey_init(&key_module);
  t16_pa4_init();
  // iwdt_init();
  power_on_ozone_working_status();
  printf("Initialization completed\r\n");
  //test();
  while (true) {
    port_do_debug_light_state();
    // feed_iwdt();
    static uint32_t keylastprocess = 0;
    if (port_haspassedms(keylastprocess) > 20) {
      keylastprocess = get_sys_ticket();
      zkey_do_loop_in_each_period(NULL);
    }
    if (starting_up_state) {  //������
      port_do_debug_light_state();
      process_error_even();
      try_adc_gather();
      if (timing_function_is_enable()) {  //��ʱ�����ǿ�����
        try_shutdown();
      }
      if (ozone_pwm_control_is_enable() == true) {
        ozone_pwm_control_module_loop();
        process_rgb_flicker();
      }
    } else {  //�ػ���
    }
  }
}

/**
 * �ϵ繤��״̬���ò���ͨ��
 * ���ػ���������ͨ��
 * ��ʱ��������ͨ��
 * ��Ъ������˸����ͨ��
 * ��λ��������ͨ��
 * ģ�����ȴ��󴥷���led0��˸����ͨ��
 * ģ���ܵ�·���󴥷���led0��led1��˸����ͨ��
 * ע�⣺��Ҫ�Ӹ��߼��������ܵ�·��ѹ�쳣�������ȵ�ѹ�쳣�������������߼�֮���ټ�
 */