update

.clang-format

@@ -0,0 +1,5 @@
+# Defines the Chromium style for automatic reformatting.
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+Language: Cpp
+BasedOnStyle: Google
+ColumnLimit: 120

APP/key.c

@@ -86,6 +86,34 @@ 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;
+//##############新的############
+extern pwm_message_t pwm_message;
+extern rgb_message_t rgb_message;
+shutdown_before_message_t shutdown_before_message;
+void process_switchkey(void) {
+  static uint8_t switchkey_press_conut = 0;
+  switchkey_press_conut++;
+  switch (switchkey_press_conut) {
+  case 1: //开机后工作模式为关机前的工作模式,无定时无间歇
+    pwm_module_set_pwm_output_2(
+        shutdown_before_message.hardware_frequency, shutdown_before_message.hardware_duty,
+        shutdown_before_message.large_period, shutdown_before_message.large_duty);
+    light_module_set_rgb_mode(rgb_message.turn_off_the_mode_before_rgb);
+    port_fan_set(true);
+    break;
+  case 2: //关机
+    switchkey_press_conut = 0;
+    shutdown_before_message.hardware_duty=pwm_message.s_hardware_duty;
+    shutdown_before_message.hardware_frequency=pwm_message.s_hardware_frequency;
+    shutdown_before_message.large_duty=pwm_message.s_large_duty;
+    shutdown_before_message.large_period=pwm_message.s_large_period;
+    light_module_set_rgb_mode(RGB_CLOSE);
+    light_module_set_timing_light_mode(CLOSE_ALL_LED);
+    pwm_module_set_pwm_output_2(1,100,0,0);
+    port_fan_set(false);
+    break;
+  }
+}
 
 void onkey(zkey_t *key, zkey_state_t key_state) {
   /**
@@ -132,27 +160,30 @@ void onkey(zkey_t *key, zkey_state_t key_state) {
       printf("key2 zks_rising_edge\r\n");
       // set_interval_time();
       // set_interval_time(running_time.interval_time_state);
-    } 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("key3 zks_rising_edge\r\n");
-       process_switch_key();
-      // set_interval_time(running_time.interval_time_state);
     }
-  } else {
+    // 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("key3 zks_rising_edge\r\n");
+    //    process_switch_key();
+    //   // set_interval_time(running_time.interval_time_state);
+    // }
+  }
+  // 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");
-      process_switch_key();
+    // process_switch_key();
+    process_switchkey();
     // set_interval_time(running_time.interval_time_state);
   }
-  }
+  // }
 }
 void port_key_state(void) {
   static uint32_t keylastprocess = 0;

APP/key.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "port.h"
 #include "ozone_work.h"
+#include "pwm.h"
 #define POWER_KEY_TRIGGER_TIME 3000
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
 #define ZKEY_INIT(_name, _get_key_state)                                       \

APP/key2.c

@@ -0,0 +1,194 @@
+#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("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 zkey_init(zkey_module_t *module) {
+  /**
+   * @brief 按键初始化，三个状态的初始化，之前的，现在的，之后的
+   *
+   */
+  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;
+//##############新的############
+extern pwm_message_t pwm_message;
+extern rgb_message_t rgb_message;
+shutdown_before_message_t shutdown_before_message;
+void process_switchkey(void) {
+  static uint8_t switchkey_press_conut = 0;
+  switchkey_press_conut++;
+  switch (switchkey_press_conut) {
+  case 1: //开机后工作模式为关机前的工作模式,无定时无间歇
+    pwm_module_set_pwm_output_2(
+        shutdown_before_message.hardware_frequency, shutdown_before_message.hardware_duty,
+        shutdown_before_message.large_period, shutdown_before_message.large_duty);
+    light_module_set_rgb_mode(rgb_message.turn_off_the_mode_before_rgb);
+    port_fan_set(true);
+    break;
+  case 2: //关机
+    switchkey_press_conut = 0;
+    shutdown_before_message.hardware_duty=pwm_message.s_hardware_duty;
+    shutdown_before_message.hardware_frequency=pwm_message.s_hardware_frequency;
+    shutdown_before_message.large_duty=pwm_message.s_large_duty;
+    shutdown_before_message.large_period=pwm_message.s_large_period;
+    light_module_set_rgb_mode(RGB_CLOSE);
+    light_module_set_timing_light_mode(CLOSE_ALL_LED);
+    pwm_module_set_pwm_output_2(1,100,0,0);
+    port_fan_set(false);
+    break;
+  }
+}
+
+void onkey(zkey_t *key, zkey_state_t key_state) {
+  /**
+   * @brief  判断每个按键触发的状态
+   *
+   * @param key
+   * @param key_state
+   */
+  if (get_ozone_starting_up_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();
+      // set_interval_time(running_time.interval_time_state);
+    }
+    // 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("key3 zks_rising_edge\r\n");
+    //    process_switch_key();
+    //   // set_interval_time(running_time.interval_time_state);
+    // }
+  }
+  // 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");
+    // process_switch_key();
+    process_switchkey();
+    // 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);
+  }
+}

APP/key2.h

@@ -0,0 +1,69 @@
+#pragma once
+#include "port.h"
+#include "ozone_work.h"
+#include "pwm.h"
+#define POWER_KEY_TRIGGER_TIME 3000
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
+#define ZKEY_INIT(_name, _get_key_state)                                       \
+  { .name = _name, .get_key_state = _get_key_state }
+#define ZMODULE_INIT(_keys, _onkey) /**/                                       \
+  {                                 /**/                                       \
+    .keys = _keys,                  /**/                                       \
+        .nkey = ARRAY_SIZE(_keys),  /**/                                       \
+        .onkey = _onkey             /**/                                       \
+  }
+
+typedef enum {
+  // mode1
+  zks_keep,
+  zks_rising_edge,  //上升沿按键按下从0-1
+  zks_falling_edge, //下降沿按键抬起1-0
+
+  // mode2
+  zks_trigger_event,          //触发
+  zks_longtime_trigger_event, //长时间触发
+} zkey_event_t;
+typedef zkey_event_t zkey_state_t;
+
+typedef bool (*get_key_state_t)(void);
+
+typedef struct {
+  const char *name;
+  get_key_state_t get_key_state;
+  bool last_io_state;
+
+  zkey_state_t cur_state;    //当前的状态
+  uint32_t keep_state_count; /*按键当前状态保持了多久*/
+
+  bool hasProcessed; /*useful for user*/
+  bool after_filter_state;
+
+  uint32_t currentstatekeep_count; //消抖使用
+  bool last_real_state;            //消抖使用
+
+} zkey_t;
+
+static uint16_t s_key_press_state;
+static uint16_t s_key_long_press_time_ms = 3000; //长按判断时间
+#define KEY_SCAN_PERIOD 20                       //扫描周期20ms
+
+typedef struct {
+  zkey_t *keys;
+  int nkey;
+  void (*onkey)(zkey_t *key, zkey_state_t key_state);
+} zkey_module_t;
+
+static zkey_module_t *s_module;
+static bool s_inited;
+
+
+
+
+
+void zkey_init(zkey_module_t *module);
+void zkey_do_loop_in_each_period(void *_null);
+void zkey_process_each(zkey_t *each);
+void zkey_process_each_after_filter(zkey_t *each, bool now_io_state);
+void read_key_state(void);
+void onkey(zkey_t *key, zkey_state_t key_state);
+void port_key_state(void);

APP/light.c

@@ -6,26 +6,26 @@ timing_message_t timing_message;
 
 /**
  * @brief 设置灯的模式,高低中分别亮不同颜色的灯
- *
+ * 高档红色，中档蓝色，低档绿色
  */
 void light_module_set_rgb_mode(RGB_MODE_T mode) {
-  if (mode == OPEN_RED_LIGHT) {
+  if (mode == RGB_COLOR_RED) {
     port_led_r_set(true);
     port_led_g_set(false);
     port_led_b_set(false);
-    rgb_message.turn_off_the_mode_before_rgb = OPEN_RED_LIGHT;
-  } else if (mode == OPEN_GREEN_LIGHT) {
+    rgb_message.turn_off_the_mode_before_rgb = RGB_COLOR_RED;
+  } else if (mode == RGB_COLOR_BLUE) {
     port_led_r_set(false);
     port_led_g_set(true);
     port_led_b_set(false);
-    rgb_message.turn_off_the_mode_before_rgb = OPEN_GREEN_LIGHT;
-  } else if (mode == OPEN_BLUE_LIGHT) {
+    rgb_message.turn_off_the_mode_before_rgb = RGB_COLOR_BLUE;
+  } else if (mode == RGB_COLOR_GERRN) {
     port_led_r_set(false);
     port_led_g_set(false);
     port_led_b_set(true);
-    rgb_message.turn_off_the_mode_before_rgb = OPEN_BLUE_LIGHT;
-  } else if (mode == CLOSE_RGB_LIGHT) {
-    rgb_message.turn_off_the_mode_before_rgb = OPEN_BLUE_LIGHT;
+    rgb_message.turn_off_the_mode_before_rgb = RGB_COLOR_GERRN;
+  } else if (mode == RGB_CLOSE) {
+    //rgb_message.turn_off_the_mode_before_rgb = RGB_CLOSE;
     port_led_r_set(false);
     port_led_g_set(false);
     port_led_b_set(false);
@@ -53,7 +53,7 @@ void process_rgb_flicker_mode() {
       // turn_off_the_mode_before_rgb保存了关闭之前的RGB亮灯的模式
       light_module_set_rgb_mode(rgb_message.turn_off_the_mode_before_rgb);
     } else {
-      light_module_set_rgb_mode(CLOSE_RGB_LIGHT);
+      light_module_set_rgb_mode(RGB_CLOSE);
       rgb_ticket_count = 0;
     }
     rgb_ticket_count++;
@@ -129,7 +129,7 @@ void light_module_set_error_light_mode(uint8_t mode) {
  *
  */
 void light_module_close_all_light(void) {
-  light_module_set_rgb_mode(CLOSE_RGB_LIGHT);
+  light_module_set_rgb_mode(RGB_CLOSE);
   light_module_set_timing_light_mode(CLOSE_ALL_LED);
   light_module_set_rgb_flicker_mode(false);
 }
@@ -143,16 +143,16 @@ void test_set_rgb_mode(void) {
   static int i = 0;
   if (i == 0) {
     i = 1;
-    light_module_set_rgb_mode(OPEN_RED_LIGHT);
+    light_module_set_rgb_mode(RGB_COLOR_RED);
   } else if (i == 1) {
     i = 2;
-    light_module_set_rgb_mode(OPEN_GREEN_LIGHT);
+    light_module_set_rgb_mode(RGB_COLOR_BLUE);
   } else if (i == 2) {
     i = 3;
-    light_module_set_rgb_mode(OPEN_BLUE_LIGHT);
+    light_module_set_rgb_mode(RGB_COLOR_GERRN);
   } else if (i == 3) {
     i = 0;
-    light_module_set_rgb_mode(CLOSE_RGB_LIGHT);
+    light_module_set_rgb_mode(RGB_CLOSE);
   }
 }
 /**

APP/light.h

@@ -8,10 +8,10 @@
 
 
 typedef enum {
-  OPEN_RED_LIGHT = 0,   /*打开红灯*/
-  OPEN_GREEN_LIGHT = 1, /*打开绿灯*/
-  OPEN_BLUE_LIGHT = 2,  /*打开蓝灯*/
-  CLOSE_RGB_LIGHT = 3,  /*关闭灯*/
+  RGB_COLOR_RED = 0,   /*打开红灯*/
+  RGB_COLOR_GERRN = 1, /*打开绿灯*/
+  RGB_COLOR_BLUE = 2,  /*打开蓝灯*/
+  RGB_CLOSE = 3,  /*关闭灯*/
 } RGB_MODE_T;
 
 

APP/main.c

@@ -1,3 +1,4 @@
+#if 0 
 /*********************************************************
  *Copyright (C), 2017, Shanghai Eastsoft Microelectronics Co., Ltd
  *文件名:  main.c
@@ -10,7 +11,9 @@
  *本软件仅供学习和演示使用，对用户直接引用代码所带来的风险或后果不承担任何法律责任。
  **********************************************************/
 #include "main.h"
+
 #include <stdbool.h>  //定义布尔
+
 // extern ozone_message_t ozone_message;
 extern zkey_module_t key_module;
 bool rgb_flicker_state = false;
@@ -49,15 +52,15 @@ void feed_iwdt(void) {
 //############### 测试一下看门狗 ##############//
 
 /**
- * @brief 上电臭氧工作情况,高档一直工作
+ * @brief 上电臭氧工作情况,设备中设置有开关机按键，所以外部上电后，不让设备工作
  *
  */
 void power_on_ozone_working_status(void) {
-  // PWM频率1Khz，占空比0,占空比低有效，设置占空比为0，pwm一直输出高电平
-  HOOK_pwm_module_set_pwm_duty(1, 0);
+  // PWM频率1Khz，占空比0,占空比低有效，设置占空比为100，pwm一直输出低电平
+  HOOK_pwm_module_set_pwm_duty(1, 100);
   light_module_set_timing_light_mode(CLOSE_ALL_LED);
-  light_module_set_rgb_mode(OPEN_RED_LIGHT);
-  port_fan_set(true); //打开你风扇
+  light_module_set_rgb_mode(RGB_COLOR_RED);
+  port_fan_set(false); //打开你风扇
 }
 
 /***********************************************************************************************************************
@@ -105,3 +108,19 @@ int main(void) {
     // feed_iwdt(); //当产生中断的时候进行喂狗操作
   }
 }
+
+#endif
+#include <stdbool.h>  //定义布尔
+
+#include "main.h"
+extern zkey_module_t key_module;
+int main(void) {
+  HRC_Config(Enable, SCU_HRC_48M, Enable);  //时钟源SCU_CLK_HRC
+  SystemInit();
+  DeviceClockAllEnable();  //打开所有外设时钟
+  User_SysTickInit();      //滴答定时器初始化为(配置为1ms中断)
+  SysTick_Enable();
+  uart0_init();
+  gpio_init();
+  // zkey_init(&key_module);
+}

APP/pwm.c

@@ -2,8 +2,11 @@
 #define TIMING_TICK 1800000
 #define INTERVAL_TICK 30000
 #define CLCK 48
-uint32_t s_hardware_period; //单位ms
-uint32_t s_hardware_duty;   //单位ms
+pwm_message_t pwm_message={.s_hardware_frequency=1};
+// uint32_t s_hardware_frequency; //单位ms，保存现在的PWM频率
+// uint32_t s_hardware_duty;   //单位ms，保存现在的PWM占空比
+// uint32_t s_large_period;     //单位ms，保存现在的定时周期
+// uint32_t s_large_duty = 100; //单位ms，保存现在的定时占空比
 
 /**
  * @brief s_large_duty是由s_large_period与INTERVAL_TIME决定
@@ -12,8 +15,7 @@ uint32_t s_hardware_duty;   //
  * s_large_duty = (30000/1800000)*100
  *
  */
-uint32_t s_large_period;     //单位ms
-uint32_t s_large_duty = 100; //单位ms
+
 uint32_t begin_ticket;
 uint8_t update_large_period_count;
 bool enableFlag = false;
@@ -29,6 +31,10 @@ void HOOK_pwm_stop(void) {
 
 bool HOOK_pwm_is_enable(void) { return enableFlag; }
 
+/**
+ * @brief 按键按下后调用这个方法更新定时周期
+ * 
+ */
 void update_large_period(void) {
   uint32_t large_period;
   update_large_period_count++;
@@ -51,9 +57,18 @@ void update_large_period(void) {
     break;
   }
   pwm_module_set_pwm_output_1(
-      large_period, s_large_duty); //将更新后的周期以及现在的占空比传进去
+      large_period, pwm_message.s_large_duty); //将更新后的周期以及现在的占空比，进行设置
 }
 
+
+
+
+
+
+
+
+
+
 /**
  * @brief 一直工作的时间定时的占空比为100，
  * 间歇时间设置300000
@@ -61,7 +76,7 @@ void update_large_period(void) {
  * @param duty
  */
 void pwm_module_set_pwm_output_1(uint32_t large_period, uint32_t large_duty) {
-  pwm_module_set_pwm_output_2(s_hardware_period, s_hardware_duty, large_period,
+  pwm_module_set_pwm_output_2(pwm_message.s_hardware_frequency, pwm_message.s_hardware_duty, large_period,
                               large_duty);
 }
 /**
@@ -75,15 +90,15 @@ void pwm_module_set_pwm_output_1(uint32_t large_period, uint32_t large_duty) {
 void pwm_module_set_pwm_output_2(uint32_t hardware_period,
                                  uint32_t hardware_duty, uint32_t large_period,
                                  uint32_t large_duty) {
-  s_hardware_period = hardware_period;
-  s_hardware_duty = hardware_duty;
-  s_large_period = large_period;
-  s_large_duty = large_duty;
+  pwm_message.s_hardware_frequency = hardware_period;
+  pwm_message.s_hardware_duty = hardware_duty;
+  pwm_message.s_large_period = large_period;
+  pwm_message.s_large_duty = large_duty;
 
   begin_ticket = get_sys_ticket();
 
   enableFlag = true;
-  HOOK_pwm_module_set_pwm_duty(s_hardware_period, s_hardware_duty);
+  HOOK_pwm_module_set_pwm_duty(pwm_message.s_hardware_frequency, pwm_message.s_hardware_duty);
 }
 
 void pwm_module_stop_pwm(void) { enableFlag = false; }
@@ -93,10 +108,10 @@ void pwm_module_loop(void) {
     HOOK_pwm_stop();
     return;
   }
-  if (port_haspassedms(begin_ticket) % s_large_period <=
-      s_large_period * s_large_duty / 100) {
+  if (port_haspassedms(begin_ticket) % pwm_message.s_large_period <=
+      pwm_message.s_large_period * pwm_message.s_large_duty / 100) {
     if (!HOOK_pwm_is_enable()) {
-      HOOK_pwm_module_set_pwm_duty(s_hardware_period, s_hardware_duty);
+      HOOK_pwm_module_set_pwm_duty(pwm_message.s_hardware_frequency, pwm_message.s_hardware_duty);
     }
   } else {
     enableFlag = false;

APP/pwm.h

@@ -7,6 +7,21 @@
 #include "port.h"
 #include "system_ES8P5066.h"
 
+typedef struct {
+  uint32_t s_hardware_frequency; // 单位Khz，保存现在的PWM频率
+  uint32_t s_hardware_duty;      // 保存现在的PWM占空比
+  uint32_t s_large_period;       // 单位ms，保存现在的定时周期
+  uint32_t s_large_duty;         // 保存现在的定时占空比
+} pwm_message_t;
+
+typedef struct {
+  uint32_t hardware_frequency; // 单位Khz，保存关机前的PWM频率
+  uint32_t hardware_duty;      // 保存关机前的PWM占空比
+  uint32_t large_period;       // 单位ms，保存关机前的定时周期
+  uint32_t large_duty;         // 保存关机前的定时占空比
+
+} shutdown_before_message_t;
+
 void HOOK_pwm_module_set_pwm_duty(uint32_t frequency, uint32_t duty);
 void HOOK_pwm_stop(void);
 bool HOOK_pwm_is_enable(void);