/*********************************************************
 *Copyright (C), 2017, Shanghai Eastsoft Microelectronics Co., Ltd
 *文件名:  main.c
 *作  者:  AE Team
 *版  本:  V1.00
 *日  期:  2021/05/13
 *描  述:  GPIO模块示例程序
 *         定时扫描GPIO_PA2的电平状态，高电平点亮LED1，低电平熄灭LED1
 *备  注:
 *本软件仅供学习和演示使用，对用户直接引用代码所带来的风险或后果不承担任何法律责任。
 **********************************************************/
#include "main.h"
#include <stdbool.h> //定义布尔
#define FREQUENCY 48000
static void gears_led_on(uint8_t led_number);
static void timing_led_on(uint8_t led_number);
void g_ozone_work_over(void);

uint32_t g_frequency = FREQUENCY;
uint32_t g_duty[4] = {0, FREQUENCY / 4, FREQUENCY / 2,
                      FREQUENCY - 1}; //目前定义三个档位（25%，50%，100%）
void test(void) {
  while (1) {
  }
  // Delay_100us(30000);
  // port_led0_set(0);
  // port_led1_set(0);
  // port_led2_set(0);
  // port_led3_set(0);
  // port_led_r_set(0);
  // port_led_g_set(0);
  // port_led_b_set(0);
  // Delay_100us(30000);
  // port_led0_set(1);
  // port_led1_set(1);
  // port_led2_set(1);
  // port_led3_set(1);
  // port_led_r_set(1);
  // port_led_g_set(1);
  // port_led_b_set(1);
}
/***********************************************************************************************************************
 * ====================================================串口初始化=====================================================
 **
 ***********************************************************************************************************************/
void uart0_init(void) {
  /**
   * @brief 配置串口0的波特率为115200
   * 时钟为系统时钟 Fpclk 为系统时钟频率
   *
   */
  GPIO_InitSettingType InitSet;
  InitSet.Dir = GPIO_Direction_Output;
  InitSet.DS = GPIO_DS_Output_Strong;
  InitSet.Func = GPIO_Reuse_Func1;
  InitSet.ODE = GPIO_ODE_Output_Disable;
  InitSet.PDE = GPIO_PDE_Input_Disable;
  InitSet.PUE = GPIO_PUE_Input_Disable;
  InitSet.Signal = GPIO_Pin_Signal_Digital;
  GPIO_Init(UART0_TXD0_PIN, &InitSet);

  InitSet.Dir = GPIO_Direction_Input;
  InitSet.DS = GPIO_DS_Output_Strong;
  InitSet.Func = GPIO_Reuse_Func1;
  InitSet.ODE = GPIO_ODE_Output_Disable;
  InitSet.PDE = GPIO_PDE_Input_Disable;
  InitSet.PUE = GPIO_PUE_Input_Disable;
  InitSet.Signal = GPIO_Pin_Signal_Digital;
  GPIO_Init(UART0_RXD0_PIN, &InitSet);

  UART_InitStruType UART_InitStruct;

  UART_InitStruct.UART_BaudRate = 115200;        //波特率
  UART_InitStruct.UART_ClockSet = UART_Clock_1;  //时钟选择不分频
  UART_InitStruct.UART_RxMode = UART_DataMode_8; // 8数据位无奇偶校验位
  //标准极性端口数据和传输数据相同
  UART_InitStruct.UART_RxPolar = UART_Polar_Normal;
  UART_InitStruct.UART_StopBits = UART_StopBits_1; //一个停止位
  UART_InitStruct.UART_TxMode = UART_DataMode_8; // 8数据位无奇偶校验位
  UART_InitStruct.UART_TxPolar = UART_Polar_Normal; //标准usart极性
  UART_Init(UART0, &UART_InitStruct);
  UART_ITConfig(UART0, UART_IT_RB, Enable); /* UART0接收中断使能 */
  /* UART0发送缓冲区空中断模式: 全空中断 */
  UART_TBIMConfig(UART0, UART_TBIM_Byte);
  NVIC_Init(NVIC_UART0_IRQn, NVIC_Priority_1, Enable); //使能串口0中断
  UART0_TxEnable();
  UART0_RxEnable();
}

void UART0_IRQHandler(void) {
  /**
   * @brief 接收来自串口的数据并做回显
   *
   */
  uint8_t uart0_data;
  uart0_data = UART_RecByte(UART0);
  UART_SendByte(UART0, uart0_data);
}

void Uart0SendBuff(uint8_t *buff) {
  while (*buff != '\0') {
    UART_SendByte(UART0, *buff);
    while (UART_GetFlagStatus(UART0, UART_FLAG_TC) == RESET)
      ;
    UART_ClearITPendingBit(UART0, UART_FLAG_TC);
    buff++;
  }
}

//##############################################################################
// port satrt
#define GPIO_GET(port, pin, mirror)                                            \
  (mirror(GPIO_ReadBit(GPIO_Pin_##port##pin) == 1))
#define GPIO_SET(port, pin, mirror, _state)                                    \
  GPIO_WriteBit(GPIO_Pin_##port##pin, mirror _state ? 1 : 0);

//定义
/**
 * @brief PA3~PA6 分别对应30min灯60min灯90min灯120min灯
 * PA7~PA9 分别对应LED_R LED_G LED_B
 * @param state
 */

void port_debug_set(bool state) { GPIO_SET(A, 28, !, state); }
void port_fan_set(bool state) { GPIO_SET(B, 1, !!, state); }
void port_led0_set(bool state) { GPIO_SET(A, 3, !, state); }
void port_led1_set(bool state) { GPIO_SET(B, 13, !, state); }
void port_led2_set(bool state) { GPIO_SET(A, 5, !, state); }
void port_led3_set(bool state) { GPIO_SET(A, 6, !, state); }
void port_led_r_set(bool state) { GPIO_SET(A, 7, !, state); }
void port_led_g_set(bool state) { GPIO_SET(A, 8, !, state); }
void port_led_b_set(bool state) { GPIO_SET(A, 9, !, state); }

bool port_gpio_get_timer_key_state(void) { return GPIO_GET(A, 11, !!); } //主键H
bool port_gpio_get_gears_key_state(void) { return GPIO_GET(A, 16, !!); } //主键M
bool port_gpio_get_interval_key_state(void) { return GPIO_GET(A, 13, !!); }

void led_gpio_init(void) {
  GPIO_InitSettingType x;
  x.Signal = GPIO_Pin_Signal_Digital;
  x.Dir = GPIO_Direction_Output;
  x.Func = GPIO_Reuse_Func0;
  x.ODE = GPIO_ODE_Output_Disable;
  x.DS = GPIO_DS_Output_Normal;
  x.PUE = GPIO_PUE_Input_Disable;
  x.PDE = GPIO_PDE_Input_Disable;
  GPIO_Init(GPIO_Pin_A3, &x);
  GPIO_Init(GPIO_Pin_B13, &x);
  GPIO_Init(GPIO_Pin_A5, &x);
  GPIO_Init(GPIO_Pin_A6, &x);
  GPIO_Init(GPIO_Pin_A7, &x);
  GPIO_Init(GPIO_Pin_A8, &x);
  GPIO_Init(GPIO_Pin_A9, &x);
  GPIO_Init(GPIO_Pin_B1, &x);
  GPIO_Init(GPIO_Pin_A28, &x);
}

// port end
//##############################################################################

/***********************************************************************************************************************
 * ====================================================系统初始化=====================================================
 **
 ***********************************************************************************************************************/
//采用滴答定时器的时钟源，滴答定时器配置的是100us
extern uint32_t g_sys_sick;
/**
 * @brief ticket辅助方法
 */
uint32_t get_sys_ticket(void) { return g_sys_sick; }

uint32_t port_haspassedms(uint32_t ticket) {
  uint32_t nowticket = get_sys_ticket();
  if (nowticket >= ticket) {
    return nowticket - ticket;
  }
  return UINT32_MAX - ticket + nowticket;
}

void port_do_debug_light_state(void) {
  static uint32_t lastprocess = 0;
  static uint8_t debug_led_state = 1;
  if (port_haspassedms(lastprocess) > 1000) {
    lastprocess = get_sys_ticket();
    debug_led_state = !debug_led_state;
    port_debug_set(debug_led_state);
  }
}
//##############################################################################
/***********************************************************************************************************************
 * =====================================================PWM初始化=====================================================
 **
 ***********************************************************************************************************************/
void t16_pinA4_init(void) {
  GPIO_InitSettingType x;

  x.Signal = GPIO_Pin_Signal_Digital; //数字
  x.Dir = GPIO_Direction_Output;      //输出模式
  x.Func = GPIO_Reuse_Func2;          //复用到T16N0_1功能
  x.ODE = GPIO_ODE_Output_Disable;    //开漏使能
  x.DS = GPIO_DS_Output_Normal;       //普通电流模式
  x.PUE = GPIO_PUE_Input_Enable;      //弱上拉使能
  x.PDE = GPIO_PDE_Input_Disable;     //弱下拉禁止
  /* 配置PA4为T16N0输出通道1 */
  GPIO_Init(GPIO_Pin_A4, &x);
}
void t16n0_1_init(void) {
  // PA4 T16N0_1
  T16Nx_BaseInitStruType x;
  T16Nx_PWMInitStruType y;
  /* 初始化T16Nx定时器*/
  x.T16Nx_ClkS = T16Nx_ClkS_PCLK; //时钟源48M
  x.T16Nx_SYNC = Disable;         //不同步
  x.T16Nx_EDGE = T16Nx_EDGE_Rise; //上升沿触发
  x.T16Nx_Mode = T16Nx_Mode_PWM;  // 选用PWM模式
  x.T16Nx_PREMAT = 0x01;          /* 预分频比1:1 */
  T16Nx_BaseInit(T16N0, &x);
  /* 配置T16N0通道1输出 */
  y.T16Nx_MOE0 = Disable;
  y.T16Nx_MOE1 = Enable;
  y.T16Nx_POL0 =
      POSITIVE; //在串口发送的时候，正极性代表发送的数据与接受的数据相同，负极性代表与发送的数据相反，在这么不知道有没有作用
  y.T16Nx_POL1 = POSITIVE;
  y.T16Nx_PWMMODE = T16Nx_PWMMode_INDEP; //选择独立模式
  y.PWMDZE = Disable;                    // PWM互补模式死区使能
  y.REGBUFEN = Enable; //缓冲寄存器使能 (REGBUFEN目前不知道干什么用的)
  T16Nx_PMWOutInit(T16N0, &y);
  /* 配置T16N0 通道1输出 */
  /*MAT2 MAT3 通道的中断配置*/
  //匹配寄存器值匹配后的工作模式，计数到以后： 继续计数不产生中断
  T16Nx_MAT2ITConfig(T16N0, T16Nx_Go_No);
  //匹配寄存器值匹配后的工作模式,清零并重新计数，产生中断
  T16Nx_MAT3ITConfig(T16N0, T16Nx_Clr_Int);

  /*MAT2 MAT3 匹配后的输出电平高低*/
  T16Nx_MAT2Out1Config(T16N0,
                       T16Nx_Out_High); //匹配后输出端口的模式，输出高还是低
  T16Nx_MAT3Out1Config(T16N0,
                       T16Nx_Out_Low); //匹配后输出端口的模式，输出高还是低
  //以上是设置模式，输出高低电平
  T16Nx_SetCNT1(T16N0, 0);         //设定计数器的初始值
  T16Nx_SetMAT2(T16N0, g_duty[3]); //设置匹配寄存器的数值
  uint32_t duty = g_frequency;
  T16Nx_SetMAT3(T16N0, duty); //设置匹配寄存器的数值
  //设置计数器峰值//根据这个得到定时的时钟48M/48000=1khZ(在独立模式下PWM的周期由TOP1决定为TOP+1，周期算出来是1ms)
  T16Nx_SetTOP1(T16N0, g_frequency);
  //以上是设置占空比
  /* 配置输出管脚 */
  t16_pinA4_init();
  T16Nx_Enable(T16N0);
  return;
}
/**
 * @brief Set the pwm frequency duty object
 *
 * @param frequency 频率
 * @param duty 占空比
 */
void set_pwm_frequency_duty(uint32_t frequency, uint32_t duty) {
  T16Nx_Disable(T16N0);
  t16n0_1_init();
  T16Nx_SetMAT2(T16N0, duty);
  duty = g_frequency;
  T16Nx_SetMAT3(T16N0, duty);
  T16Nx_SetTOP1(T16N0, frequency);
}
int ozone_work_state = 0; // 0没有工作，1一直工作，2定时工作
void ozone_work_mode(int mode) {
  ozone_work_state = 1;
  port_fan_set(true);
  switch (mode) {
  case 0:
    gears_led_on(0);
    break;
  case 1:
    gears_led_on(1);
    break;
  case 2:
    gears_led_on(2);
    break;
  case 3:
    g_ozone_work_over(); //结束工作
    break;
  default:
    break;
  }
}
int g_ozen_gears = 1; // M键我认为是上电键，所以默认下次设置50%的PWM输出

void set_ozen_gears(int ozen_gears) {
  /**
   * @brief Construct a new switch object
   * 设置pwm输出
   */
  switch (ozen_gears) {
  case 0:
    set_pwm_frequency_duty(g_frequency, g_duty[3]);
    g_ozen_gears = 1;
    printf("pwm g_duty:%d", g_duty[3]);
    ozone_work_mode(0);
    break;
  case 1:
    set_pwm_frequency_duty(g_frequency, g_duty[2]);
    g_ozen_gears = 2;
    printf("pwm g_duty:%d", g_duty[2]);
    ozone_work_mode(1);
    break;
  case 2:
    set_pwm_frequency_duty(g_frequency, g_duty[1]);
    g_ozen_gears = 3;
    printf("pwm g_duty:%d", g_duty[1]);
    ozone_work_mode(2);
    break;
  case 3:
    set_pwm_frequency_duty(g_frequency, g_duty[0]);
    g_ozen_gears = 0;
    printf("pwm g_duty:%d", g_duty[0]);
    ozone_work_mode(3);
    break;
  }
}
uint32_t g_count_down_begin_sys_time = 0;
int time_key_press_frequency = 0; //每按下4次进行清0
uint32_t g_ozone_work_time = 0;
void set_ozone_work_time() {
  if (!ozone_work_state) { //如果现在不是工作状态，直接开始工作
    set_ozen_gears(0);
  }
  //获取现在的时间，作为判断倒计时时间的基准
  g_count_down_begin_sys_time = get_sys_ticket();
  ozone_work_state = 2; //处于定时工作状态
  port_fan_set(1);      //风扇开始工作
  switch (time_key_press_frequency) {
  case 0: //两小时
    // g_ozone_work_time = 50000;//5s
    // g_ozone_work_time = 72000000;
    g_ozone_work_time = 3600000;
    printf("g_ozone_work_time:%d", g_ozone_work_time);
    time_key_press_frequency = 1;
    timing_led_on(0);
    break;
  case 1: //四小时
    // g_ozone_work_time = 100000;
    g_ozone_work_time = 144000000;
    printf("g_ozone_work_time:%d", g_ozone_work_time);
    time_key_press_frequency = 2;
    timing_led_on(1);
    break;
  case 2: //六小时
    // g_ozone_work_time = 150000;
    g_ozone_work_time = 216000000;
    printf("g_ozone_work_time:%d", g_ozone_work_time);
    time_key_press_frequency = 3;
    timing_led_on(2);
    break;
  case 3: //八小时
    // g_ozone_work_time = 200000;
    g_ozone_work_time = 288000000;
    printf("g_ozone_work_time:%d", g_ozone_work_time);
    time_key_press_frequency = 4;
    timing_led_on(3);
    break;
  case 4:
    ozone_work_state = 1; //一直工作
    printf("close timing");
    timing_led_on(4);
    time_key_press_frequency = 0;
    break;
  default:
    break;
  }
}

void g_ozone_work_over(void) {
  /**
   * @brief 定时结束
   *
   */
  set_pwm_frequency_duty(g_frequency, 0); //关闭PWM输出
  ozone_work_state = 0;
  gears_led_on(3);  //关闭RGB
  timing_led_on(4); //关闭4个led灯
  time_key_press_frequency =
      0; //将time_key_press_frequency=0下次按键按下从定时2小时开始
  g_ozen_gears = 0;    // g_ozen_gears=0下次按键按下从最高档开始
  port_fan_set(false); //风扇结束工作
}
/**
 * @brief 定时结束后将
 *
 */
void is_ozone_work_time_over() {
  if (port_haspassedms(g_count_down_begin_sys_time) >= g_ozone_work_time) {
    g_count_down_begin_sys_time = get_sys_ticket();
    g_ozone_work_over();
    printf("time over\r\n");
  }
}
/**
 * @brief
 *
 * @param led_number 0亮红灯 1亮绿灯 2亮蓝灯 3全灭
 */
static void gears_led_on(uint8_t led_number) {
  switch (led_number) {
  case 0:
    port_led_r_set(true);
    port_led_g_set(false);
    port_led_b_set(false);
    break;
  case 1:
    port_led_r_set(false);
    port_led_g_set(true);
    port_led_b_set(false);
    break;
  case 2:
    port_led_r_set(false);
    port_led_g_set(false);
    port_led_b_set(true);
    break;
  case 3:
    port_led_r_set(false);
    port_led_g_set(false);
    port_led_b_set(false);
    break;
  default:
    break;
  }
}
/**
 * @brief  定时时间设定后对应指示灯亮起
 *
 * @param led_number 0亮led0 1亮led1 2亮led2 3亮led3 4全灭并代表臭氧机结束工作
 */
static void timing_led_on(uint8_t led_number) {
  switch (led_number) {
  case 0:
    port_led0_set(true);
    port_led1_set(false);
    port_led2_set(false);
    port_led3_set(false);
    break;
  case 1:
    port_led0_set(false);
    port_led1_set(true);
    port_led2_set(false);
    port_led3_set(false);
    break;

  case 2:
    port_led0_set(false);
    port_led1_set(false);
    port_led2_set(true);
    port_led3_set(false);
    break;

  case 3:
    port_led0_set(false);
    port_led1_set(false);
    port_led2_set(false);
    port_led3_set(true);
    break;
  case 4:
    port_led0_set(false);
    port_led1_set(false);
    port_led2_set(false);
    port_led3_set(false);
    break;
  default:
    break;
  }
}
// T16N_CNT1 计数器一直在计数
// T16N_MAT2匹配数值相当于STM32TTIM-CCRX
// T16Nx_SetTOP1相当于STM32TIM-ARR

/*独立模式，T16N0OUT0/T16N0OUT1 输出不同的 PWM 波形。其中 T16N_CNT0 匹配
T16N_MAT0/T16N_MAT1，控制 T16N0OUT0 输出，PWM 周期由 T16N_TOP0 设定，
为 T16N_TOP0+1；而 T16N_CNT1 匹配 T16N_MAT2/ T16N_MAT3，控制 T16N0OUT1
输出，PWM 周期由 T16N_TOP1 设定，为 T16N_TOP1+1*/

/***********************************************************************************************************************
 * =====================================================按键模块======================================================
 **
 ***********************************************************************************************************************/

void PINTx_Init(void) {
  GPIO_InitSettingType x;
  PINT_InitSettingType y;

  x.Signal = GPIO_Pin_Signal_Digital;
  x.Dir = GPIO_Direction_Input;
  x.Func = GPIO_Reuse_Func0;
  x.PUE = GPIO_PUE_Input_Disable;
  x.PDE = GPIO_PDE_Input_Enable;
  GPIO_Init(GPIO_Pin_A1, &x);

  y.IE_Set = PINT_IE_Set_Enable;
  y.Trigger_Style = PINT_Trigger_Rising_Edge;
  PINT_Init(GPIO_Pin_A1, &y);
  NVIC_Init(NVIC_PINT1_IRQn, NVIC_Priority_1, Enable);

  return;
}

void key_gpio_init(void) {
  /**
   * @brief PA11~PA13对应定时按键 高低档按键 间歇时间按键
   *
   */
  GPIO_InitSettingType x;

  x.Signal = GPIO_Pin_Signal_Digital;
  x.Dir = GPIO_Direction_Input;
  x.Func = GPIO_Reuse_Func0;
  x.PUE = GPIO_PUE_Input_Disable;
  x.PDE = GPIO_PDE_Input_Enable;
  GPIO_Init(GPIO_Pin_A11, &x); //主键H
  GPIO_Init(GPIO_Pin_A16, &x); //主键M
  GPIO_Init(GPIO_Pin_A13, &x);
}

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),
};
static void onkey(zkey_t *key, zkey_state_t key_state);
static zkey_module_t key_module = ZMODULE_INIT(s_keys, onkey);
static 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);
  }
}

void gpio_init() {
  led_gpio_init();
  key_gpio_init();
  PINTx_Init();
}
/***********************************************************************************************************************
 * ======================================================主函数=======================================================
 **
 ***********************************************************************************************************************/
uint8_t uart0_data[] = {"www.zhuang.com"};
int main(void) {                                                             
  HRC_Config(Enable, SCU_HRC_48M, Enable); //时钟源SCU_CLK_HRC
  SystemInit();
  DeviceClockAllEnable(); //打开所有外设时钟
  User_SysTickInit();     //滴答定时器初始化为
  SysTick_Enable();
  uart0_init();
  gpio_init();
  zkey_init(&key_module);
  t16n0_1_init();     //配置PA4输出pwm
  gears_led_on(0);    //上电以后默认高档工作亮红灯
  port_fan_set(true); //上电风扇开始工作
  printf("Initialization completed\r\n");
  // test();
  while (1) {
    port_do_debug_light_state();
    port_key_state();
    if (ozone_work_state == 2)
      is_ozone_work_time_over();
  }
}