update

README.md

@@ -1,13 +1,36 @@
 ```
-```
-
-```
-
-
 
 
 
+```
 
+```
+/**
+ * @brief
+ *
+ *
+ *  回流按键:短按一下， 回流
+ *          快按两下， 填充管路
+ *
+ *
+ *  加液按键短按，加液体
+ *  加液按键长按，切换模式，点动模式，连续自动模式
+ *
+ *    模式1 点动
+ *    模式2 连续自动
+ *
+ *
+ *  灯:
+ *    颜色,区分不同模式。
+ *    闪烁,状态。
+ *
+ *    连接，无连接
+ *    唤醒，非唤醒
+ *    模式，
+ *    状态，
+ * 
+ *
+ */
 
 
 ```

app_protocols/app_protocols.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "bean/hand_acid_mode.h"
+#include "bean/hand_acid_remoter_key_event.h"
 #include "appecode/errorcode.h"
 //
 #include "zscanprotocol/zscanprotocol.h"

app_protocols/bean/hand_acid_remoter_key_event.h

@@ -2,4 +2,6 @@
 typedef enum {
   hand_acid_remoter_kevent_add_liquid       = 0,  //
   hand_acid_remoter_kevent_change_next_mode = 1,  //
-} hand_acid_remoter_key_event_t;
+  hand_acid_remoter_kevent_reflux           = 2,  //
+  hand_acid_remoter_kevent_preFilling       = 3,  //
+} hand_acid_remoter_key_event_t;

app_protocols/ble_through/ble_proto.h

@@ -45,7 +45,7 @@ typedef enum {
   kzble_cmd_read_version     = 101,  // param:{}                receipt:ble_master_read_version_t
   kzble_cmd_start_scan       = 102,  // param:zble_start_scan_t receipt:{}
   kzble_cmd_stop_scan        = 103,  // param:{}                receipt:{}
-  kzble_cmd_enter_dfu_scan   = 104,  // param:{}                receipt:{}
+  kzble_cmd_set_in_dfu_mode  = 104,  // param:{}                receipt:{}
   kzble_cmd_clear_reset_flag = 105,  //
 
   kzble_report_connected_event = 150,  // zble_connected_event_t

app_protocols/ble_through/ble_proto_utils.c

@@ -1,4 +1,5 @@
 #include "ble_proto_utils.h"
+
 #include <stdio.h>
 #include <string.h>
 
@@ -44,6 +45,8 @@ void zble_proto_utils_create_cmd_packet(zble_proto_packet_t *packet, uint16_t cm
   packet->frameType  = kzble_proto_cmd;
   packet->frameIndex = index;
   packet->cmd        = cmd;
+  packet->from       = kzble_upper;
+  packet->to         = kzble_slave;
   memcpy((void *)packet->data, data, datalen);
   BLE_THROUGH_PACKET_SET_CHECKSUM(packet);
   BLE_THROUGH_PACKET_SET_TAIL(packet);

uappbase/base.hpp

@@ -7,4 +7,6 @@
 #include "service/app_event_bus.hpp"
 #include "service/gstate_mgr.hpp"
 #include "service/config_service.hpp"
+#include "service/config_service_utils.hpp"
+//
 #include "apphal/apphal.hpp"

uappbase/bean/event.hpp

@@ -5,13 +5,19 @@
 namespace iflytop {
 using namespace std;
 typedef enum {
-  kPumpStart,
-  kPumpStop,
-
-  kAppEvent_RemoterControlerConnected,
-  kAppEvent_RemoterControlerDisConnected,
+  kAppEvent_BleConnectedStateChangeEvent,
+  kAppEvent_RunModeChangeEvent,
+  kAppEvent_PumpWorkStateChangeEvent,
 } AppEventType_t;
 
+/**
+ *
+ * @brief
+ *
+ *
+ * @注意
+ *   下面这个结构不易定义过大，否则容易造成栈溢出
+ */
 typedef struct {
   AppEventType_t type;
   union event {
@@ -20,5 +26,10 @@ typedef struct {
 
 } AppEvent_t;
 
+static inline AppEvent_t createAppEvent(AppEventType_t type) {
+  AppEvent_t event;
+  event.type = type;
+  return event;
+}
 
 }  // namespace iflytop

uappbase/service/app_event_bus.cpp

@@ -25,7 +25,7 @@ void AppEventBus::regOnEvent(onAppEventCB_t onEvent) {
   m_cbs[cbNum] = onEvent;
   cbNum++;
 }
-void AppEventBus::pushEvent(AppEvent_t& event) {
+void AppEventBus::pushEvent(const AppEvent_t& event) {
   xQueueSend(xQueue, &event, 0);
 
   if (xQueueSend(xQueue, &event, 100) != pdPASS) {

uappbase/service/app_event_bus.hpp

@@ -23,7 +23,7 @@ class AppEventBus {
   void initialize();
 
   void regOnEvent(onAppEventCB_t onEvent);
-  void pushEvent(AppEvent_t& event);
+  void pushEvent(const AppEvent_t& event);
 };
 
 }  // namespace iflytop

uappbase/service/config_service_utils.cpp

@@ -0,0 +1,37 @@
+#include "config_service_utils.hpp"
+namespace iflytop {
+int32_t getMotorULToTruns(int32_t motorid) {
+  switch (motorid) {
+    case 0:
+      return getCfgInt(kcfg_1ulTrunsM0);
+    case 1:
+      return getCfgInt(kcfg_1ulTrunsM1);
+    case 2:
+      return getCfgInt(kcfg_1ulTrunsM2);
+    case 3:
+      return getCfgInt(kcfg_1ulTrunsM3);
+    default:
+      ZASSERT(0);
+      return 0;
+  }
+}
+void setMotorULToTruns(int motorid, int32_t val) {
+  //
+  switch (motorid) {
+    case 0:
+      CS->setcfg(kcfg_1ulTrunsM0, val);
+      break;
+    case 1:
+      CS->setcfg(kcfg_1ulTrunsM1, val);
+      break;
+    case 2:
+      CS->setcfg(kcfg_1ulTrunsM2, val);
+      break;
+    case 3:
+      CS->setcfg(kcfg_1ulTrunsM3, val);
+      break;
+    default:
+      ZASSERT(0);
+  }
+}
+}

uappbase/service/config_service_utils.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include "config_service.hpp"
+namespace iflytop {
+int32_t getMotorULToTruns(int32_t motorid);
+void    setMotorULToTruns(int32_t motorid, int32_t val);
+
+}  // namespace iflytop

uappbase/service/gstate_mgr.cpp

@@ -0,0 +1,40 @@
+#include "gstate_mgr.hpp"
+
+#include "app_event_bus.hpp"
+
+using namespace std;
+using namespace iflytop;
+#define GSM GStateMgr::ins()
+
+void GStateMgr::setLogin(bool isAdmin, const char* loginUsr) {
+  m_isLogin = true;
+  m_isAdmin = isAdmin;
+  if (loginUsr) {
+    strncpy(this->m_loginUsr, loginUsr, MAX_USR_NAME_SIZE);
+  }
+}
+void GStateMgr::setUnLogin() {
+  m_isLogin = false;
+  m_isAdmin = false;
+  memset(m_loginUsr, 0, MAX_USR_NAME_SIZE + 1);
+}
+
+bool        GStateMgr::isLogin() { return m_isLogin; }
+bool        GStateMgr::isAdmin() { return m_isAdmin; }
+const char* GStateMgr::getLoginUsr() { return m_loginUsr; }
+
+void GStateMgr::setAcidState(int32_t state) { m_AcidState = state; }
+void GStateMgr::setRemoterS(int32_t state) { m_RemoterS = state; }
+void GStateMgr::setRunMode(hand_acid_mode_t mode) {
+  if (m_RunMode != mode) {
+    m_RunMode = mode;
+    AppEventBus::ins()->pushEvent(createAppEvent(kAppEvent_RunModeChangeEvent));
+  }
+}
+
+int32_t          GStateMgr::getAcidState() { return m_AcidState; }
+int32_t          GStateMgr::getRemoterS() { return m_RemoterS; }
+hand_acid_mode_t GStateMgr::getRunMode() { return m_RunMode; }
+
+void GStateMgr::setPumpSelectState(int32_t index, bool state) { pumpSelectState[index] = state; }
+bool GStateMgr::getPumpSelectState(int32_t index) { return pumpSelectState[index]; }

uappbase/service/gstate_mgr.hpp

@@ -28,33 +28,23 @@ class GStateMgr {
     return &instance;
   }
 
-  void setLogin(bool isAdmin, const char* loginUsr) {
-    m_isLogin = true;
-    m_isAdmin = isAdmin;
-    if (loginUsr) {
-      strncpy(this->m_loginUsr, loginUsr, MAX_USR_NAME_SIZE);
-    }
-  }
-  void setUnLogin() {
-    m_isLogin = false;
-    m_isAdmin = false;
-    memset(m_loginUsr, 0, MAX_USR_NAME_SIZE + 1);
-  }
+  void setLogin(bool isAdmin, const char* loginUsr);
+  void setUnLogin();
 
-  bool        isLogin() { return m_isLogin; }
-  bool        isAdmin() { return m_isAdmin; }
-  const char* getLoginUsr() { return m_loginUsr; }
+  bool        isLogin();
+  bool        isAdmin();
+  const char* getLoginUsr();
 
-  void setAcidState(int32_t state) { m_AcidState = state; }
-  void setRemoterS(int32_t state) { m_RemoterS = state; }
-  void setRunMode(hand_acid_mode_t mode) { m_RunMode = mode; }
+  void setAcidState(int32_t state);
+  void setRemoterS(int32_t state);
+  void setRunMode(hand_acid_mode_t mode);
 
-  int32_t          getAcidState() { return m_AcidState; }
-  int32_t          getRemoterS() { return m_RemoterS; }
-  hand_acid_mode_t getRunMode() { return m_RunMode; }
+  int32_t          getAcidState();
+  int32_t          getRemoterS();
+  hand_acid_mode_t getRunMode();
 
-  void setPumpSelectState(int32_t index, bool state) { pumpSelectState[index] = state; }
-  bool getPumpSelectState(int32_t index) { return pumpSelectState[index]; }
+  void setPumpSelectState(int32_t index, bool state);
+  bool getPumpSelectState(int32_t index);
 };
 
 }  // namespace iflytop

usrc/service/app_core.cpp

@@ -6,7 +6,7 @@
 #include "service/front_end_controler.hpp"
 #include "service/pump_ctrl_service.hpp"
 #include "service/remote_controler.hpp"
-#include "service/remote_controler_event_processer.hpp"
+#include "service/remote_controler_state_sync_service.hpp"
 //
 #include "service/page/page.hpp"
 
@@ -46,6 +46,38 @@ void AppCore::debugLightLoop() {
     }
   }
 }
+void AppCore::processKeyEventFromRemoter(hand_acid_remoter_key_event_t keyEvent) {
+  /**
+   * @brief 如果当前设备处于工作中，则无论什么按键都是停止工作
+   */
+  if (PUMPCS->isWorking()) {
+    PUMPCS->stop();
+    RCTRL->setRemoterState(GSM->getRunMode(), PUMPCS->isWorking());
+  } else {
+    if (keyEvent == hand_acid_remoter_kevent_add_liquid) {
+      //
+      if (GSM->getRunMode() == khand_acid_m_jog_mode) {
+        PUMPCS->moveOnce();
+      } else if (GSM->getRunMode() == khand_acid_m_continuous_mode) {
+        PUMPCS->autoMoveMutiTimes();
+      }
+    } else if (keyEvent == hand_acid_remoter_kevent_change_next_mode) {
+      // 修改工作模式
+      if (GSM->getRunMode() == khand_acid_m_jog_mode) {
+        GSM->setRunMode(khand_acid_m_continuous_mode);
+      } else if (GSM->getRunMode() == khand_acid_m_continuous_mode) {
+        GSM->setRunMode(khand_acid_m_jog_mode);
+      }
+    } else if (keyEvent == hand_acid_remoter_kevent_reflux) {
+      // 回流
+      PUMPCS->reflux();
+    } else if (keyEvent == hand_acid_remoter_kevent_preFilling) {
+      // 管路填充
+      PUMPCS->acidPrefilling();
+    }
+  }
+}
+
 void AppCore::appsetup() {
   /***********************************************************************************************************************
    *                                                        INIT                                                         *
@@ -58,18 +90,23 @@ void AppCore::appsetup() {
   FrontEndControler::ins()->initialize();     // 前端控制器，对屏幕的消息进行解析，发送消息给屏幕
 
   // BaseServiceInit
-  //
+  PUMPCS->initialize();
+  RemoteControlerStateSyncService::ins()->initialize();
 
   Page_login::ins()->initialize();  //
   Page_main::ins()->initialize();   //
   Page_keybAcidCh::ins()->initialize();
   Page_muAcidType::ins()->initialize();
-
+  
   /***********************************************************************************************************************
    *                                                  REG_EVENT_HANDLER                                                  *
    ***********************************************************************************************************************/
-  RemoteControlerUpper::ins()->regOnReport([](uint8_t* rx, int32_t len) {  //
-    ZLOGI(TAG, "[RCTRL] on event:%s", zhex2str(rx, len));
+  RCTRL->regOnReport([this](uint8_t* rx, int32_t len) {  //
+    zble_proto_packet_t* packet = (zble_proto_packet_t*)rx;
+    if (packet->cmd == kzble_app_report_key_event) {
+      int32_t keyEvent = *(int32_t*)packet->data;
+      processKeyEventFromRemoter((hand_acid_remoter_key_event_t)keyEvent);
+    }
   });
 
   /***********************************************************************************************************************
@@ -77,6 +114,7 @@ void AppCore::appsetup() {
    ***********************************************************************************************************************/
   FrontEndControler::ins()->startSchedule();
   RCTRL->startSchedule();
+  RemoteControlerStateSyncService::ins()->startSync();
 
   // dim
   UIS->chpage(pg_login);

usrc/service/app_core.hpp

@@ -9,6 +9,8 @@ class AppCore {
   /* data */
   AppCore(/* args */) {}
 
+
+
  public:
   static AppCore* ins() {
     static AppCore ins;
@@ -17,6 +19,9 @@ class AppCore {
   void initialize();
   void appsetup();
   void debugLightLoop();
+
+ public:
+  void processKeyEventFromRemoter(hand_acid_remoter_key_event_t keyEvent);
 };
 
 }  // namespace iflytop

usrc/service/pump_ctrl_service.cpp

@@ -1,5 +1,7 @@
 #include "pump_ctrl_service.hpp"
 
+#include "remote_controler.hpp"
+
 using namespace iflytop;
 #define TAG "PumpCtrlService"
 
@@ -7,13 +9,17 @@ static TMC51X0* m_motors[4];
 #define PUMP_NUM 4
 
 static CfgItermCache cfgcache;
-
-void PumpCtrlService::initialize() {
+void                 PumpCtrlService::initialize() {
   m_motors[0] = AppHardware::ins()->getPump(0);
   m_motors[1] = AppHardware::ins()->getPump(1);
   m_motors[2] = AppHardware::ins()->getPump(2);
   m_motors[3] = AppHardware::ins()->getPump(3);
 
+  m_thread.init("PumpCtrlService", 1024);
+  updateMotorSetting();
+}
+
+void PumpCtrlService::updateMotorSetting() {
   for (size_t i = 0; i < PUMP_NUM; i++) {
     m_motors[i]->enable(false);
 
@@ -28,27 +34,9 @@ void PumpCtrlService::initialize() {
     m_motors[i]->setDmax(MOTOR_AMAX);
     m_motors[i]->setV1(MOTOR_V1);
     m_motors[i]->setTzerowait(MOTOR_TZEROWAIT);
-
-    switch (i) {
-      case 0:
-        m_motors[i]->setScale(getCfgInt(kcfg_1ulTrunsM0));
-        break;
-      case 1:
-        m_motors[i]->setScale(getCfgInt(kcfg_1ulTrunsM1));
-        break;
-      case 2:
-        m_motors[i]->setScale(getCfgInt(kcfg_1ulTrunsM2));
-        break;
-      case 3:
-        m_motors[i]->setScale(getCfgInt(kcfg_1ulTrunsM3));
-        break;
-      default:
-        break;
-    }
+    m_motors[i]->setScale(getMotorULToTruns(i));
     m_motors[i]->enable(true);
   }
-
-  m_thread.init("PumpCtrlService", 1024);
 }
 
 void PumpCtrlService::stop() {
@@ -136,6 +124,8 @@ void PumpCtrlService::moveOnce() {
   m_thread.start([this]() { doMoveOnce(); });
 }
 
+bool PumpCtrlService::isWorking() { return m_thread.isworking(); }
+
 /***********************************************************************************************************************
  *                                                        BASIC                                                        *
  ***********************************************************************************************************************/
@@ -165,7 +155,7 @@ void PumpCtrlService::doMoveOnce() {
 
 bool PumpCtrlService::isAllReachTarget() {
   for (size_t i = 0; i < PUMP_NUM; i++) {
-     TMC5130RampStat state =  m_motors[i]->getRampStat();
+    TMC5130RampStat state = m_motors[i]->getRampStat();
     if (!m_motors[i]->isReachTarget(&state)) {
       return false;
     }

usrc/service/pump_ctrl_service.hpp

@@ -3,13 +3,11 @@
 #include "uappbase/base.hpp"
 namespace iflytop {
 using namespace std;
-#define PCS PumpCtrlService::ins()
+#define PUMPCS PumpCtrlService::ins()
 
 /**
  * @brief
- *
  */
-
 class PumpCtrlService {
   ZThread m_thread;
 
@@ -23,18 +21,16 @@ class PumpCtrlService {
   }
 
   void initialize();
+  void updateMotorSetting();
 
  public:
   bool isWorking();
-  bool pumpIsWorking();
 
  public:
   void moveOnce();
   void autoMoveMutiTimes();
-
   void reflux();
   void acidPrefilling();
-
   void stop();
 
  private:

usrc/service/remote_controler.cpp

@@ -158,6 +158,75 @@ bool RemoteControlerUpper::txcmd(uint8_t* data, uint32_t len) {
  *                                                         CMD                                                         *
  ***********************************************************************************************************************/
 
+bool RemoteControlerUpper::resetMasterBoard() {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_reset, m_index++, NULL, 0);
+  txpacket->to = kzble_master;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  return suc;
+}
+bool RemoteControlerUpper::resetClientBoard() {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_reset, m_index++, NULL, 0);
+  txpacket->to = kzble_slave;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  return suc;
+}
+
+bool RemoteControlerUpper::readMasterBoardVersion(zble_read_version_t* version) {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_read_version, m_index++, NULL, 0);
+  txpacket->to = kzble_master;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  if (suc) *version = *(zble_read_version_t*)(rxpacket->data);
+  return suc;
+}
+bool RemoteControlerUpper::readClientBoardVersion(zble_read_version_t* version) {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_read_version, m_index++, NULL, 0);
+  txpacket->to = kzble_slave;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  if (suc) *version = *(zble_read_version_t*)(rxpacket->data);
+  return suc;
+}
+
+bool RemoteControlerUpper::clearMasterResetFlag() {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_clear_reset_flag, m_index++, NULL, 0);
+  txpacket->to = kzble_master;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  return suc;
+}
+bool RemoteControlerUpper::clearSlaveResetFlag() {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_clear_reset_flag, m_index++, NULL, 0);
+  txpacket->to = kzble_slave;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  return suc;
+}
+
+bool RemoteControlerUpper::setMasterInDfuMode() {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_set_in_dfu_mode, m_index++, NULL, 0);
+  txpacket->to = kzble_master;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  return suc;
+}
+bool RemoteControlerUpper::setSlaveInDfuMode() {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_set_in_dfu_mode, m_index++, NULL, 0);
+  txpacket->to = kzble_slave;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  return suc;
+}
+
+bool RemoteControlerUpper::startScan() {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_start_scan, m_index++, NULL, 0);
+  txpacket->to = kzble_master;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  return suc;
+}
+bool RemoteControlerUpper::stopScan() {
+  zble_proto_utils_create_cmd_packet(txpacket, kzble_cmd_stop_scan, m_index++, NULL, 0);
+  txpacket->to = kzble_master;
+  bool suc     = txcmd(txbuf, txpacket->packetlen);
+  return suc;
+}
+/***********************************************************************************************************************
+ *                                                         APP                                                         *
+ ***********************************************************************************************************************/
 bool RemoteControlerUpper::setRemoterState(hand_acid_mode_t mode, bool state) {
   zble_proto_packet_t* packet   = (zble_proto_packet_t*)txbuf;
   int32_t              param[2] = {mode, state};
@@ -165,5 +234,3 @@ bool RemoteControlerUpper::setRemoterState(hand_acid_mode_t mode, bool state) {
   bool suc = txcmd(txbuf, packet->packetlen);
   return suc;
 }
-
-

usrc/service/remote_controler.hpp

@@ -18,9 +18,11 @@ class RemoteControlerUpper {
 
   zmutex m_cmdlock;
 
+  uint8_t                       txbuf[255];
   RemoteControlerReportPacket_t ackcache;
+  zble_proto_packet_t*          txpacket = (zble_proto_packet_t*)txbuf;
+  zble_proto_packet_t*          rxpacket = (zble_proto_packet_t*)ackcache.data;
 
-  uint8_t txbuf[255];
   uint8_t m_index = 0;
 
  public:

usrc/service/remote_controler_event_processer.cpp

@@ -1,30 +0,0 @@
-#include "remote_controler_event_processer.hpp"
-#include "remote_controler.hpp"
-using namespace iflytop;
-void RemoterControlerEventProcesser::initialize() {
-  //
-  RemoteControlerUpper::ins()->regOnReport([this](uint8_t* rx, int32_t len) {  //
-    onPacket((zble_proto_packet_t*)rx);
-  });
-}
-
-void RemoterControlerEventProcesser::onPacket(zble_proto_packet_t* packet) {
-  // kproto_report_key_event
-  // kproto_report_connected_event
-
-  // if (packet->cmd == kproto_report_connected_event) {
-  //   static AppEvent_t event;
-  //   if (packet->data.connected_event.connected) {
-  //     /**
-  //      * @brief ͬ²½×´Ì¬µ½±Ê¶Ë
-  //      */
-
-  //     event.type = kAppEvent_RemoterControlerConnected;
-  //     AppEventBus::ins()->pushEvent(event);
-
-  //   } else {
-  //     event.type = kAppEvent_RemoterControlerDisConnected;
-  //     AppEventBus::ins()->pushEvent(event);
-  //   }
-  // }
-}

usrc/service/remote_controler_event_processer.hpp

@@ -1,20 +0,0 @@
-#pragma once
-#include "apphardware/apphardware.hpp"
-#include "uappbase/base.hpp"
-namespace iflytop {
-using namespace std;
-
-class RemoterControlerEventProcesser {
- public:
-  static RemoterControlerEventProcesser* ins() {
-    static RemoterControlerEventProcesser instance;
-    return &instance;
-  }
-
-  void initialize();
-
- private:
-  void onPacket(zble_proto_packet_t* packet);
-};
-
-}  // namespace iflytop

usrc/service/remote_controler_state_sync_service.cpp

@@ -0,0 +1,49 @@
+#include "remote_controler_state_sync_service.hpp"
+
+#include "pump_ctrl_service.hpp"
+#include "remote_controler.hpp"
+
+using namespace iflytop;
+
+void RemoteControlerStateSyncService::initialize() {
+  AppEventBus::ins()->regOnEvent([this](AppEvent_t* event) {
+    if (event->type == kAppEvent_BleConnectedStateChangeEvent) {
+      zlock_guard lck(m_forceUpdateflagLock);
+      m_forceUpdateflag = true;
+    }
+  });
+
+  bleStateUpdateThread.init("bleStateUpdateThread");
+}
+
+void RemoteControlerStateSyncService::startSync() {
+  bleStateUpdateThread.start([this]() {
+    //
+    hand_acid_mode_t runmode     = khand_acid_m_unset_mode;
+    bool             workState   = false;
+    bool             forceupdate = false;
+
+    while (true) {
+      if (!RCTRL->isConnected()) {
+        osDelay(100);
+        continue;
+      }
+
+      {
+        zlock_guard lck(m_forceUpdateflagLock);
+        forceupdate       = m_forceUpdateflag;
+        m_forceUpdateflag = false;
+      }
+
+      if (runmode != GSM->getRunMode() || workState != PUMPCS->isWorking()) {
+        runmode   = GSM->getRunMode();
+        workState = PUMPCS->isWorking();
+        RCTRL->setRemoterState(runmode, workState);
+      } else if (forceupdate) {
+        RCTRL->setRemoterState(runmode, workState);
+      }
+
+      osDelay(500);
+    }
+  });
+}

usrc/service/remote_controler_state_sync_service.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "apphardware/apphardware.hpp"
+#include "uappbase/base.hpp"
+namespace iflytop {
+using namespace std;
+class RemoteControlerStateSyncService {
+ private:
+  /* data */
+  ZThread bleStateUpdateThread;
+  bool    m_forceUpdateflag = false;
+  zmutex  m_forceUpdateflagLock;
+
+ public:
+  static RemoteControlerStateSyncService* ins() {
+    static RemoteControlerStateSyncService instance;
+    return &instance;
+  }
+
+  void initialize();
+  void startSync();
+
+ public:
+};
+}  // namespace iflytop