update

README.md

@@ -20,6 +20,18 @@
         单导联 3.2v 162ua
         开发板      3ua
 
+
+        什么都不开:320
+        打开zapp定时器,和慢广播后: 320->330
+        系统初始化: 260->270
+
+        屏幕:10ma        
+
+开机后,初始化外设后,如果关闭外设电源,功耗不降,反升
+
+
+外设的供电如果关闭之后,需要先将部分引脚的电平拉低,然后再将引脚设置成default状态.
+
 ...
 
 ```
@@ -28,28 +40,55 @@
 ```
 
 ```
-        onTimer
-                pushEvent.
-
         onCommand
-                pushEvent.
+                startCapture(inMainPage)
+                        pushStartCaptureEvent
+                stopCapture(inCapturePage)
+                        pushStopCaptureEvent
+
         onConnect
                 loadDevice
-                        doSomeThing.
-                        block?how_to_do?
-
         onDisconnect
                 unloadDevice
-        onCharging
-
-        onChargEnd
-
-        startCapture
-
-        stopCapture
+                
+        onCharging(inIdlePage)
+                changePageToChanging
 
+        onChargEnd(inChangePage)
+                changePageToPowerOff
+                unloadDevice
 
 
+State
+        standby
+                onConnected
+                        loadDevice
+                onChanger
+                        loadDevice and changeTo chargPage
+        welcomPage
+
+        mainPage
+                onChange
+                onStartCapture
+        capture
+                onData
+                onStopCapture
+                onError
+                        changeToErrorPage(time)
+                        pushDelayEvent()
+                onErrorPageOvertime
+
+        charging
+                onChargeEnd
+
+功耗管理:
+        待机状态:
+                电池管理-待机状态
+                电池管理-开机状态
+                其他:失能
+        
+        开机状态:
+                全部使能
 
 
 ```

app/src/app_basic_service/basic/event.h

@@ -27,6 +27,7 @@ typedef struct {
 
 typedef struct {
   app_event_type_t eventType;
+  uint8_t          *hang_up_flag;
   union {
     struct {
       uint32_t           frameIndex;

app/src/app_basic_service/basic/state.h

@@ -4,45 +4,26 @@
 
 #include "aproject_config/config.h"
 typedef enum {
-  // 待机
-  kdevice_state_standby = 0,
-  // 充电中
-  kdevice_state_charging,
-  // 开机
-  kdevice_state_poweron,
-  // 首页
-  kdevice_state_home,
-  // 提示用户保持静止
-  kdevice_state_keep_still,
-  // 采集中
-  kdevice_state_sampling,
-  // 采集完成
-  kdevice_state_sampling_complete,
-  // 采集异常
-  kdevice_state_sampling_error,
-  // 测试模式
-  kdevice_state_test_mode,
+  kstate_standby,
+  kstate_welcomPage,
+  kstate_mainPage,
+  kstate_capture,
+  kstate_charging,
 } device_state_t;
 
 static const char* device_state_to_str(device_state_t ds) {
   switch (ds) {
-    case kdevice_state_standby:
-      return "standby";
-    case kdevice_state_poweron:
-      return "poweron";
-    case kdevice_state_home:
-      return "home";
-    case kdevice_state_keep_still:
-      return "keep_still";
-    case kdevice_state_sampling:
-      return "sampling";
-    case kdevice_state_sampling_complete:
-      return "sampling_complete";
-    case kdevice_state_sampling_error:
-      return "sampling_error";
-    case kdevice_state_charging:
-      return "charging";
+    case kstate_standby:
+      return "kstate_standby";
+    case kstate_welcomPage:
+      return "kstate_welcomPage";
+    case kstate_mainPage:
+      return "kstate_mainPage";
+    case kstate_capture:
+      return "kstate_capture";
+    case kstate_charging:
+      return "kstate_charging";
     default:
-      return "unknow";
+      return "unknown";
   }
 }

app/src/app_basic_service/zapp.c

@@ -6,8 +6,8 @@ typedef struct {
   app_event_listener_t cbfunc;
 } AppEventListener;
 
-static device_state_t    m_device_state           = kdevice_state_standby;  // 设备状态
-static uint32_t          m_change_to_cur_state_tp = 0;                      // 切换到当前状态的时间戳
+static device_state_t    m_device_state           = kstate_standby;  // 设备状态
+static uint32_t          m_change_to_cur_state_tp = 0;               // 切换到当前状态的时间戳
 static on_state_change_t m_onstate_change;
 static AppEventListener  m_listener[10];
 static int               m_listener_num = 0;
@@ -15,17 +15,34 @@ static int               m_listener_num = 0;
 APP_TIMER_DEF(m_state_machine_driver_tmr);  // 状态机驱动定时器
 #define SCHED_MAX_EVENT_DATA_SIZE MAX(sizeof(app_event_t), APP_TIMER_SCHED_EVENT_DATA_SIZE)
 
+APP_TIMER_DEF(m_delay_event_preset_tmr0);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr1);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr2);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr3);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr4);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr5);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr6);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr7);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr8);  //
+APP_TIMER_DEF(m_delay_event_preset_tmr9);  //
+
+typedef struct {
+  app_timer_id_t tmrid;
+  app_event_t    eventcache;
+  bool           usage;
+} zevent_preset_tmr_t;
+zevent_preset_tmr_t m_delay_event_preset_tmr[10] = {0};
+
 /***********************************************************************************************************************
  *                                                      CALL BAK                                                       *
  ***********************************************************************************************************************/
-static void state_machine_driver_tmr_cb(void* p_context) {  //
-  static app_event_t appevent;
-  appevent.eventType = kevent_tmr_scheduler_event;
-  wd_feed();
-  zapp_ebus_push_event(&appevent);
-}
 
 static void app_event_process_cb(void* p_event_data, uint16_t event_size) {
+  app_event_t* p_event = (app_event_t*)p_event_data;
+  if (p_event->hang_up_flag) {
+    *p_event->hang_up_flag = 0;
+  }
+
   for (int i = 0; i < m_listener_num; i++) {
     if (m_listener[i].cbfunc) {
       m_listener[i].cbfunc(p_event_data, event_size);
@@ -33,18 +50,59 @@ static void app_event_process_cb(void* p_event_data, uint16_t event_size) {
   }
 }
 
+static void state_machine_driver_tmr_cb(void* p_context) {  //
+  wd_feed();
+  static app_event_t appevent;
+  static uint8_t     event_hang_up = 0;
+  appevent.eventType               = kevent_tmr_scheduler_event;
+  zapp_ebus_push_event_ext(&event_hang_up, &appevent);
+}
+
+static void delay_event_preset_tmr_cb(void* p_context) {  //
+  zevent_preset_tmr_t* tmr = (zevent_preset_tmr_t*)p_context;
+  tmr->usage               = false;
+  app_event_t* event       = &tmr->eventcache;
+  ZASSERT(zapp_ebus_push_event(event));
+}
+
 /***********************************************************************************************************************
  *                                                       EXTERN                                                        *
  ***********************************************************************************************************************/
 void zapp_early_init() { APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, 20); }
-void zapp_init() { ZERROR_CHECK(app_timer_create(&m_state_machine_driver_tmr, APP_TIMER_MODE_REPEATED, state_machine_driver_tmr_cb)); }
+void zapp_init() {
+  ZERROR_CHECK(app_timer_create(&m_state_machine_driver_tmr, APP_TIMER_MODE_REPEATED, state_machine_driver_tmr_cb));
+
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr0, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr1, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr2, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr3, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr4, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr5, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr6, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr7, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr8, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+  ZERROR_CHECK(app_timer_create(&m_delay_event_preset_tmr9, APP_TIMER_MODE_SINGLE_SHOT, delay_event_preset_tmr_cb));
+
+  m_delay_event_preset_tmr[0].tmrid = m_delay_event_preset_tmr0;
+  m_delay_event_preset_tmr[1].tmrid = m_delay_event_preset_tmr1;
+  m_delay_event_preset_tmr[2].tmrid = m_delay_event_preset_tmr2;
+  m_delay_event_preset_tmr[3].tmrid = m_delay_event_preset_tmr3;
+  m_delay_event_preset_tmr[4].tmrid = m_delay_event_preset_tmr4;
+  m_delay_event_preset_tmr[5].tmrid = m_delay_event_preset_tmr5;
+  m_delay_event_preset_tmr[6].tmrid = m_delay_event_preset_tmr6;
+  m_delay_event_preset_tmr[7].tmrid = m_delay_event_preset_tmr7;
+  m_delay_event_preset_tmr[8].tmrid = m_delay_event_preset_tmr8;
+  m_delay_event_preset_tmr[9].tmrid = m_delay_event_preset_tmr9;
+}
 void zapp_start_schedule() { ZERROR_CHECK(app_timer_start(m_state_machine_driver_tmr, APP_TIMER_TICKS(300), NULL)); }
 
 /***********************************************************************************************************************
  *                                                    state_machine                                                    *
  ***********************************************************************************************************************/
 void zapp_state_machine_reg_state_change_listener(on_state_change_t listener) { m_onstate_change = listener; }
-void zapp_state_machine_change_state(device_state_t tostate) {
+
+static void _zapp_state_machine_change_state(void* tostate_) {
+  device_state_t tostate = (device_state_t)tostate_;
   ZLOGI("change state from %s to %s", device_state_to_str(m_device_state), device_state_to_str(tostate));
   device_state_t nowstate = m_device_state;
 
@@ -54,13 +112,73 @@ void zapp_state_machine_change_state(device_state_t tostate) {
   }
   m_change_to_cur_state_tp = znordic_getpower_on_ms();
 }
+
+void zapp_state_machine_change_state(device_state_t tostate) {  //
+  uint32_t ret =  zapp_exec_in_main_context(NULL, _zapp_state_machine_change_state, (void*)tostate);
+  if(ret != 0){
+    ZLOGE("zapp_state_machine_change_state failed");
+    ZASSERT(0);
+  }
+}
 device_state_t zapp_state_machine_now_state() { return m_device_state; }
 uint32_t       zapp_state_machine_haspassed_ms() { return znordic_haspassed_ms(m_change_to_cur_state_tp); }
 
 /***********************************************************************************************************************
  *                                                        EBUS                                                         *
  ***********************************************************************************************************************/
-void zapp_ebus_push_event(app_event_t* event) { app_event_process_cb(event, sizeof(app_event_t)); }
+bool zapp_ebus_push_event(app_event_t* event) {
+  uint32_t suc = app_sched_event_put(event, sizeof(app_event_t), app_event_process_cb);  // app_event_process_cb(event, sizeof(app_event_t)
+  if (suc != 0) {
+    ZLOGE("app_sched_event_put failed");
+    return false;
+  }
+  return true;
+}
+
+bool zapp_ebus_push_event_ext(uint8_t* hang_up_flag, app_event_t* event) {
+  event->hang_up_flag = hang_up_flag;
+  if (event->hang_up_flag) {
+    if (*event->hang_up_flag) {
+      return true;
+    }
+
+    *event->hang_up_flag = 1;
+    if (zapp_ebus_push_event(event)) {
+      return true;
+    } else {
+      *event->hang_up_flag = 0;
+      return false;
+    }
+  } else {
+    return zapp_ebus_push_event(event);
+  }
+}
+
+bool zapp_ebus_push_delayed_event(int delay, app_event_t* event) {
+  zevent_preset_tmr_t* tmr = NULL;
+  CRITICAL_REGION_ENTER();
+  for (int i = 0; i < 10; i++) {
+    if (!m_delay_event_preset_tmr[i].usage) {
+      tmr        = &m_delay_event_preset_tmr[i];
+      tmr->usage = true;
+      break;
+    }
+  }
+  CRITICAL_REGION_EXIT();
+  if (tmr == NULL) {
+    return false;
+  }
+
+  tmr->eventcache = *event;
+
+  uint32_t suc = app_timer_start(tmr->tmrid, APP_TIMER_TICKS(delay), tmr);
+  if (suc != NRF_SUCCESS) {
+    tmr->usage = false;
+    return false;
+  }
+  return true;
+}
+
 void zapp_ebus_reg_event_listener(app_event_listener_t listener) {
   ZASSERT(m_listener_num < 10);
   m_listener[m_listener_num++].cbfunc = listener;
@@ -80,3 +198,45 @@ void zapp_gstate_set_preview_state(bool is_preview) {
   gstate_t* p_gstate   = zapp_get_gstate();
   p_gstate->is_preview = is_preview;
 }
+
+typedef struct {
+  uint8_t* hang_up_flag;
+  void (*handler)(void*);
+  void* usrdata;
+} zapp_exec_in_main_context_t;
+
+static void zapp_exec_once_event_handler(void* p_event_data, uint16_t event_size) {
+  zapp_exec_in_main_context_t* event = (zapp_exec_in_main_context_t*)p_event_data;
+  if (event->hang_up_flag) {
+    *event->hang_up_flag = 0;
+  }
+  event->handler(event->usrdata);
+}
+
+uint32_t zapp_exec_in_main_context(uint8_t* hang_up_flag, void (*handler)(void*), void* usrdata) {
+  zapp_exec_in_main_context_t event = {0};
+  event.hang_up_flag                = hang_up_flag;
+  event.handler                     = handler;
+  event.usrdata                     = usrdata;
+
+  /**
+   * @brief
+   *  1. 如果hang_up_flag为空，则无论事件队列中是否已经存在事件，都会推入事件队列
+   *  2. 如果hang_up_flag不为空，则只有当事件队列中没有该事件时，才会推入事件队列(应用于定时器周期调度事件)
+   */
+
+  if (hang_up_flag) {
+    if (*hang_up_flag != 0) {
+      return 0;
+    }
+
+    *hang_up_flag = 1;
+    uint32_t ret  = app_sched_event_put(&event, sizeof(zapp_exec_in_main_context_t), zapp_exec_once_event_handler);
+    if (ret != 0) {
+      *hang_up_flag = 0;
+    }
+    return ret;
+  } else {
+    return app_sched_event_put(&event, sizeof(zapp_exec_in_main_context_t), zapp_exec_once_event_handler);
+  }
+}

app/src/app_basic_service/zapp.h

@@ -26,9 +26,19 @@ uint32_t       zapp_state_machine_haspassed_ms();
 /***********************************************************************************************************************
  *                                                      event bus                                                      *
  ***********************************************************************************************************************/
-void zapp_ebus_push_event(app_event_t* event);
+bool zapp_ebus_push_event(app_event_t* event);
+bool zapp_ebus_push_event_ext(uint8_t* hang_up_flag, app_event_t* event);
+bool zapp_ebus_push_delayed_event(int delay,app_event_t* event);
+
 void zapp_ebus_reg_event_listener(app_event_listener_t listener);
 
+/**
+ * @brief 推入一次性事件，只有当本次事件处理完毕后才能推入下一个事件
+ *
+ * @param handler
+ */
+uint32_t zapp_exec_in_main_context(uint8_t* hang_up_flag, void (*handler)(void*), void* usrdata);
+
 /***********************************************************************************************************************
  *                                                       GSTATE                                                        *
  ***********************************************************************************************************************/

app/src/app_service/base_hardware/hardware_power_mgr.c

@@ -2,11 +2,12 @@
 
 #define POWER_CTRL_PIN 7
 
-void hardware_power_init() {  //
+void hardware_power_mgr_init() {  //
   znrf_gpio_cfg_output(POWER_CTRL_PIN, NRF_GPIO_PIN_NOPULL);
+  hardware_power_mgr_main_power_supply_set(false);
 }
 
-void hardware_power_deinit() {  //
+void hardware_power_mgr_deinit() {  //
   nrf_gpio_cfg_default(POWER_CTRL_PIN);
 }
 void hardware_power_mgr_main_power_supply_set(bool val) {

app/src/app_service/battery_mgr_service.c

@@ -3,9 +3,16 @@
 #include "app_basic_service/zapp.h"
 #include "base_hardware/adc_mgr.h"
 
+typedef enum {
+  kunload,
+  kstandy,
+  kpoweron,
+} state_t;
+
 APP_TIMER_DEF(battery_state_detect_tmr);        //
 static bool    m_battery_is_chargeing = false;  //
 static int16_t m_batter_level;
+state_t        m_state = kunload;
 
 static bool    battery_get_chargeing_state() { return !nrf_gpio_pin_read(BATTERY_CHARGE_DETECT_PIN); }
 static int16_t _battery_level_filter(int16_t nowlevel);
@@ -26,8 +33,9 @@ static void module_tmr_cb(void *context) {  //
     zapp_ebus_push_event(&event);
   }
   m_battery_is_chargeing = chargeing_state;
-
-  m_batter_level = _battery_mgr_service_get_battery_level();
+  if (m_state == kpoweron) {
+    m_batter_level = _battery_mgr_service_get_battery_level();
+  }
 }
 
 static int16_t _battery_level_filter(int16_t nowlevel) {
@@ -88,15 +96,26 @@ void battery_mgr_service_init() {
   /**
    * @brief 500ms启动定时器500ms检查一次当前是否正在充电
    */
-  nrf_gpio_cfg_sense_input(BATTERY_CHARGE_DETECT_PIN, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_NOSENSE);
+  nrf_gpio_cfg_input(BATTERY_CHARGE_DETECT_PIN, NRF_GPIO_PIN_PULLUP);
   app_timer_create(&battery_state_detect_tmr, APP_TIMER_MODE_REPEATED, module_tmr_cb);
-  app_timer_start(battery_state_detect_tmr, APP_TIMER_TICKS(500), NULL);
+  m_state = kstandy;
 }
 
-void battery_mgr_service_load() {}
+void battery_mgr_service_load() { app_timer_start(battery_state_detect_tmr, APP_TIMER_TICKS(500), NULL); }
+
+void battery_mgr_service_change_state_to_standy() { m_state = kstandy; }
+void battery_mgr_service_change_state_to_poweron() { m_state = kpoweron; }
 void battery_mgr_service_unload() {
-  // adc是公共资源，在最上层进行unload
+  /**
+   * @brief 电池管理永远不失能
+   */
+  ZASSERT(0);
+}
+int16_t battery_mgr_service_get_charging_state() { return battery_get_chargeing_state(); }
+int16_t battery_mgr_service_get_battery_level() {
+  if (m_state == kpoweron) {
+    return m_batter_level;
+  } else {
+    return _battery_mgr_service_get_battery_level();
+  }
 }
-
-int16_t battery_mgr_service_get_charging_state() { return !nrf_gpio_pin_read(BATTERY_CHARGE_DETECT_PIN); }
-int16_t battery_mgr_service_get_battery_level() { return m_batter_level; }

app/src/app_service/battery_mgr_service.h

@@ -6,11 +6,12 @@
 #include "aproject_config/config.h"
 #include "znordic.h"
 
-void    battery_mgr_service_init();
-
-void    battery_mgr_service_load();
-void    battery_mgr_service_unload();
+void battery_mgr_service_init();
 
+void battery_mgr_service_load();
+void battery_mgr_service_change_state_to_standy();
+void battery_mgr_service_change_state_to_poweron();
+void battery_mgr_service_unload();
 
 int16_t battery_mgr_service_get_battery_level();
 int16_t battery_mgr_service_get_charging_state();

app/src/app_service/beep_ctrl.c

@@ -99,6 +99,9 @@ void beep_unload() {
   beep_set(0);
   nrfx_pwm_uninit(&m_beep_pwm0);
   m_beep_loaded = false;
+
+  nrf_gpio_cfg_input(BEEP_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_default(BEEP_PIN);
 }
 
 void beep_set(uint8_t state) {

app/src/app_service/display_ctrl_service/display_mgr.c

@@ -4,6 +4,7 @@
 //
 #include <stdarg.h>
 
+#include "app_basic_service/zapp.h"
 #include "app_service/battery_mgr_service.h"
 #include "aproject_config/config.h"
 #include "font.h"
@@ -61,10 +62,9 @@ static void _page_reg(page_t page, void (*on_page_load)(), void (*on_page_schedu
 
   ZASSERT(m_pageNum < 20);
 }
-
-static void _page_schedule(page_t page) {
+static void _page_schedule() {
   for (int i = 0; i < m_pageNum; i++) {
-    if (m_page_processers[i].page == page) {
+    if (m_page_processers[i].page == m_page) {
       if (m_page_processers[i].on_page_scheduler) m_page_processers[i].on_page_scheduler();
       break;
     }
@@ -313,9 +313,12 @@ static void     page_charging_page_tmr_cb() {
  *                                                       EXTERN                                                        *
  ***********************************************************************************************************************/
 
+static void run_in_main_context(void* arg) { _page_schedule(); }
 static void dsp_mgr_schedule_tmr_cb(void* p_context) {  //
   if (!m_module_load) return;
-  _page_schedule(m_page);
+  // _page_schedule();
+  static uint8_t event_hang_up = 0;
+  zapp_exec_in_main_context(&event_hang_up, run_in_main_context, NULL);
 }
 
 void dsp_mgr_init(void) {
@@ -336,7 +339,9 @@ void dsp_mgr_load(void) {
   m_module_load = true;
 }
 void dsp_mgr_unload(void) {
+  
   m_module_load = false;
+  m_page = kpage_poweroff;
   app_timer_stop(m_dsp_mgr_schedule_tmr);
   ssd1306_if_unload();
 }

app/src/app_service/display_ctrl_service/ssd1306_if_impl.c

@@ -34,7 +34,9 @@ void ssd1306_if_load() {
   znrf_gpio_cfg_output(SCREEN_POWER_PIN, NRF_GPIO_PIN_NOPULL);
   znrf_gpio_cfg_output(SCREEN_A0PIN, NRF_GPIO_PIN_NOPULL);
 
-  nrf_gpio_pin_set(SCREEN_POWER_PIN);
+  nrf_gpio_pin_clear(SCREEN_RESET_PIN);
+  nrf_gpio_pin_clear(SCREEN_POWER_PIN);
+  nrf_gpio_pin_clear(SCREEN_A0PIN);
   // ²Î¿¼
   // OLEDÇý¶¯³ÌÐò     : https://iflytop1.feishu.cn/wiki/OQ4Iwv0DpiQDJvkjftjcQHJBnCg
   // nRF5_SDK-ʹÓÃÊÖ²á: https://iflytop1.feishu.cn/wiki/ThaAwZEGVi2bspkfGU9cbl9Enqd
@@ -50,12 +52,23 @@ void ssd1306_if_load() {
 }
 
 void ssd1306_if_unload() {
+  ssd1306_basic_deinit();
+
+  nrf_drv_spi_uninit(&m_screen_spi);
+
+  nrf_gpio_cfg_input(SCREEN_POWER_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(SCREEN_RESET_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(SCREEN_A0PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(SCREEN_CS_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(SCREEN_MOSI_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(SCREEN_CLK_PIN, NRF_GPIO_PIN_NOPULL);
+
+  nrf_gpio_cfg_default(SCREEN_CS_PIN);
+  nrf_gpio_cfg_default(SCREEN_MOSI_PIN);
+  nrf_gpio_cfg_default(SCREEN_CLK_PIN);
   nrf_gpio_cfg_default(SCREEN_RESET_PIN);
   nrf_gpio_cfg_default(SCREEN_POWER_PIN);
   nrf_gpio_cfg_default(SCREEN_A0PIN);
-
-  ssd1306_basic_deinit();
-  nrf_drv_spi_uninit(&m_screen_spi);
 }
 
 static uint8_t board_screen_spi_write_cmd(uint8_t *buf, uint16_t len) {  //

app/src/app_service/ecg_service/ecg_service.c

@@ -13,16 +13,16 @@
 static nrf_drv_spi_t        ads129x_spi = NRF_DRV_SPI_INSTANCE(ADS1291_SPI_INSTANCE);  // global
 static nrf_drv_spi_config_t ads129x_spi_config;
 
-uint8_t port_spi_transmit_receive(uint8_t tx);
-int32_t i24toi32(uint8_t* p_i32);
-uint8_t ads129x_send_cmd(uint8_t cmd);
-uint8_t ads129x_rw_reg(uint8_t cmd, uint8_t data);
-void    ads129x_write_multiregs(uint8_t reg, uint8_t* ch, uint8_t size);
-void    ads129x_read_multiregs(uint8_t reg, uint8_t* ch, uint8_t size);
-void    ads129x_readback_regs(ads129x_regs_t* regcache);
-void    ads129x_dump_regs(ads129x_regs_t* regcache);
-bool    ads129x_write_regs(ads129x_regs_t* writeval);
-void    ads129x_read_data(ads129x_capture_data_t* capture_data);
+// uint8_t port_spi_transmit_receive(uint8_t tx);
+// int32_t i24toi32(uint8_t* p_i32);
+// uint8_t ads129x_send_cmd(uint8_t cmd);
+// uint8_t ads129x_rw_reg(uint8_t cmd, uint8_t data);
+// void    ads129x_write_multiregs(uint8_t reg, uint8_t* ch, uint8_t size);
+// void    ads129x_read_multiregs(uint8_t reg, uint8_t* ch, uint8_t size);
+// void    ads129x_readback_regs(ads129x_regs_t* regcache);
+// void    ads129x_dump_regs(ads129x_regs_t* regcache);
+// bool    ads129x_write_regs(ads129x_regs_t* writeval);
+// void    ads129x_read_data(ads129x_capture_data_t* capture_data);
 
 /***********************************************************************************************************************
  *                                                    PRIVATE_FUNC                                                     *
@@ -293,7 +293,18 @@ void ecg_service_unload() {
 
   nrfx_gpiote_in_event_disable(ADS1291_READY_PIN);
 
+  nrf_gpio_cfg_input(ADS1291_SPI_CS0_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(ADS1291_SPI_SCK_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(ADS1291_SPI_MOSI_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(ADS1291_SPI_MISO_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(ADS1291_PWDN_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(ADS1291_START_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(ADS1291_READY_PIN, NRF_GPIO_PIN_NOPULL);
+
   nrf_gpio_cfg_default(ADS1291_SPI_CS0_PIN);
+  nrf_gpio_cfg_default(ADS1291_SPI_SCK_PIN);
+  nrf_gpio_cfg_default(ADS1291_SPI_MOSI_PIN);
+  nrf_gpio_cfg_default(ADS1291_SPI_MISO_PIN);
   nrf_gpio_cfg_default(ADS1291_PWDN_PIN);
   nrf_gpio_cfg_default(ADS1291_START_PIN);
   nrf_gpio_cfg_default(ADS1291_READY_PIN);

app/src/app_service/light_ctrl.c

@@ -53,9 +53,15 @@ void light_ctrl_load() {
   znrf_gpio_cfg_output(LED_RED_PIN, NRF_GPIO_PIN_NOPULL);
 }
 void light_ctrl_unload() {
+
+  nrf_gpio_cfg_input(LED_GREEN_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(LED_BLUE_PIN, NRF_GPIO_PIN_NOPULL);
+  nrf_gpio_cfg_input(LED_RED_PIN, NRF_GPIO_PIN_NOPULL);
+
   nrf_gpio_cfg_default(LED_GREEN_PIN);
   nrf_gpio_cfg_default(LED_BLUE_PIN);
   nrf_gpio_cfg_default(LED_RED_PIN);
+
 }
 
 void light_ctrl_set_green_light_state(bool state) {

app/src/main.c

@@ -81,6 +81,5 @@ int main() {
   /*******************************************************************************
    *                                    LOOP                                     *
    *******************************************************************************/
-  zapp_start_schedule();
   znordic_loop();
 }

app/src/one_conduction_main.c

@@ -1,14 +1,20 @@
 #include <math.h>
 #include <stdint.h>
 
+#include "aproject_config/config.h"
+#include "ify_hrs_protocol/heart_rate_sensor_protocol.h"
+#include "zdatachannel_service.h"
+//
 #include "app_basic_service/device_version_info_mgr.h"
 #include "app_basic_service/zapp.h"
+#include "app_service/base_hardware/adc_mgr.h"
 #include "app_service/base_hardware/hardware_power_mgr.h"
 #include "app_service/battery_mgr_service.h"
+#include "app_service/beep_ctrl.h"
+#include "app_service/display_ctrl_service/display_mgr.h"
 #include "app_service/ecg_service/ecg_service.h"
-#include "aproject_config/config.h"
-#include "ify_hrs_protocol/heart_rate_sensor_protocol.h"
-#include "zdatachannel_service.h"
+#include "app_service/light_ctrl.h"
+
 /***********************************************************************************************************************
  *                                                       GLOBAL                                                        *
  ***********************************************************************************************************************/
@@ -137,7 +143,7 @@ void one_conduction_process_rx_packet(uint8_t* rx, int len) {
 
     receipt->drop_state0                  = (0);
     receipt->drop_state1                  = 0x00;
-    receipt->device_state0.sampling_state = (zapp_state_machine_now_state() == kdevice_state_sampling);
+    receipt->device_state0.sampling_state = (zapp_state_machine_now_state() == kstate_capture);
     receipt->device_state0.report_state   = 0;
     receipt->device_state0.low_battery    = (0 < APP_LOW_BATTERY_WARNING_LIMIT);
     receipt->device_state0.full_storge    = false;
@@ -152,42 +158,75 @@ void one_conduction_process_rx_packet(uint8_t* rx, int len) {
   /***********************************************************************************************************************
    *                                                      ²âÊÔÖ¸Áî                                                       *
    ***********************************************************************************************************************/
-  // void hwss_start_capture(void);
-  // void hwss_start_prepare_capture(void);
-  // void hwss_stop_capture(void);
-
-  // void    hwss_subic_write_reg(uint8_t addr, uint8_t val);
-  // uint8_t hwss_subic_read_reg(uint8_t addr);
-
-  // else if (cmd == ify_hrs_test_cmd_start_capture) {
-  //   hwss_start_prepare_capture();
-  //   hwss_start_capture();
-  //   send_success_receipt(rxheader, 0);
-  // } else if (cmd == ify_hrs_test_cmd_stop_capture) {
-  //   hwss_stop_capture();
-  //   send_success_receipt(rxheader, 0);
-  // } else if (cmd == ify_hrs_test_cmd_read_reg) {
-  //   uint8_t regadd    = rxheader->data[0];
-  //   uint8_t regval    = hwss_subic_read_reg(regadd);
-  //   txheader->data[0] = regval;
-  //   send_success_receipt(rxheader, 1);
-  // } else if (cmd == ify_hrs_test_cmd_write_reg) {
-  //   uint8_t regadd = rxheader->data[0];
-  //   uint8_t regval = rxheader->data[1];
-  //   hwss_subic_write_reg(regadd, regval);
-  //   send_success_receipt(rxheader, 0);
-  // }
-  //
   else {
     send_error_receipt(rxheader, kifyhrs_ecode_cmd_not_support);
   }
 }
 
+void on_state_change(device_state_t from, device_state_t to) {
+  /**
+   * @brief ¿ª»ú
+   */
+
+  if (from == kstate_standby && to != kstate_standby) {
+    ZLOGI("power on");
+    hardware_power_mgr_main_power_supply_set(true);
+    battery_mgr_service_change_state_to_poweron();
+    beep_load();
+    light_ctrl_load();
+    dsp_mgr_load();
+    // dsp_mgr_change_page(kpage_welcome);
+    ecg_service_load();
+
+  }
+  /**
+   * @brief ¹Ø»ú
+   */
+  else if (from != kstate_standby && to == kstate_standby) {
+    ZLOGI("power off");
+
+    battery_mgr_service_change_state_to_standy();
+
+    beep_unload();
+    light_ctrl_unload();
+    dsp_mgr_unload();
+    ecg_service_unload();
+
+    // battery_mgr_service_change_state_to_standy();
+    hardware_power_mgr_main_power_supply_set(false);
+  }
+
+  if (to == kstate_welcomPage) {
+    // dsp_mgr_change_page(kpage_welcome);
+    zapp_state_machine_change_state(kstate_standby);
+  }
+}
+void on_zapp_ebus_event(void* p_event_data, uint16_t event_size) {
+
+  
+
+
+}
+
 void one_conduction_main() {
   sn_t sn;
   device_info_read_sn(&sn);
-  ZLOGI("one_conduction_main %s",sn.sn);
+  ZLOGI("one_conduction_main %s", sn.sn);
   ZLOG_FLUSH();
+  zapp_ebus_reg_event_listener(on_zapp_ebus_event);
+  zapp_state_machine_reg_state_change_listener(on_state_change);
+
+  adc_mgr_init();
+  hardware_power_mgr_init();
+
+  battery_mgr_service_init();
+  light_ctrl_init();
+  beep_init();
+  dsp_mgr_init();
+  ecg_service_init();
+
+  zapp_state_machine_change_state(kstate_welcomPage);
 
   zble_module_start_adv();
+  zapp_start_schedule();
 }

libznordic

@@ -1 +1 @@
-Subproject commit 34b66f400e35757e7fc42e0004e88c8d1c090d88
+Subproject commit 1d9ac0bb2d87ce60cbe742d2ddffa0b91c68acdd