update

.clang-format

@@ -2,7 +2,7 @@
 # http://clang.llvm.org/docs/ClangFormatStyleOptions.html
 Language: Cpp
 BasedOnStyle: Google
-ColumnLimit: 160
+ColumnLimit: 220
 AlignConsecutiveMacros: true
 AlignConsecutiveDeclarations: true
 AlignConsecutiveAssignments:  true

README.md

@@ -8,8 +8,12 @@
 # 测试指令
 
 ```
+./app.out 正常启动
+./app.out --test_mode //测试模式启动
 
 
+开始消毒
+{"command":"startDisinfection","loglevel":12,"messageId":"startDisinfection","roomVolume":0}
 ```
 
 

iflytoplinuxsdk

@@ -1 +1 @@
-Subproject commit 0035acd2d227a103291b128fdcda9cf3f9531662
+Subproject commit d3f953abc7412dacab027d4af3bef0958724e879

src/configs/project_setting.hpp

@@ -15,9 +15,11 @@
 #ifdef PROJECT_TYPE_SMALL_SPACE_DISINFECTION
 #define DISINFECTANT_BUCKET_CAPACITY 2300
 #define PROJECT_NAME                 "small_space_disinfection"
+#define MAX_H2O2_SENSOR_NUM          (3)
 #endif
 
 #ifdef PROJECT_TYPE_LARGE_SPACE_DISINFECTION
 #define DISINFECTANT_BUCKET_CAPACITY 2300
 #define PROJECT_NAME                 "large_space_disinfection"
+#define MAX_H2O2_SENSOR_NUM          (3)
 #endif

src/main.cpp

@@ -43,6 +43,7 @@ int Main::main(int argc, char *argv[]) {
   } else {
     g_in_test = true;
   }
+  g_in_test = true;
   logger->info("test_mode:{}:{}", test_mode, g_in_test);
 
   /**

src/main_control_service.cpp

@@ -39,14 +39,13 @@ void MainControlService::initialize() {
   BUILD_AND_REG_SERRVICE(DisinfectionLogsManager);
   GET_SERVICE(DisinfectionLogsManager)->initialize();
 
-  //DeviceIOInit
+  // DeviceIOInit
   if (!g_in_test) {
-    BUILD_AND_REG_SERRVICE(DeviceIoControlService);
+    REG_SERRVICE(IF_DeviceIoContrlService, new DeviceIoControlService());
   } else {
-    REG_SERRVICE(DeviceIoControlService, new DeviceIoControlServiceTest());
+    REG_SERRVICE(IF_DeviceIoContrlService, new DeviceIoControlServiceTest());
   }
-  GET_SERVICE(DeviceIoControlService)->initialize();
-  GET_SERVICE(DeviceIoControlService)->startScan();
+  GET_SERVICE(IF_DeviceIoContrlService)->initialize();
 
   BUILD_AND_REG_SERRVICE(DataExportService);
   GET_SERVICE(DataExportService)->initialize();
@@ -58,13 +57,8 @@ void MainControlService::initialize() {
   GET_SERVICE(IflytopFrontEndService)->initialize("0.0.0.0");
   GET_SERVICE(IflytopFrontEndService)->onMessage.connect([this](weak_ptr<WebSocket> webSocket, json& cmd, json& receipt) {
     string cmdstr = cmd["command"];
-    if (cmdstr != "getState") {
-      logger->info("rx:{}", cmd.dump());
-    }
+    if (cmdstr != "getState") logger->info("rx:{}", cmd.dump());
     m_frontMsgProcesser->processMsg(cmd, receipt);
-    if (cmdstr != "getState") {
-      logger->info("tx:{}", receipt.dump());
-    }
   });
   GET_SERVICE(IflytopFrontEndService)->startListen();
 

src/main_control_service.hpp

@@ -71,7 +71,7 @@ class MainControlService : public enable_shared_from_this<MainControlService> {
   shared_ptr<DBService>               m_dbService;
   shared_ptr<DeviceStateService>      m_deviceStateService;
   shared_ptr<DisinfectionCtrlService> m_disinfectionCtrlService;
-  shared_ptr<DeviceIoControlService>  m_deviceIoControlService;
+  shared_ptr<IF_DeviceIoContrlService>  m_deviceIoControlService;
   shared_ptr<DisinfectionLogsManager> m_disinfectionLogsManager;
   shared_ptr<ZCanHost>                m_zcanhost;
   shared_ptr<DataExportService>       m_dataExportService;

src/service/device_io_control_service.cpp

@@ -1,4 +1,5 @@
 #include "device_io_control_service.hpp"
+
 #include <iconv.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,7 +11,6 @@
 using namespace iflytop;
 using namespace std;
 
-
 #define GPM_TO_SPEED(gpm)   (gpm * 14.7)
 #define SPEED_TO_GPM(speed) (speed / 14.7)
 
@@ -18,6 +18,10 @@ DeviceIoControlService::DeviceIoControlService() {}
 void DeviceIoControlService::initialize() {
   GET_TO_SERVICE(m_zcanHost);
   GET_TO_SERVICE(m_config);
+  m_zcanReceiverHost = m_zcanHost->getZCanReceiverHost();
+  m_zcanReceiverHost->registerReportMsgListener([this](uint8_t* packet, size_t len) { processReportPacket(packet, len); });
+
+  startScan();
 }
 
 void DeviceIoControlService::updateDisinfectantVolumeSample(float _pa) {
@@ -80,12 +84,41 @@ void DeviceIoControlService::startScan() {
     }
   }));
 
-  m_workThread.reset(new Thread("DeviceIoControlService", [this]() {
+  m_mainH2O2SensorDataSampleThread.reset(new Thread("MainH2O2SensorDataSampleThread", [this]() {
     ThisThread thisThread;
-    uint32_t   i     = 0;
     int        error = 0;
 
     while (!thisThread.getExitFlag()) {
+      thisThread.sleepForMs(3000);
+      if (error >= 10) {
+        continue;
+      }
+
+      ZCanHost::hpp272_data_t hpp272data;
+      int                     suc = m_zcanHost->hpp272_read_c1000(1, hpp272data);
+      if (suc == 0) {
+        report_h2o2_data_t h2o2data;
+        h2o2data.sensorid   = 0;
+        h2o2data.h2o2       = hpp272data.hydrogen_peroxide_volume;
+        h2o2data.humid      = hpp272data.relative_humidity / 10;
+        h2o2data.temp       = hpp272data.temperature1 / 10;
+        h2o2data.saturation = hpp272data.h2o_h2o2_rs / 10;
+        H2O2Sensor_updateSensorData(0, &h2o2data);
+        error = 0;
+      } else {
+        error++;
+        if (error == 10) {
+          logger->error("hpp272_read_c1000 error:{}", suc);
+        }
+      }
+    }
+  }));
+
+  m_workThread.reset(new Thread("DeviceIoControlService", [this]() {
+    ThisThread thisThread;
+    uint32_t   i = 0;
+
+    while (!thisThread.getExitFlag()) {
       /* code */
       thisThread.sleepForMs(1);
       i++;
@@ -106,21 +139,6 @@ void DeviceIoControlService::startScan() {
           m_adc_2 = adcv;
         }
       }
-      if (i % 3000 == 0 && error < 10) {
-        // m_hpp272_data_1
-        ZCanHost::hpp272_data_t m_hpp272_data_1_cache;
-        int                     suc = m_zcanHost->hpp272_read_c1000(1, m_hpp272_data_1_cache);
-        if (suc == 0) {
-          lock_guard<recursive_mutex> lock(lock_);
-          m_hpp272_data_1 = m_hpp272_data_1_cache;
-          error           = 0;
-        } else {
-          error++;
-          if (error == 10) {
-            logger->error("hpp272_read_c1000 error:{}", suc);
-          }
-        }
-      }
 
       if (i % 100 == 0) {
         // m_zcanHost->readio(1, m_waterImmersionSensor1);
@@ -183,7 +201,7 @@ int DeviceIoControlService::heatingStrip_getio2() { return m_zcanHost->read_writ
 int DeviceIoControlService::heatingStrip_getstate() { return m_zcanHost->read_writeio_state_cache(4) && m_zcanHost->read_writeio_state_cache(5); }
 int DeviceIoControlService::heatingStrip_getcurrentValue() { return m_adc_2 * 0.00336 - 2.5; }
 //
-int DeviceIoControlService::getChargingPump_PumpRPM() { return m_zcanHost->pumpctrl_c1004_get_speed_cache(1); }
+int DeviceIoControlService::drainingPump_getRPM() { return m_zcanHost->pumpctrl_c1004_get_speed_cache(1); }
 
 void DeviceIoControlService::drainingPump_open() {
   logger->info("drainingPump_open");
@@ -312,106 +330,88 @@ int DeviceIoControlService::getWaterImmersionSensor2() {
   return m_waterImmersionSensor2 ? 1 : 0;
 }
 
-DeviceIoControlService::h2o2sensor_data_t DeviceIoControlService::getH2O2SenSorData1() {
-  lock_guard<recursive_mutex>               lock(lock_);
-  DeviceIoControlService::h2o2sensor_data_t data;
-  // int16_t hydrogen_peroxide_volume;                  // ppm            0x0100 过氧化氢浓度
-  // int16_t h2o_h2o2_rs;                               // %RS * 100      0x0101 过氧化氢相对饱和度
-  // int16_t temperature1;                              // °C * 100       0x0102 温度
-  // int16_t relative_humidity;                         // %RH * 100      0x0103 相对湿度
-  data.h2o2       = m_hpp272_data_1.hydrogen_peroxide_volume;
-  data.humid      = m_hpp272_data_1.relative_humidity / 100;
-  data.temp       = m_hpp272_data_1.temperature1 / 100;
-  data.saturation = m_hpp272_data_1.h2o_h2o2_rs / 100;
+void DeviceIoControlService::warningLightCtrl(int r, int g, int b, int w) {
+  lock_guard<recursive_mutex> lock(lock_);
+  m_zcanHost->warning_light_ctrl_c1002(1, r, g, b, w);
+}
+
+void DeviceIoControlService::printerPrintf(string str) { GET_SERVICE(UartPrinter)->print(ZIconv::utf8_to_gb2312(str)); }
+
+void DeviceIoControlService::processReportPacket(uint8_t* packet, size_t len) {  //
+  auto* cmdpacket = (transmit_disinfection_protocol_header_t*)packet;
 
   /**
-   * @brief
-   * TODO:传感器未初始化完成时，除了温度外，读取到的数据都是小于零，这里做了一个简单的处理，后续需要修改
-   *
+   * @brief 更新过氧化氢传感器数据
    */
-  if (data.h2o2 < 0) {
-    data.h2o2 = 0;
-  }
-  if (data.humid < 0) {
-    data.humid = 0;
-  }
-  if (data.saturation < 0) {
-    data.saturation = 0;
+  if (cmdpacket->cmdid == kreport_h2o2_sensor_data) {
+    report_h2o2_data_t* h2o2data = (report_h2o2_data_t*)cmdpacket->data;
+    if (h2o2data->sensorid > 100 && h2o2data->sensorid < 200) {
+      H2O2Sensor_updateSensorData(h2o2data->sensorid - 1, h2o2data);
+    } else if (h2o2data->sensorid < 100) {
+      H2O2Sensor_updateSensorData(0, h2o2data);
+    } else {
+      logger->error("[h2o2 sensor] id:{} error sensorid", h2o2data->sensorid);
+    }
   }
-
-  return data;
 }
 
-bool DeviceIoControlService::getAllSensorData(DeviceIoControlService::all_h2o2sensor_data_t& data) {
-  lock_guard<recursive_mutex> lock(lock_);
+int32_t DeviceIoControlService::H2O2Sensor_readH2O2PPM(int32_t sensorid) {
+  std::lock_guard<std::mutex> lck(m_h2o2_sensor_data_lock_);
+  if (sensorid > MAX_H2O2_SENSOR_NUM) return -1;
 
-  data                      = {0};
-  data.h2o2sensor_data[0]   = getH2O2SenSorData1();
-  data.h2o2sensor_status[0] = true;
+  h2o2_sensor_data_t* data = &m_h2o2_sensor_data[sensorid];
+  if (data->updatetime == 0) return -1;
 
-  data.h2o2sensor_status[1] = false;
-  data.h2o2sensor_status[2] = false;
+  if (zsys_haspassedms(data->updatetime) > 10 * 1000) return -1;
 
-  /**
-   * @brief 找到最小的过氧化氢浓度
-   */
-  data.min_h2o2 = -1;
-  for (size_t i = 0; i < ZARRAYSIZE(data.h2o2sensor_data); i++) {
-    if (data.h2o2sensor_status[i]) {
-      if (data.min_h2o2 < 0) {
-        data.min_h2o2 = data.h2o2sensor_data[i].h2o2;
-      } else if (data.h2o2sensor_data[i].h2o2 < data.min_h2o2) {
-        data.min_h2o2 = data.h2o2sensor_data[i].h2o2;
-      }
-    }
-  }
+  return data->h2o2;
+}
+int32_t DeviceIoControlService::H2O2Sensor_readHumid(int32_t sensorid) {
+  std::lock_guard<std::mutex> lck(m_h2o2_sensor_data_lock_);
+  if (sensorid > MAX_H2O2_SENSOR_NUM) return -1;
 
-  data.max_h2o2 = -1;
-  for (size_t i = 0; i < ZARRAYSIZE(data.h2o2sensor_data); i++) {
-    if (data.h2o2sensor_status[i]) {
-      if (data.max_h2o2 < 0) {
-        data.max_h2o2 = data.h2o2sensor_data[i].h2o2;
-      } else if (data.h2o2sensor_data[i].h2o2 > data.max_h2o2) {
-        data.max_h2o2 = data.h2o2sensor_data[i].h2o2;
-      }
-    }
-  }
+  h2o2_sensor_data_t* data = &m_h2o2_sensor_data[sensorid];
+  if (data->updatetime == 0) return -1;
 
-  /**
-   * @brief 找到最大的过氧化氢相对饱和度
-   */
-  data.max_saturation = -1;
-  for (size_t i = 0; i < ZARRAYSIZE(data.h2o2sensor_data); i++) {
-    if (data.h2o2sensor_status[i]) {
-      if (data.max_saturation < 0) {
-        data.max_saturation = data.h2o2sensor_data[i].saturation;
-      } else if (data.h2o2sensor_data[i].saturation > data.max_saturation) {
-        data.max_saturation = data.h2o2sensor_data[i].saturation;
-      }
-    }
-  }
+  if (zsys_haspassedms(data->updatetime) > 10 * 1000) return -1;
 
-  /**
-   * @brief 找到最大的相对湿度
-   */
+  return data->humid;
+}
+int32_t DeviceIoControlService::H2O2Sensor_readTemperature(int32_t sensorid) {
+  std::lock_guard<std::mutex> lck(m_h2o2_sensor_data_lock_);
+  if (sensorid > MAX_H2O2_SENSOR_NUM) return -1;
 
-  data.max_humid = -1;
-  for (size_t i = 0; i < ZARRAYSIZE(data.h2o2sensor_data); i++) {
-    if (data.h2o2sensor_status[i]) {
-      if (data.max_humid < 0) {
-        data.max_humid = data.h2o2sensor_data[i].humid;
-      } else if (data.h2o2sensor_data[i].humid > data.max_humid) {
-        data.max_humid = data.h2o2sensor_data[i].humid;
-      }
-    }
-  }
-  return true;
+  h2o2_sensor_data_t* data = &m_h2o2_sensor_data[sensorid];
+  if (data->updatetime == 0) return -1;
+
+  if (zsys_haspassedms(data->updatetime) > 10 * 1000) return -1;
+
+  return data->temp;
 }
+int32_t DeviceIoControlService::H2O2Sensor_readSaturation(int32_t sensorid) {
+  std::lock_guard<std::mutex> lck(m_h2o2_sensor_data_lock_);
+  if (sensorid > MAX_H2O2_SENSOR_NUM) return -1;
 
-void DeviceIoControlService::warningLightCtrl(int r, int g, int b, int w) {
-  lock_guard<recursive_mutex> lock(lock_);
-  m_zcanHost->warning_light_ctrl_c1002(1, r, g, b, w);
+  h2o2_sensor_data_t* data = &m_h2o2_sensor_data[sensorid];
+  if (data->updatetime == 0) return -1;
+
+  if (zsys_haspassedms(data->updatetime) > 10 * 1000) return -1;
+
+  return data->saturation;
 }
 
-void DeviceIoControlService::printerTest() {}
-void DeviceIoControlService::printerPrintf(string str) { GET_SERVICE(UartPrinter)->print(ZIconv::utf8_to_gb2312(str)); }
+void DeviceIoControlService::H2O2Sensor_updateSensorData(int32_t sensorid, report_h2o2_data_t* data) {
+  std::lock_guard<std::mutex> lck(m_h2o2_sensor_data_lock_);
+  if (sensorid > MAX_H2O2_SENSOR_NUM) {
+    logger->warn("H2O2Sensor_updateSensorData fail,sensorid:{} is invalid", sensorid);
+    return;
+  }
+
+  h2o2_sensor_data_t* sensor_data = &m_h2o2_sensor_data[sensorid];
+  sensor_data->h2o2               = data->h2o2 / 10;
+  sensor_data->temp               = data->temp / 10;
+  sensor_data->humid              = data->humid / 10;
+  sensor_data->saturation         = data->saturation / 10;
+  sensor_data->sensorId           = data->sensorid;
+  sensor_data->updatetime         = zsys_get_ticket();
+}

src/service/device_io_control_service.hpp

@@ -13,19 +13,8 @@
 #include <sstream>
 #include <string>
 #include <vector>
-
-#include "iflytop/components/zcanreceiver/zcanhost.hpp"
-#include "iflytop/core/core.hpp"
-#include "zservice_container/zservice_container.hpp"
 //
-#include "configs/gconfig.hpp"
-#include "utils/moving_average_filter.hpp"
-#include "utils/volume_convertor.hpp"
-
-// lock_guard<mutex> lock(lock_);
-
-#include <mutex>
-// std::lock_guard<std::recursive_mutex> lock(lock_);
+#include "if_devoce_io_contrl_service.hpp"
 
 /**
  * @brief
@@ -43,20 +32,40 @@ namespace iflytop {
 using namespace std;
 using namespace core;
 
-class DeviceIoControlService : public enable_shared_from_this<DeviceIoControlService> {
+class DeviceIoControlService : public IF_DeviceIoContrlService {
   ENABLE_LOGGER(DeviceIoControlService);
 
-  unique_ptr<Thread>   m_workThread;
-  shared_ptr<ZCanHost> m_zcanHost;
+ public:
+  typedef struct {
+    uint8_t sensorId;
+    int64_t updatetime;
+    float   h2o2;        // ppm * 10
+    float   humid;       // %RH * 10
+    float   temp;        // °C * 10
+    float   saturation;  // %RS * 10
+  } h2o2_sensor_data_t;
+
+  typedef struct {
+    int min_h2o2;
+    int max_h2o2;
+    int max_humid;
+    int max_saturation;
+  } h2o2_sensor_statistics_result_t;
 
-  unique_ptr<Thread>  m_PressureSensorDataSampleThread;
+ private:
   shared_ptr<GConfig> m_config;
 
+  shared_ptr<ZCanHost>         m_zcanHost;
+  shared_ptr<ZCanReceiverHost> m_zcanReceiverHost;
+
+  unique_ptr<Thread> m_PressureSensorDataSampleThread;
+  unique_ptr<Thread> m_mainH2O2SensorDataSampleThread;
+  unique_ptr<Thread> m_workThread;
+
   //
   // std::mutex lock_;
   std::recursive_mutex lock_;
 
-  ZCanHost::hpp272_data_t                         m_hpp272_data_1           = {0};
   ZCanHost::huacheng_pressure_sensor_read_c1005_t m_pressure_sensor_data[5] = {0};
   int32_t                                         m_disinfectantVolumeSample_g;  // 消毒液量采样
 
@@ -72,101 +81,90 @@ class DeviceIoControlService : public enable_shared_from_this<DeviceIoControlSer
   int m_adc_1 = 0;  //
   int m_adc_2 = 0;
 
+  h2o2_sensor_data_t m_h2o2_sensor_data[MAX_H2O2_SENSOR_NUM] = {0};
+  std::mutex         m_h2o2_sensor_data_lock_;
+
  public:
   DeviceIoControlService();
-  virtual void initialize();
-  virtual void startScan();
+  virtual void initialize() override;
 
-  void printerPrintf(string str);
-  void printerTest();
+  virtual void printerPrintf(string str) override;
+
+ public:
+  virtual int32_t H2O2Sensor_readH2O2PPM(int32_t sensorid) override;
+  virtual int32_t H2O2Sensor_readHumid(int32_t sensorid) override;
+  virtual int32_t H2O2Sensor_readTemperature(int32_t sensorid) override;
+  virtual int32_t H2O2Sensor_readSaturation(int32_t sensorid) override;
+
+ private:
+  void H2O2Sensor_updateSensorData(int32_t sensorid, report_h2o2_data_t* data);
 
  public:
   /*******************************************************************************
    *                                 加热片控制                                  *
    *******************************************************************************/
-  virtual int  heatingStrip_getio1();
-  virtual int  heatingStrip_getio2();
-  virtual int  heatingStrip_getstate();
-  virtual int  heatingStrip_getcurrentValue();
-  virtual void heartingPlate_setPower(bool val);
+  virtual int  heatingStrip_getio1() override;
+  virtual int  heatingStrip_getio2() override;
+  virtual int  heatingStrip_getstate() override;
+  virtual int  heatingStrip_getcurrentValue() override;
+  virtual void heartingPlate_setPower(bool val) override;
 
   /*******************************************************************************
    *                                 鼓风机控制                                  *
    *******************************************************************************/
-  virtual int airBlower_getio1();
-  virtual int airBlower_getio2();
-  virtual int airBlower_getstate();
-  virtual int airBlower_getcurrentValue();
-  virtual int airBlower_setState(bool state);
+  virtual int airBlower_getio1() override;
+  virtual int airBlower_getio2() override;
+  virtual int airBlower_getstate() override;
+  virtual int airBlower_getcurrentValue() override;
+  virtual int airBlower_setState(bool state) override;
 
   /*******************************************************************************
    *                                 空压机控制                                  *
    *******************************************************************************/
-  virtual void airCompressor_setState(bool val);
-  virtual int  airCompressor_getio1();
-  virtual int  airCompressor_getio2();
-  virtual int  airCompressor_getstate();
-  virtual int  airCompressor_getcurrentValue();
-
-  // heatingStrip
+  virtual void airCompressor_setState(bool val) override;
+  virtual int  airCompressor_getio1() override;
+  virtual int  airCompressor_getio2() override;
+  virtual int  airCompressor_getstate() override;
+  virtual int  airCompressor_getcurrentValue() override;
 
   /*******************************************************************************
    *                                 泵控制                                       *
    *******************************************************************************/
-  virtual int getChargingPump_PumpRPM();
   // 排液泵
-  virtual void drainingPump_open();
-  virtual void drainingPump_close();
+  virtual void drainingPump_open() override;
+  virtual void drainingPump_close() override;
+  virtual int  drainingPump_getRPM() override;
   // 充液泵
-  virtual void replenishingFluidsPump_open();
-  virtual void replenishingFluidsPump_close();
+  virtual void replenishingFluidsPump_open() override;
+  virtual void replenishingFluidsPump_close() override;
 
-  virtual void replenishingFluidsPump_open_for_test(int speed);
-  virtual void replenishingFluidsPump_close_for_test();
+  virtual void replenishingFluidsPump_open_for_test(int speed) override;
+  virtual void replenishingFluidsPump_close_for_test() override;
 
   // 喷液泵
-  virtual void sprayLiquidPump_open(int gpm);
-  virtual void sprayLiquidPump_close();
-  virtual int  sprayLiquidPump_getState();
-  virtual int  sprayLiquidPump_getRPM();
-  virtual int  sprayLiquidPump_getGPM();
+  virtual void sprayLiquidPump_open(int gpm) override;
+  virtual void sprayLiquidPump_close() override;
+  virtual int  sprayLiquidPump_getState() override;
+  virtual int  sprayLiquidPump_getRPM() override;
+  virtual int  sprayLiquidPump_getGPM() override;
 
-  virtual void sprayLiquidPump_open_for_test(int gpm);
-  virtual void sprayLiquidPump_close_for_test();
+  virtual void sprayLiquidPump_open_for_test(int gpm) override;
+  virtual void sprayLiquidPump_close_for_test() override;
 
   /******************************************************************************
    *                                 水浸传感器                                  *
    ******************************************************************************/
-  virtual int getWaterImmersionSensor1();
-  virtual int getWaterImmersionSensor2();
-
-  virtual int getDisinfectantVolume_g();  // g
-  virtual int getPressureSensorData(int index);
-
-  typedef struct {
-    int h2o2;        // ppm
-    int temp;        // 温度
-    int humid;       // 湿度 %RS
-    int saturation;  // 相对饱和度 %RS
-  } h2o2sensor_data_t;
-
-  virtual h2o2sensor_data_t getH2O2SenSorData1();
-
-  typedef struct {
-    h2o2sensor_data_t h2o2sensor_data[3];
-    bool              h2o2sensor_status[3];
-
-    int min_h2o2;
-    int max_h2o2;
-    int max_humid;
-    int max_saturation;
+  virtual int getWaterImmersionSensor1() override;
+  virtual int getWaterImmersionSensor2() override;
 
-  } all_h2o2sensor_data_t;
-  virtual bool getAllSensorData(DeviceIoControlService::all_h2o2sensor_data_t& data);
+  virtual int getDisinfectantVolume_g() override;  // g
+  virtual int getPressureSensorData(int index) override;
 
-  virtual void warningLightCtrl(int r, int g, int b, int w);
+  virtual void warningLightCtrl(int r, int g, int b, int w) override;
 
  private:
   void updateDisinfectantVolumeSample(float kpa);
+  void processReportPacket(uint8_t* packet, size_t len);
+  void startScan();
 };
 }  // namespace iflytop

src/service/device_io_control_service_test.cpp

@@ -5,296 +5,100 @@ using namespace std;
 
 #define IN_TEST 1
 
-void DeviceIoControlServiceTest::initialize() {}
+void DeviceIoControlServiceTest::printerPrintf(string str) {}
 
-void DeviceIoControlServiceTest::startScan() {}
+int32_t DeviceIoControlServiceTest::H2O2Sensor_readH2O2PPM(int32_t sensorid) { return rand() % 1000; }
+int32_t DeviceIoControlServiceTest::H2O2Sensor_readHumid(int32_t sensorid) { return rand() % 100; }
+int32_t DeviceIoControlServiceTest::H2O2Sensor_readTemperature(int32_t sensorid) { return rand() % 100; }
+int32_t DeviceIoControlServiceTest::H2O2Sensor_readSaturation(int32_t sensorid) { return rand() % 100; }
 
-void DeviceIoControlServiceTest::airCompressor_setState(bool val) {
-  logger->info("airCompressor_setState:{}", val);
-  if (val) {
-    m_airCompressor_State = true;
-  } else {
-    m_airCompressor_State = false;
-  }
-}
-int DeviceIoControlServiceTest::airCompressor_getio1() {
-  if (m_airCompressor_State) {
-    return 1;
-  }
-  return 0;
-}
-int DeviceIoControlServiceTest::airCompressor_getio2() {
-  if (m_airCompressor_State) {
-    return 1;
-  }
-  return 0;
-}
-int DeviceIoControlServiceTest::airCompressor_getcurrentValue() {
-  if (m_airCompressor_State) {
-    return 2;
-  }
-  return 0;
-}
-int DeviceIoControlServiceTest::airCompressor_getstate() {
-  if (m_airCompressor_State) {
-    return 1;
-  }
-  return 0;
-}
-
-int DeviceIoControlServiceTest::airBlower_setState(bool val) {
-  logger->info("airBlower_setState:{}", val);
-  m_airBlower_State = val;
+/*******************************************************************************
+ *                                 加热片控制                                  *
+ *******************************************************************************/
 
-  return 0;
-}
-int DeviceIoControlServiceTest::airBlower_getio1() {
-  if (m_airBlower_State) {
-    return 1;
-  }
-  return 0;
-}
-int DeviceIoControlServiceTest::airBlower_getio2() {
-  if (m_airBlower_State) {
-    return 1;
-  }
-  return 0;
-}
-int DeviceIoControlServiceTest::airBlower_getstate() {
-  if (m_airBlower_State) {
-    return 1;
-  }
-  return 0;
-}
+static int heatingStrip_io1;
+static int heatingStrip_io2;
+static int heatingStrip_state;
+static int heatingStrip_currentValue;
 
-int DeviceIoControlServiceTest::airBlower_getcurrentValue() {
-  if (m_airBlower_State) {
-    return 2;
-  }
-  return 0;
-}
-// heatingStrip
+int  DeviceIoControlServiceTest::heatingStrip_getio1() { return heatingStrip_io1; }
+int  DeviceIoControlServiceTest::heatingStrip_getio2() { return heatingStrip_io2; }
+int  DeviceIoControlServiceTest::heatingStrip_getstate() { return heatingStrip_state; }
+int  DeviceIoControlServiceTest::heatingStrip_getcurrentValue() { return heatingStrip_currentValue; }
 void DeviceIoControlServiceTest::heartingPlate_setPower(bool val) {
-  logger->info("heartingPlate_setPower:{}", val);
-
-  m_heartingPlate_power = val;
-}
-int DeviceIoControlServiceTest::heatingStrip_getio1() {
-  if (m_heartingPlate_power) {
-    return 1;
-  }
-  return 0;
-}
-int DeviceIoControlServiceTest::heatingStrip_getio2() {
-  if (m_heartingPlate_power) {
-    return 1;
-  }
-  return 0;
-}
-int DeviceIoControlServiceTest::heatingStrip_getstate() {
-  if (m_heartingPlate_power) {
-    return 1;
-  }
-  return 0;
-}
-int DeviceIoControlServiceTest::heatingStrip_getcurrentValue() {
-  if (m_heartingPlate_power) {
-    return 2;
-  }
-  return 0;
+  heatingStrip_state        = val;
+  heatingStrip_currentValue = val ? 10 : 0;
+  heatingStrip_io1          = 1;
+  heatingStrip_io2          = 1;
 }
-//
 
-static bool drainingPump_state;
-void        DeviceIoControlServiceTest::drainingPump_open() {
-  logger->info("drainingPump_open");
-  drainingPump_state = true;
-}
-void DeviceIoControlServiceTest::drainingPump_close() {
-  logger->info("drainingPump_close");
-  drainingPump_state = false;
-}
-static bool replenishingFluidsPump_state;
-static int  replenishingFluidsPump_gpm;
-void        DeviceIoControlServiceTest::replenishingFluidsPump_open() {
-  logger->info("replenishingFluidsPump_open");
-  replenishingFluidsPump_state = true;
-  replenishingFluidsPump_gpm   = 20;
-}
-void DeviceIoControlServiceTest::replenishingFluidsPump_close() {
-  logger->info("replenishingFluidsPump_close");
-  replenishingFluidsPump_state = false;
-  replenishingFluidsPump_gpm   = 0;
-}
-
-void DeviceIoControlServiceTest::replenishingFluidsPump_open_for_test(int gpm) {
-  logger->info("replenishingFluidsPump_open_for_test {}", gpm);
-  replenishingFluidsPump_state = true;
-  replenishingFluidsPump_gpm   = gpm;
-}
-void DeviceIoControlServiceTest::replenishingFluidsPump_close_for_test() {
-  logger->info("replenishingFluidsPump_close_for_test");
-  replenishingFluidsPump_state = false;
-  replenishingFluidsPump_gpm   = 0;
-}
-int DeviceIoControlServiceTest::getChargingPump_PumpRPM() {
-  if (replenishingFluidsPump_state) {
-    return replenishingFluidsPump_gpm;
-  }
+/*******************************************************************************
+ *                                 鼓风机控制                                  *
+ *******************************************************************************/
+static int airBlower_io1;
+static int airBlower_io2;
+static int airBlower_state;
+static int airBlower_currentValue;
+
+int DeviceIoControlServiceTest::airBlower_getio1() { return airBlower_io1; }
+int DeviceIoControlServiceTest::airBlower_getio2() { return airBlower_io2; }
+int DeviceIoControlServiceTest::airBlower_getstate() { return airBlower_state; }
+int DeviceIoControlServiceTest::airBlower_getcurrentValue() { return airBlower_currentValue; }
+int DeviceIoControlServiceTest::airBlower_setState(bool state) {
+  airBlower_state        = state;
+  airBlower_currentValue = state ? 11 : 0;
+  airBlower_io1          = 1;
+  airBlower_io2          = 1;
   return 0;
 }
 
 /*******************************************************************************
- *                               sprayLiquidPump                               *
+ *                                 空压机控制                                  *
  *******************************************************************************/
-static bool sprayLiquidPump_state;
-static int  sprayLiquidPump_gpm;
-void        DeviceIoControlServiceTest::sprayLiquidPump_open(int gpm) {
-  logger->info("sprayLiquidPump_open");
-  sprayLiquidPump_state = true;
-  sprayLiquidPump_gpm   = gpm;
-}
-void DeviceIoControlServiceTest::sprayLiquidPump_close() {
-  logger->info("sprayLiquidPump_close");
-  sprayLiquidPump_state = false;
-}
-
-void DeviceIoControlServiceTest::sprayLiquidPump_open_for_test(int gpm) {
-  logger->info("sprayLiquidPump_open_for_test {}", gpm);
-  sprayLiquidPump_state = true;
-  sprayLiquidPump_gpm   = gpm;
-}
-void DeviceIoControlServiceTest::sprayLiquidPump_close_for_test() {
-  logger->info("sprayLiquidPump_close");
-  sprayLiquidPump_state = false;
-}
-
-int DeviceIoControlServiceTest::sprayLiquidPump_getRPM() {
-  if (sprayLiquidPump_state) {
-    return sprayLiquidPump_gpm;
-  } else {
-    return 0;
-  }
-}
-int DeviceIoControlServiceTest::sprayLiquidPump_getGPM() {
-  if (sprayLiquidPump_state) {
-    return sprayLiquidPump_gpm;
-  } else {
-    return 0;
-  }
-}
+static int airCompressor_io1;
+static int airCompressor_io2;
+static int airCompressor_state;
+static int airCompressor_currentValue;
+void       DeviceIoControlServiceTest::airCompressor_setState(bool val) {
+  airCompressor_state        = val;
+  airCompressor_currentValue = val ? 12 : 0;
+  airCompressor_io1          = 1;
+  airCompressor_io2          = 1;
+}
+int DeviceIoControlServiceTest::airCompressor_getio1() { return airCompressor_io1; }
+int DeviceIoControlServiceTest::airCompressor_getio2() { return airCompressor_io2; }
+int DeviceIoControlServiceTest::airCompressor_getstate() { return airCompressor_state; }
+int DeviceIoControlServiceTest::airCompressor_getcurrentValue() { return airCompressor_currentValue; }
 
-int DeviceIoControlServiceTest::sprayLiquidPump_getState() {  //
-  return (sprayLiquidPump_getRPM() != 0);
-}
 /*******************************************************************************
- *                                 SensorState                                 *
+ *                                 泵控制                                       *
  *******************************************************************************/
-int DeviceIoControlServiceTest::getDisinfectantVolume_g() { return 1000; }
-int DeviceIoControlServiceTest::getPressureSensorData(int index) { return 1000; }
-
-int DeviceIoControlServiceTest::getWaterImmersionSensor1() { return 0; }
-int DeviceIoControlServiceTest::getWaterImmersionSensor2() { return 0; }
-
-DeviceIoControlService::h2o2sensor_data_t DeviceIoControlServiceTest::getH2O2SenSorData1() {
-  DeviceIoControlService::h2o2sensor_data_t data;
-
-  static bool       isPumpOpen = false;
-  static int        h2o2       = 0;
-  static int        maxh2o2    = 0;
-  static zsteady_tp opentime;
-  static zsteady_tp closetime;
-  if (!isPumpOpen && sprayLiquidPump_getState() != 0) {
-    isPumpOpen = true;
-    h2o2       = 0;
-    opentime   = zsteady_clock().now();
-  }
-  if (isPumpOpen && sprayLiquidPump_getState() == 0) {
-    isPumpOpen = false;
-    closetime  = zsteady_clock().now();
-  }
-
-  if (isPumpOpen) {
-    int hasopens = zsteady_clock().elapsedTimeS(opentime);
-    h2o2         = hasopens * 10;
-    if (h2o2 > 1500) h2o2 = 1500;
-    maxh2o2 = h2o2;
-  } else {
-    int hasopens = zsteady_clock().elapsedTimeS(closetime);
-    h2o2         = maxh2o2 - hasopens * 10;
-  }
-
-  if (h2o2 < 0) {
-    h2o2 = 0;
-  }
-
-  data.h2o2       = h2o2;
-  data.humid      = 12;
-  data.temp       = 34;
-  data.saturation = 56;
-  return data;
-}
 
-bool DeviceIoControlServiceTest::getAllSensorData(DeviceIoControlServiceTest::all_h2o2sensor_data_t& data) {
-  data                      = {0};
-  data.h2o2sensor_data[0]   = getH2O2SenSorData1();
-  data.h2o2sensor_status[0] = true;
-
-  data.h2o2sensor_status[1] = false;
-  data.h2o2sensor_status[2] = false;
-
-  /**
-   * @brief 找到最小的过氧化氢浓度
-   */
-  data.min_h2o2 = -1;
-  for (size_t i = 0; i < ZARRAYSIZE(data.h2o2sensor_data); i++) {
-    if (data.h2o2sensor_status[i]) {
-      if (data.min_h2o2 < 0) {
-        data.min_h2o2 = data.h2o2sensor_data[i].h2o2;
-      } else if (data.h2o2sensor_data[i].h2o2 < data.min_h2o2) {
-        data.min_h2o2 = data.h2o2sensor_data[i].h2o2;
-      }
-    }
-  }
-
-  data.max_h2o2 = -1;
-  for (size_t i = 0; i < ZARRAYSIZE(data.h2o2sensor_data); i++) {
-    if (data.h2o2sensor_status[i]) {
-      if (data.max_h2o2 < 0) {
-        data.max_h2o2 = data.h2o2sensor_data[i].h2o2;
-      } else if (data.h2o2sensor_data[i].h2o2 > data.max_h2o2) {
-        data.max_h2o2 = data.h2o2sensor_data[i].h2o2;
-      }
-    }
-  }
-
-  /**
-   * @brief 找到最大的过氧化氢相对饱和度
-   */
-  data.max_saturation = -1;
-  for (size_t i = 0; i < ZARRAYSIZE(data.h2o2sensor_data); i++) {
-    if (data.h2o2sensor_status[i]) {
-      if (data.max_saturation < 0) {
-        data.max_saturation = data.h2o2sensor_data[i].saturation;
-      } else if (data.h2o2sensor_data[i].saturation > data.max_saturation) {
-        data.max_saturation = data.h2o2sensor_data[i].saturation;
-      }
-    }
-  }
-
-  /**
-   * @brief 找到最大的相对湿度
-   */
-
-  data.max_humid = -1;
-  for (size_t i = 0; i < ZARRAYSIZE(data.h2o2sensor_data); i++) {
-    if (data.h2o2sensor_status[i]) {
-      if (data.max_humid < 0) {
-        data.max_humid = data.h2o2sensor_data[i].humid;
-      } else if (data.h2o2sensor_data[i].humid > data.max_humid) {
-        data.max_humid = data.h2o2sensor_data[i].humid;
-      }
-    }
-  }
-  return true;
-}
+// 排液泵
+static int drainingPump_rpm;
+void       DeviceIoControlServiceTest::drainingPump_open() { drainingPump_rpm = 121; }
+void       DeviceIoControlServiceTest::drainingPump_close() { drainingPump_rpm = 0; }
+int        DeviceIoControlServiceTest::drainingPump_getRPM() { return drainingPump_rpm; }
+// 充液泵
+void DeviceIoControlServiceTest::replenishingFluidsPump_open() { drainingPump_rpm = -122; }
+void DeviceIoControlServiceTest::replenishingFluidsPump_close() { drainingPump_rpm = 0; }
+void DeviceIoControlServiceTest::replenishingFluidsPump_open_for_test(int speed) { drainingPump_rpm = speed; }
+void DeviceIoControlServiceTest::replenishingFluidsPump_close_for_test() { drainingPump_rpm = 0; }
+// 喷液泵
+static int sprayLiquidPump_rpm;
+void       DeviceIoControlServiceTest::sprayLiquidPump_open(int gpm) { sprayLiquidPump_rpm = 123; }
+void       DeviceIoControlServiceTest::sprayLiquidPump_close() { sprayLiquidPump_rpm = 0; }
+int        DeviceIoControlServiceTest::sprayLiquidPump_getState() { return sprayLiquidPump_rpm; }
+int        DeviceIoControlServiceTest::sprayLiquidPump_getRPM() { return sprayLiquidPump_rpm; }
+int        DeviceIoControlServiceTest::sprayLiquidPump_getGPM() { return sprayLiquidPump_rpm * 2; }
+void       DeviceIoControlServiceTest::sprayLiquidPump_open_for_test(int gpm) { sprayLiquidPump_rpm = gpm; }
+void       DeviceIoControlServiceTest::sprayLiquidPump_close_for_test() { sprayLiquidPump_rpm = 0; }
+
+/******************************************************************************
+ *                                 水浸传感器                                  *
+ ******************************************************************************/
+int  DeviceIoControlServiceTest::getWaterImmersionSensor1() { return 0; }
+int  DeviceIoControlServiceTest::getWaterImmersionSensor2() { return 1; }
+int  DeviceIoControlServiceTest::getDisinfectantVolume_g() { return 123; }         // g
+int  DeviceIoControlServiceTest::getPressureSensorData(int index) { return 456; }  // g
+void DeviceIoControlServiceTest::warningLightCtrl(int r, int g, int b, int w) { logger->info("warningLightCtrl r:{} g:{} b:{} w:{}", r, g, b, w); }

src/service/device_io_control_service_test.hpp

@@ -14,6 +14,7 @@
 #include <string>
 #include <vector>
 
+#include "configs/project_setting.hpp"
 #include "device_io_control_service.hpp"
 #include "iflytop/components/zcanreceiver/zcanhost.hpp"
 #include "iflytop/core/core.hpp"
@@ -39,81 +40,78 @@ namespace iflytop {
 using namespace std;
 using namespace core;
 
-class DeviceIoControlServiceTest : public DeviceIoControlService {
+class DeviceIoControlServiceTest : public IF_DeviceIoContrlService {
   ENABLE_LOGGER(DeviceIoControlServiceTest);
 
-  bool m_airCompressor_State;
-  bool m_airBlower_State;
-  bool m_heartingPlate_power;
-
  public:
-  virtual void initialize();
-  virtual void startScan();
+  virtual void printerPrintf(string str) override;
 
  public:
+  virtual int32_t H2O2Sensor_readH2O2PPM(int32_t sensorid) override;
+  virtual int32_t H2O2Sensor_readHumid(int32_t sensorid) override;
+  virtual int32_t H2O2Sensor_readTemperature(int32_t sensorid) override;
+  virtual int32_t H2O2Sensor_readSaturation(int32_t sensorid) override;
+
   /*******************************************************************************
    *                                 加热片控制                                  *
    *******************************************************************************/
-  virtual int  heatingStrip_getio1();
-  virtual int  heatingStrip_getio2();
-  virtual int  heatingStrip_getstate();
-  virtual int  heatingStrip_getcurrentValue();
-  virtual void heartingPlate_setPower(bool val);
+  virtual int  heatingStrip_getio1() override;
+  virtual int  heatingStrip_getio2() override;
+  virtual int  heatingStrip_getstate() override;
+  virtual int  heatingStrip_getcurrentValue() override;
+  virtual void heartingPlate_setPower(bool val) override;
 
   /*******************************************************************************
    *                                 鼓风机控制                                  *
    *******************************************************************************/
-  virtual int airBlower_getio1();
-  virtual int airBlower_getio2();
-  virtual int airBlower_getstate();
-  virtual int airBlower_getcurrentValue();
-  virtual int airBlower_setState(bool state);
+  virtual int airBlower_getio1() override;
+  virtual int airBlower_getio2() override;
+  virtual int airBlower_getstate() override;
+  virtual int airBlower_getcurrentValue() override;
+  virtual int airBlower_setState(bool state) override;
 
   /*******************************************************************************
    *                                 空压机控制                                  *
    *******************************************************************************/
-  virtual void airCompressor_setState(bool val);
-  virtual int  airCompressor_getio1();
-  virtual int  airCompressor_getio2();
-  virtual int  airCompressor_getstate();
-  virtual int  airCompressor_getcurrentValue();
-
-  // heatingStrip
+  virtual void airCompressor_setState(bool val) override;
+  virtual int  airCompressor_getio1() override;
+  virtual int  airCompressor_getio2() override;
+  virtual int  airCompressor_getstate() override;
+  virtual int  airCompressor_getcurrentValue() override;
 
   /*******************************************************************************
    *                                 泵控制                                       *
    *******************************************************************************/
-  virtual int getChargingPump_PumpRPM();
-  // 排液泵
-  virtual void drainingPump_open();
-  virtual void drainingPump_close();
+  virtual int  drainingPump_getRPM() override;
+
+  virtual void drainingPump_open() override;
+  virtual void drainingPump_close() override;
   // 充液泵
-  virtual void replenishingFluidsPump_open();
-  virtual void replenishingFluidsPump_close();
+  virtual void replenishingFluidsPump_open() override;
+  virtual void replenishingFluidsPump_close() override;
 
-  virtual void replenishingFluidsPump_open_for_test(int speed);
-  virtual void replenishingFluidsPump_close_for_test();
+  virtual void replenishingFluidsPump_open_for_test(int speed) override;
+  virtual void replenishingFluidsPump_close_for_test() override;
 
   // 喷液泵
-  virtual void sprayLiquidPump_open(int gpm);
-  virtual void sprayLiquidPump_close();
-  virtual int  sprayLiquidPump_getState();
-  virtual int  sprayLiquidPump_getRPM();
-  virtual int  sprayLiquidPump_getGPM();
-
-  virtual void sprayLiquidPump_open_for_test(int gpm);
-  virtual void sprayLiquidPump_close_for_test();
+  virtual void sprayLiquidPump_open(int gpm) override;
+  virtual void sprayLiquidPump_close() override;
+  virtual int  sprayLiquidPump_getState() override;
+  virtual int  sprayLiquidPump_getRPM() override;
+  virtual int  sprayLiquidPump_getGPM() override;
 
-  virtual h2o2sensor_data_t getH2O2SenSorData1();
+  virtual void sprayLiquidPump_open_for_test(int gpm) override;
+  virtual void sprayLiquidPump_close_for_test() override;
 
   /******************************************************************************
    *                                 水浸传感器                                  *
    ******************************************************************************/
-  virtual int getWaterImmersionSensor1();
-  virtual int getWaterImmersionSensor2();
+  virtual int getWaterImmersionSensor1() override;
+  virtual int getWaterImmersionSensor2() override;
+
+  virtual int getDisinfectantVolume_g() override;  // g
+  virtual int getPressureSensorData(int index) override;
 
-  virtual int  getDisinfectantVolume_g();  // g
-  virtual int  getPressureSensorData(int index);
-  virtual bool getAllSensorData(DeviceIoControlService::all_h2o2sensor_data_t& data);
+  virtual void warningLightCtrl(int r, int g, int b, int w) override;
 };
 }  // namespace iflytop

src/service/if_devoce_io_contrl_service.hpp

@@ -0,0 +1,143 @@
+//
+// Created by zwsd
+//
+
+#pragma once
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "iflytop/components/zcanreceiver/zcanhost.hpp"
+#include "iflytop/core/core.hpp"
+#include "zservice_container/zservice_container.hpp"
+//
+#include <mutex>
+
+#include "configs/gconfig.hpp"
+#include "utils/moving_average_filter.hpp"
+#include "utils/volume_convertor.hpp"
+
+/**
+ * @brief
+ *
+ * service: IF_DeviceIoContrlService
+ *
+ * 监听事件:
+ * 依赖状态:
+ * 依赖服务:
+ * 作用:
+ *
+ */
+
+namespace iflytop {
+using namespace std;
+using namespace core;
+
+class IF_DeviceIoContrlService {
+ public:
+  typedef struct {
+    uint8_t sensorId;
+    int64_t updatetime;
+    float   h2o2;        // ppm * 10
+    float   humid;       // %RH * 10
+    float   temp;        // °C * 10
+    float   saturation;  // %RS * 10
+  } h2o2_sensor_data_t;
+
+ public:
+  virtual ~IF_DeviceIoContrlService() {}
+
+  virtual void initialize() {};
+
+ public:
+  virtual void printerPrintf(string str) = 0;
+
+ public:
+  virtual int32_t H2O2Sensor_readH2O2PPM(int32_t sensorid)                                = 0;
+  virtual int32_t H2O2Sensor_readHumid(int32_t sensorid)                                  = 0;
+  virtual int32_t H2O2Sensor_readTemperature(int32_t sensorid)                            = 0;
+  virtual int32_t H2O2Sensor_readSaturation(int32_t sensorid)                             = 0;
+
+  /*******************************************************************************
+   *                                 加热片控制                                  *
+   *******************************************************************************/
+  virtual int  heatingStrip_getio1()            = 0;
+  virtual int  heatingStrip_getio2()            = 0;
+  virtual int  heatingStrip_getstate()          = 0;
+  virtual int  heatingStrip_getcurrentValue()   = 0;
+  virtual void heartingPlate_setPower(bool val) = 0;
+
+  /*******************************************************************************
+   *                                 鼓风机控制                                  *
+   *******************************************************************************/
+  virtual int airBlower_getio1()             = 0;
+  virtual int airBlower_getio2()             = 0;
+  virtual int airBlower_getstate()           = 0;
+  virtual int airBlower_getcurrentValue()    = 0;
+  virtual int airBlower_setState(bool state) = 0;
+
+  /*******************************************************************************
+   *                                 空压机控制                                  *
+   *******************************************************************************/
+  virtual void airCompressor_setState(bool val) = 0;
+  virtual int  airCompressor_getio1()           = 0;
+  virtual int  airCompressor_getio2()           = 0;
+  virtual int  airCompressor_getstate()         = 0;
+  virtual int  airCompressor_getcurrentValue()  = 0;
+
+  // heatingStrip
+
+  /*******************************************************************************
+   *                                 泵控制                                       *
+   *******************************************************************************/
+  virtual int drainingPump_getRPM() = 0;
+
+  // 排液泵
+  virtual void drainingPump_open()  = 0;
+  virtual void drainingPump_close() = 0;
+  // 充液泵
+  virtual void replenishingFluidsPump_open()                   = 0;
+  virtual void replenishingFluidsPump_close()                  = 0;
+  virtual void replenishingFluidsPump_open_for_test(int speed) = 0;
+  virtual void replenishingFluidsPump_close_for_test()         = 0;
+
+  // 喷液泵
+  virtual void sprayLiquidPump_open(int gpm) = 0;
+  virtual void sprayLiquidPump_close()       = 0;
+  virtual int  sprayLiquidPump_getState()    = 0;
+  virtual int  sprayLiquidPump_getRPM()      = 0;
+  virtual int  sprayLiquidPump_getGPM()      = 0;
+
+  virtual void sprayLiquidPump_open_for_test(int gpm) = 0;
+  virtual void sprayLiquidPump_close_for_test()       = 0;
+
+  /******************************************************************************
+   *                                 水浸传感器                                  *
+   ******************************************************************************/
+  virtual int getWaterImmersionSensor1() = 0;
+  virtual int getWaterImmersionSensor2() = 0;
+
+  /******************************************************************************
+   *                                 水位传感器                                  *
+   ******************************************************************************/
+  virtual int getDisinfectantVolume_g() = 0;  // g
+
+  /*******************************************************************************
+   *                                 压力传感器                                  *
+   *******************************************************************************/
+  virtual int getPressureSensorData(int index) = 0;
+
+  /*******************************************************************************
+   *                                 报警指示灯                                  *
+   *******************************************************************************/
+
+  virtual void warningLightCtrl(int r, int g, int b, int w) = 0;
+};
+}  // namespace iflytop