update

iflytoplinuxsdk

@@ -1 +1 @@
-Subproject commit e7f29bc0cb917c9e17706e9c7666f9c9f47cefc1
+Subproject commit 32297f28a8e13bf748e983e61f7d444d4919ff48

src/db/db_service.cpp

@@ -155,7 +155,7 @@ id	setting_name	      setting_name_ch	         val_upper_limit	   val_lower_limi
 
       if (storage.get_all<Setting>(where(c(&Setting::id) == 7)).size() == 0)
         storage.insert(Setting{7, "injection_pump_speed", "喷射蠕动泵转速", 0, 350, 2, 300});
-        
+
       if (storage.get_all<Setting>(where(c(&Setting::id) == 8)).size() == 0)  //
         storage.insert(Setting{8, "pre_heat_time_s", "预热时间", 0, 600, 1, 120});
 
@@ -284,6 +284,16 @@ bool DBService::setSettingVal(string setting_name, int val) {
   return true;
 }
 
+int DBService::getSettingVal(string name) {
+  auto settingtable = make_storage(SETTING_DB, SETTING_DB_STRUCT);
+  settingtable.sync_schema();
+  auto setting = settingtable.get_all<Setting>(where(c(&Setting::name) == name));
+  if (setting.size() == 0) {
+    return -1;
+  }
+  return setting[0].val;
+}
+
 json DBService::getAllRecords(string disinfection_id) {
   json j_records;
   auto recordtable = make_storage(DISINFECTION_RECORD_DB_STRUCT);

src/db/db_service.hpp

@@ -128,6 +128,7 @@ class DBService : public enable_shared_from_this<DBService> {
   json                          getAllSettingJson();
   bool                          setSettingVal(int id, int val);
   bool                          setSettingVal(string name, int val);
+  int                           getSettingVal(string name);
 
  public:
   /*******************************************************************************

src/main_control_service.cpp

@@ -44,11 +44,16 @@ void MainControlService::initialize() {
   GET_SERVICE(ZCanHost)->initialize(m_zconfig->get_iflytopSubDeviceCanIFName(), m_zconfig->get_iflytopSubDeviceCanBitrate(), false);
   GET_TO_SERVICE(m_zcanhost);
 
-  BUILD_AND_REG_SERRVICE(SensorDataScan);
-  GET_SERVICE(SensorDataScan)->initialize();
-  GET_TO_SERVICE(m_sensorDataScan);
+  BUILD_AND_REG_SERRVICE(DisinfectionLogsManager);
+  GET_SERVICE(DisinfectionLogsManager)->initialize();
+  GET_TO_SERVICE(m_disinfectionLogsManager);
 
-  m_sensorDataScan->startScan();
+  BUILD_AND_REG_SERRVICE(DeviceIoControlService);
+  GET_SERVICE(DeviceIoControlService)->initialize();
+  GET_TO_SERVICE(m_deviceIoControlService);
+
+
+  m_deviceIoControlService->startScan();
 
   /**
    * @brief Get the to service object
@@ -119,38 +124,39 @@ void MainControlService::initialize() {
 
 json MainControlService::createSensorDataJson() {
   json report;
-  report["airCompressor"]["io1"]        = m_sensorDataScan->getAirCompressor_io1();
-  report["airCompressor"]["io2"]        = m_sensorDataScan->getAirCompressor_io2();
-  report["airCompressor"]["currentVal"] = m_sensorDataScan->getAirCompressor_currentValue();
+  report["airCompressor"]["io1"]        = m_deviceIoControlService->getAirCompressor_io1();
+  report["airCompressor"]["io2"]        = m_deviceIoControlService->getAirCompressor_io2();
+  report["airCompressor"]["currentVal"] = m_deviceIoControlService->getAirCompressor_currentValue();
 
-  report["airBlower"]["io1"]        = m_sensorDataScan->getAirBlower_io1();
-  report["airBlower"]["io2"]        = m_sensorDataScan->getAirBlower_io2();
-  report["airBlower"]["currentVal"] = m_sensorDataScan->getAirBlower_currentValue();
+  report["airBlower"]["io1"]        = m_deviceIoControlService->getAirBlower_io1();
+  report["airBlower"]["io2"]        = m_deviceIoControlService->getAirBlower_io2();
+  report["airBlower"]["currentVal"] = m_deviceIoControlService->getAirBlower_currentValue();
 
-  report["heatingStrip"]["io1"]        = m_sensorDataScan->getHeatingStrip_io1();
-  report["heatingStrip"]["io2"]        = m_sensorDataScan->getHeatingStrip_io2();
-  report["heatingStrip"]["currentVal"] = m_sensorDataScan->getHeatingStrip_currentValue();
+  report["heatingStrip"]["io1"]        = m_deviceIoControlService->getHeatingStrip_io1();
+  report["heatingStrip"]["io2"]        = m_deviceIoControlService->getHeatingStrip_io2();
+  report["heatingStrip"]["currentVal"] = m_deviceIoControlService->getHeatingStrip_currentValue();
 
-  report["sprinklerPump"] = m_sensorDataScan->getSprinkler_PumpRPM();
-  report["chargingPump"]  = m_sensorDataScan->getChargingPump_PumpRPM();
+  report["sprinklerPump"] = m_deviceIoControlService->getSprinkler_PumpRPM();
+  report["chargingPump"]  = m_deviceIoControlService->getChargingPump_PumpRPM();
 
-  report["waterImmersionSensor1"] = m_sensorDataScan->getWaterImmersionSensor1();
-  report["waterImmersionSensor2"] = m_sensorDataScan->getWaterImmersionSensor2();
+  report["waterImmersionSensor1"] = m_deviceIoControlService->getWaterImmersionSensor1();
+  report["waterImmersionSensor2"] = m_deviceIoControlService->getWaterImmersionSensor2();
 
   // Water immersion sensor
-  report["disinfectant_volume"] = m_sensorDataScan->getDisinfectantVolume_g();
-  report["h2o2_1"]              = m_sensorDataScan->getH2O2SenSorData1().h2o2;
-  report["temp_1"]              = m_sensorDataScan->getH2O2SenSorData1().temp;
-  report["humid_1"]             = m_sensorDataScan->getH2O2SenSorData1().humid;
-  report["saturation_1"]        = m_sensorDataScan->getH2O2SenSorData1().saturation;
-  report["h2o2_2"]              = -1;
-  report["temp_2"]              = -1;
-  report["humid_2"]             = -1;
-  report["saturation_2"]        = -1;
-  report["h2o2_3"]              = -1;
-  report["temp_3"]              = -1;
-  report["humid_3"]             = -1;
-  report["saturation_3"]        = -1;
+  report["disinfectant_volume"] = m_deviceIoControlService->getDisinfectantVolume_g();
+  // report["h2o2_1"]              = m_deviceIoControlService->getH2O2SenSorData1().h2o2;
+  report["h2o2_1"]       = m_deviceIoControlService->getH2O2SenSorData1().h2o2;
+  report["temp_1"]       = m_deviceIoControlService->getH2O2SenSorData1().temp;
+  report["humid_1"]      = m_deviceIoControlService->getH2O2SenSorData1().humid;
+  report["saturation_1"] = m_deviceIoControlService->getH2O2SenSorData1().saturation;
+  report["h2o2_2"]       = -1;
+  report["temp_2"]       = -1;
+  report["humid_2"]      = -1;
+  report["saturation_2"] = -1;
+  report["h2o2_3"]       = -1;
+  report["temp_3"]       = -1;
+  report["humid_3"]      = -1;
+  report["saturation_3"] = -1;
   return report;
 }
 // {"command":"startReplenishingFluids","messageId":"startReplenishingFluids","stopAt":123}
@@ -254,14 +260,6 @@ void MainControlService::processFrontEndMessage(weak_ptr<WebSocket> webSocket, j
     return;
   }
 
-  if (cmdstr == "pauseDisinfection") {
-    m_disinfectionCtrlService->pauseDisinfection();
-    return;
-  }
-  if (cmdstr == "continueDisinfection") {
-    m_disinfectionCtrlService->continueDisinfection();
-    return;
-  }
 #if 0
 //开始加液
 {

src/main_control_service.hpp

@@ -30,7 +30,8 @@
 //
 #include "db/db_service.hpp"
 #include "iflytop/components/zcanreceiver/zcanhost.hpp"
-#include "service/sensor_data_scan.hpp"
+#include "service/device_io_control_service.hpp"
+#include "service/disinfection_logs_manager.hpp"
 #include "src/service/iflytop_can_host_device.hpp"
 
 /**
@@ -57,7 +58,8 @@ 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<SensorDataScan>          m_sensorDataScan;
+  shared_ptr<DeviceIoControlService>  m_deviceIoControlService;
+  shared_ptr<DisinfectionLogsManager> m_disinfectionLogsManager;
   shared_ptr<ZCanHost>                m_zcanhost;
 
   unique_ptr<Thread> m_reportThread;

src/service/device_io_control_service.cpp

@@ -0,0 +1,211 @@
+#include "device_io_control_service.hpp"
+
+using namespace iflytop;
+using namespace std;
+
+#if 0
+模块           板子 硬件ID ID
+空压机-安全电磁阀 3 PC2 0
+空压机-通断电磁阀 3 PC3 1
+鼓风机-安全电磁阀 3 PC4 2
+-通断电磁阀      3 PC5 3
+加热片-安全电磁阀 3 PC6 4
+-通断电磁阀      3 PC7 5
+#endif
+
+DeviceIoControlService::DeviceIoControlService() {}
+void DeviceIoControlService::initialize() { GET_TO_SERVICE(m_zcanHost); }
+
+void DeviceIoControlService::startScan() {
+  m_workThread.reset(new Thread("DeviceIoControlService", [this]() {
+    ThisThread thisThread;
+    uint32_t   i = 0;
+
+    int readpressuresensor_id = 1;
+
+    while (!thisThread.getExitFlag()) {
+      /* code */
+      thisThread.sleepForMs(1);
+      i++;
+
+      if (i % 1000 == 0) {
+        m_zcanHost->readadc(0, m_adc_0);
+        m_zcanHost->readadc(1, m_adc_1);
+        m_zcanHost->readadc(2, m_adc_2);
+        // m_zcanHost->readadc(3, m_adc_3);
+        // m_zcanHost->readadc(4, m_adc_4);
+        // m_zcanHost->readadc(5, m_adc_5);
+      }
+
+      if (i % 3000 == 0) {
+        // m_hpp272_data_1
+        m_zcanHost->hpp272_read_c1000(1, m_hpp272_data_1);
+      }
+
+      if (i % 300 == 0) {
+        if (readpressuresensor_id == 5) {
+          readpressuresensor_id = 1;
+        }
+        m_zcanHost->huacheng_pressure_sensor_read_c1005(readpressuresensor_id, m_pressure_sensor_data[readpressuresensor_id]);
+        readpressuresensor_id++;
+      }
+
+      if (i % 100 == 0) {
+        // m_zcanHost->readio(1, m_waterImmersionSensor1);
+        // m_zcanHost->readio(2, m_waterImmersionSensor2);
+      }
+    }
+  }));
+}
+
+void DeviceIoControlService::airCompressor_setState(bool val) {
+  logger->info("airCompressor_setState:{}", val);
+  if (val) {
+    m_zcanHost->writeio(0, 1);
+    usleep(500 * 100);
+    m_zcanHost->writeio(1, 1);
+  } else {
+    m_zcanHost->writeio(1, 0);
+    usleep(500 * 100);
+    m_zcanHost->writeio(0, 0);
+  }
+}
+
+int DeviceIoControlService::getAirCompressor_io1() { return m_zcanHost->read_writeio_state_cache(1); }
+int DeviceIoControlService::getAirCompressor_io2() { return m_zcanHost->read_writeio_state_cache(2); }
+int DeviceIoControlService::getAirCompressor_currentValue() { return m_adc_0 * 0.00167 - 1.25; }
+
+int DeviceIoControlService::getAirBlower_io1() { return m_zcanHost->read_writeio_state_cache(3); }
+int DeviceIoControlService::getAirBlower_io2() { return m_zcanHost->read_writeio_state_cache(4); }
+int DeviceIoControlService::getAirBlower_currentValue() { return m_adc_1 * 0.00167 - 1.25; }
+int DeviceIoControlService::AirBlower_setState(bool val) {
+  logger->info("AirBlower_setState:{}", val);
+  if (val) {
+    m_zcanHost->writeio(2, 1);
+    usleep(500 * 100);
+    m_zcanHost->writeio(3, 1);
+  } else {
+    m_zcanHost->writeio(3, 0);
+    usleep(500 * 100);
+    m_zcanHost->writeio(2, 0);
+  }
+  return 0;
+}
+
+// heatingStrip
+int  DeviceIoControlService::getHeatingStrip_io1() { return m_zcanHost->read_writeio_state_cache(5); }
+int  DeviceIoControlService::getHeatingStrip_io2() { return m_zcanHost->read_writeio_state_cache(6); }
+int  DeviceIoControlService::getHeatingStrip_currentValue() { return m_adc_2 * 0.00336 - 2.5; }
+void DeviceIoControlService::heartingPlate_setPower(bool val) {
+  logger->info("heartingPlate_setPower:{}", val);
+  if (val) {
+    m_zcanHost->writeio(4, 1);
+    usleep(500 * 100);
+    m_zcanHost->writeio(5, 1);
+  } else {
+    m_zcanHost->writeio(5, 0);
+    usleep(500 * 100);
+    m_zcanHost->writeio(4, 0);
+  }
+}
+
+int DeviceIoControlService::getSprinkler_PumpRPM() { return m_zcanHost->pumpctrl_c1004_get_speed_cache(2); }
+int DeviceIoControlService::getChargingPump_PumpRPM() { return m_zcanHost->pumpctrl_c1004_get_speed_cache(1); }
+
+void DeviceIoControlService::drainingPump_open() { m_zcanHost->pumpctrl_c1004(1, 100, -300, 1, 20); }
+void DeviceIoControlService::drainingPump_close() { m_zcanHost->pumpctrl_c1004(1, 100, 0, 1, 20); }
+
+void DeviceIoControlService::replenishingFluidsPump_open() { m_zcanHost->pumpctrl_c1004(1, 100, 300, 1, 20); }
+void DeviceIoControlService::replenishingFluidsPump_close() { m_zcanHost->pumpctrl_c1004(1, 100, 0, 1, 20); }
+
+void DeviceIoControlService::sprayLiquidPump_open() { m_zcanHost->pumpctrl_c1004(2, 100, 200, 1, 15); }
+void DeviceIoControlService::sprayLiquidPump_close() { m_zcanHost->pumpctrl_c1004(2, 100, 0, 1, 15); }
+
+int DeviceIoControlService::getDisinfectantVolume_g() {
+  // kpa;
+  float kpa = m_pressure_sensor_data[1].value / 1000.0;
+  int   g   = 2.11 * kpa * 1000;
+  if (g < 450) { /*零点*/
+    return 0;
+  }
+  return g;
+}
+
+int DeviceIoControlService::getWaterImmersionSensor1() { return m_waterImmersionSensor1 ? 1 : 0; }
+int DeviceIoControlService::getWaterImmersionSensor2() { return m_waterImmersionSensor2 ? 1 : 0; }
+
+DeviceIoControlService::h2o2sensor_data_t DeviceIoControlService::getH2O2SenSorData1() {
+  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;
+  return data;
+}
+
+bool DeviceIoControlService::getAllSensorData(DeviceIoControlService::all_h2o2sensor_data_t& data) {
+  data.h2o2sensor_data[0]   = getH2O2SenSorData1();
+  data.h2o2sensor_status[0] = true;
+
+  data.h2o2sensor_status[1] = true;
+  data.h2o2sensor_status[2] = true;
+
+  /**
+   * @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;
+}

src/service/device_io_control_service.hpp

@@ -0,0 +1,129 @@
+//
+// 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"
+
+/**
+ * @brief
+ *
+ * service: DeviceIoControlService
+ *
+ * 监听事件:
+ * 依赖状态:
+ * 依赖服务:
+ * 作用:
+ *
+ */
+
+namespace iflytop {
+using namespace std;
+using namespace core;
+
+class DeviceIoControlService : public enable_shared_from_this<DeviceIoControlService> {
+  ENABLE_LOGGER(DeviceIoControlService);
+
+  unique_ptr<Thread>   m_workThread;
+  shared_ptr<ZCanHost> m_zcanHost;
+
+  //
+  ZCanHost::hpp272_data_t                         m_hpp272_data_1;
+  ZCanHost::huacheng_pressure_sensor_read_c1005_t m_pressure_sensor_data[5];
+
+  //
+  bool m_waterImmersionSensor1 = false;  // 漏液检测
+  bool m_waterImmersionSensor2 = false;  // 仓内液体检测
+
+  int m_adc_0 = 0;  //
+  int m_adc_1 = 0;  //
+  int m_adc_2 = 0;
+
+ public:
+  DeviceIoControlService();
+  void initialize();
+  void startScan();
+
+ public:
+  /*******************************************************************************
+   *                                 空压机控制                                  *
+   *******************************************************************************/
+  void airCompressor_setState(bool val);
+  int  getAirCompressor_io1();
+  int  getAirCompressor_io2();
+  int  getAirCompressor_currentValue();
+
+  /*******************************************************************************
+   *                                 鼓风机控制                                  *
+   *******************************************************************************/
+  int getAirBlower_io1();
+  int getAirBlower_io2();
+  int getAirBlower_currentValue();
+  int AirBlower_setState(bool state);
+
+  // heatingStrip
+  /*******************************************************************************
+   *                                 加热片控制                                  *
+   *******************************************************************************/
+  int  getHeatingStrip_io1();
+  int  getHeatingStrip_io2();
+  int  getHeatingStrip_currentValue();
+  void heartingPlate_setPower(bool val);
+
+  /*******************************************************************************
+   *                                 泵控制                                       *
+   *******************************************************************************/
+  int getSprinkler_PumpRPM();
+  int getChargingPump_PumpRPM();
+  // 排液泵
+  void drainingPump_open();
+  void drainingPump_close();
+  // 充液泵
+  void replenishingFluidsPump_open();
+  void replenishingFluidsPump_close();
+  // 喷液泵
+  void sprayLiquidPump_open();
+  void sprayLiquidPump_close();
+  /*******************************************************************************
+   *                                 水浸传感器                                  *
+   *******************************************************************************/
+  int getWaterImmersionSensor1();
+  int getWaterImmersionSensor2();
+
+  int getDisinfectantVolume_g();  // g
+
+  typedef struct {
+    int h2o2;        // ppm
+    int temp;        // 温度
+    int humid;       // 湿度 %RS
+    int saturation;  // 相对饱和度 %RS
+  } h2o2sensor_data_t;
+
+  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;
+
+  } all_h2o2sensor_data_t;
+  bool getAllSensorData(DeviceIoControlService::all_h2o2sensor_data_t& data);
+};
+}  // namespace iflytop

src/service/disinfection_ctl_service.cpp

@@ -22,54 +22,26 @@ using namespace std;
  *
  */
 
-#define PRE_HEAT_TIME (5 * 60)
+#define PRE_HEAT_TIME               (2)
+#define DVALUE_COMPUTEPERIOD_TIME_S (60.0)
+#define MAX_VOLUME                  (5000)
 
-void DisinfectionCtrlService::drainingPump_open() { m_zcanHost->pumpctrl_c1004(1, 100, -300, 1, 20); }
-void DisinfectionCtrlService::drainingPump_close() { m_zcanHost->pumpctrl_c1004(1, 100, 0, 1, 20); }
-
-void DisinfectionCtrlService::replenishingFluidsPump_open() { m_zcanHost->pumpctrl_c1004(1, 100, 300, 1, 20); }
-void DisinfectionCtrlService::replenishingFluidsPump_close() { m_zcanHost->pumpctrl_c1004(1, 100, 0, 1, 20); }
+DisinfectionCtrlService::DisinfectionCtrlService() {}
+void DisinfectionCtrlService::initialize() {
+  GET_TO_SERVICE(m_zcanHost);
+  GET_TO_SERVICE(m_deviceIoControlService);
+  GET_TO_SERVICE(m_dbService);
+  GET_TO_SERVICE(m_disinfectionLogsManager);
 
-void DisinfectionCtrlService::sprayLiquidPump_open() { m_zcanHost->pumpctrl_c1004(2, 100, 200, 1, 15); }
-void DisinfectionCtrlService::sprayLiquidPump_close() { m_zcanHost->pumpctrl_c1004(2, 100, 0, 1, 15); }
+  m_deviceIoControlService->drainingPump_close();
+  m_deviceIoControlService->replenishingFluidsPump_close();
+  m_deviceIoControlService->sprayLiquidPump_close();
 
-void DisinfectionCtrlService::airCompressor(bool val) {
-  if (val) {
-    m_zcanHost->writeio(0, 1);
-    usleep(500 * 100);
-    m_zcanHost->writeio(1, 1);
-  } else {
-    m_zcanHost->writeio(1, 0);
-    usleep(500 * 100);
-    m_zcanHost->writeio(0, 0);
-  }
-}
-
-void DisinfectionCtrlService::blower_setPower(bool val) {
-  if (val) {
-    m_zcanHost->writeio(2, 1);
-    usleep(500 * 100);
-    m_zcanHost->writeio(3, 1);
-  } else {
-    m_zcanHost->writeio(3, 0);
-    usleep(500 * 100);
-    m_zcanHost->writeio(2, 0);
-  }
-}
-void DisinfectionCtrlService::heartingPlate_setPower(bool val) {
-  if (val) {
-    m_zcanHost->writeio(4, 1);
-    usleep(500 * 100);
-    m_zcanHost->writeio(5, 1);
-  } else {
-    m_zcanHost->writeio(5, 0);
-    usleep(500 * 100);
-    m_zcanHost->writeio(4, 0);
-  }
+  m_deviceIoControlService->heartingPlate_setPower(false);
+  m_deviceIoControlService->AirBlower_setState(false);
+  m_deviceIoControlService->airCompressor_setState(false);
 }
 
-DisinfectionCtrlService::DisinfectionCtrlService() {}
-
 string DisinfectionCtrlService::createDisinfectionID() {
   struct tm tm = {0};
 
@@ -91,86 +63,242 @@ string DisinfectionCtrlService::createDisinfectionID() {
                      tm.tm_hour,                                                   //
                      tm.tm_min, tm.tm_sec);
 }
+float DisinfectionCtrlService::getDisinfectionDValue(float ppm) {
+  /**
+   * @brief
+   *
+   *  D值的计算公式是根据美国竞品的数据记录计算得来的
+   *
+   *  浓度小于150时,y=-0.5269X+97.868
+   *  浓度大于150时,y=-0.1405X+40.369
+   */
+
+  float dvalue = 0;
+
+  if (ppm < 150) {
+    dvalue = -0.5269 * ppm + 97.868;
+  } else if (ppm >= 150 || ppm < 300) {
+    dvalue = -0.1405 * ppm + 40.369;
+  }
+  if (dvalue < 2) {
+    dvalue = 2;
+  }
+  return dvalue;
+}
 
-void DisinfectionCtrlService::initialize() {
-  GET_TO_SERVICE(m_zcanHost);
-  GET_TO_SERVICE(m_sensorDataScan);
+void DisinfectionCtrlService::computeRemainTime(DisinfectionContext& context) {
+  /**
+   * @brief 计算Dvalue
+   */
+  float dvalue = getDisinfectionDValue(context.h2o2data.min_h2o2);
+
+  /**
+   * @brief 计算 m_nowLoglevel
+   */
+  context.m_nowLoglevel += DVALUE_COMPUTEPERIOD_TIME_S / (dvalue * 60);
+  if (context.m_targetLoglevel >= context.m_nowLoglevel) {
+    context.m_remaintime = (context.m_targetLoglevel - context.m_nowLoglevel) * (dvalue * 60);
+  } else {
+    context.m_remaintime = 0;
+  }
+  logger->info("computeRemainTime minh2o2 {} dvalue {}", context.h2o2data.min_h2o2, dvalue);
+}
+
+void DisinfectionCtrlService::initContext(DisinfectionContext& context, int loglevel, float roomVol) {
+  context.m_disinfectionID = createDisinfectionID();
+  // m_remaintime            = loglevel * 20 * 60;  // 计算总的加热时间
+  context.m_remaintime     = PRE_HEAT_TIME + loglevel * 20 * 60 * (roomVol / 20.0);  // 计算总的加热时间
+  m_disinfectionWorkState  = 1;
+  context.m_targetLoglevel = loglevel;
+  context.m_nowLoglevel    = 0;
+  context.m_loglevel       = loglevel;
+  context.m_roomvol        = roomVol;
+
+  context.stoped_gs       = m_dbService->getSettingVal("stoped_gs");
+  context.continued_gs    = m_dbService->getSettingVal("continued_gs");
+  context.stoped_satur    = m_dbService->getSettingVal("stoped_satur");
+  context.continued_satur = m_dbService->getSettingVal("continued_satur");
+
+  m_context.m_starttp = zsteady_clock().now();
+  logger->info("startDisinfection {} {} {}", m_context.m_loglevel, m_context.m_roomvol, m_context.m_disinfectionID);
+  logger->info(" stoped_gs {}", context.stoped_gs);
+  logger->info(" continued_gs {}", context.continued_gs);
+  logger->info(" stoped_satur {}", context.stoped_satur);
+  logger->info(" continued_satur {}", context.continued_satur);
+  logger->info("");
+
+  m_zcanHost->warning_light_ctrl_c1002(1, 0, 0, 1, 0);
+  m_deviceIoControlService->heartingPlate_setPower(true);
+  context.csvlogger = m_disinfectionLogsManager->createNewLogger(context.m_disinfectionID);
+  context.csvlogger->write("time,h2o21,temp1,humi1,saturation1,h2o22,temp2,humi2,saturation2,h2o23,temp3,humi3,saturation3,dvalue,nowlog,targetlog,remaintime");
+}
+void DisinfectionCtrlService::finishDisinfection(DisinfectionContext& context) {
+  context.m_remaintime = 0;
+  logger->info("stop disinfection {}", context.m_disinfectionID);
+
+  // sprayLiquidPump_close();
+  m_deviceIoControlService->sprayLiquidPump_close();
+  usleep(1000 * 1000);
+  // airCompressor(false);
+  m_deviceIoControlService->airCompressor_setState(false);
+  usleep(1000 * 1000);
+  // blower_setPower(false);
+  m_deviceIoControlService->AirBlower_setState(false);
+  usleep(1000 * 1000);
+  // heartingPlate_setPower(false);
+  m_deviceIoControlService->heartingPlate_setPower(false);
+  m_disinfectionWorkState = 3;
+  m_zcanHost->warning_light_ctrl_c1002(1, 0, 0, 0, 0);
+  context.csvlogger = nullptr;
+}
+
+void DisinfectionCtrlService::processPreheatState(DisinfectionContext& context) {
+  if (context.m_preheatFlag && zsteady_clock().elapsedTimeS(context.m_starttp) > PRE_HEAT_TIME) {
+    logger->info("preheat finished {}", context.m_disinfectionID);
+    // blower_setPower(true);
+    m_deviceIoControlService->AirBlower_setState(true);
+    usleep(1000 * 1000);
+    // airCompressor(true);
+    m_deviceIoControlService->airCompressor_setState(true);
+    usleep(1000 * 1000);
+    // sprayLiquidPump_open();
+    m_deviceIoControlService->sprayLiquidPump_open();
+    context.m_preheatFlag   = false;
+    context.sprayLiquidFlag = true;
+  }
+}
+void DisinfectionCtrlService::dumpDisinfectionLogs(DisinfectionContext& context) {
+  logger->info("T:{},h2o21:{},t1:{},humi:{},s1:{},h2o22:{},t2:{},humi2:{},s2:{},h2o23:{},t3:{},humi3:{},s3:{},dvalue:{},nowlog:{},targetlog:{},remaintime:{}",
+               zsteady_clock().elapsedTimeS(m_context.m_starttp),  //
+               m_context.h2o2data.h2o2sensor_data[0].h2o2,         //
+               m_context.h2o2data.h2o2sensor_data[0].temp,         //
+               m_context.h2o2data.h2o2sensor_data[0].humid,        //
+               m_context.h2o2data.h2o2sensor_data[0].saturation,   //
+               m_context.h2o2data.h2o2sensor_data[1].h2o2,         //
+               m_context.h2o2data.h2o2sensor_data[1].temp,         //
+               m_context.h2o2data.h2o2sensor_data[1].humid,        //
+               m_context.h2o2data.h2o2sensor_data[1].saturation,   //
+               m_context.h2o2data.h2o2sensor_data[2].h2o2,         //
+               m_context.h2o2data.h2o2sensor_data[2].temp,         //
+               m_context.h2o2data.h2o2sensor_data[2].humid,        //
+               m_context.h2o2data.h2o2sensor_data[2].saturation,   //
+               m_context.dvalue,                                   //
+               m_context.m_nowLoglevel,                            //
+               m_context.m_targetLoglevel,                         //
+               m_context.m_remaintime                              //
+  );
+
+  context.csvlogger->write(fmt::format("{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}",
+                                       zsteady_clock().elapsedTimeS(m_context.m_starttp),  //
+                                       m_context.h2o2data.h2o2sensor_data[0].h2o2,         //
+                                       m_context.h2o2data.h2o2sensor_data[0].temp,         //
+                                       m_context.h2o2data.h2o2sensor_data[0].humid,        //
+                                       m_context.h2o2data.h2o2sensor_data[0].saturation,   //
+                                       m_context.h2o2data.h2o2sensor_data[1].h2o2,         //
+                                       m_context.h2o2data.h2o2sensor_data[1].temp,         //
+                                       m_context.h2o2data.h2o2sensor_data[1].humid,        //
+                                       m_context.h2o2data.h2o2sensor_data[1].saturation,   //
+                                       m_context.h2o2data.h2o2sensor_data[2].h2o2,         //
+                                       m_context.h2o2data.h2o2sensor_data[2].temp,         //
+                                       m_context.h2o2data.h2o2sensor_data[2].humid,        //
+                                       m_context.h2o2data.h2o2sensor_data[2].saturation,   //
+                                       m_context.dvalue,                                   //
+                                       m_context.m_nowLoglevel,                            //
+                                       m_context.m_targetLoglevel,                         //
+                                       m_context.m_remaintime                              //
+                                       ));
+}
+
+void DisinfectionCtrlService::processDisinfectionState(DisinfectionContext& context) {
+  /**
+   * @brief 读取传感器数值
+   */
+  m_deviceIoControlService->getAllSensorData(m_context.h2o2data);
+
+  if (zsteady_clock().elapsedTimeS(m_context.m_lastComputeDvalueTp) > DVALUE_COMPUTEPERIOD_TIME_S) {
+    m_context.m_lastComputeDvalueTp = zsteady_clock().now();
+    /**
+     * @brief 周期性计算剩余时间
+     */
+    computeRemainTime(m_context);
+  }
+
+  dumpDisinfectionLogs(m_context);
+  /**
+   * @brief 根据湿度启停喷雾
+   */
+  if (m_context.sprayLiquidFlag) {
+    /**
+     * @brief 检查当前
+     */
+    float nowSatur = m_context.h2o2data.max_saturation;
+    float nowh2o2  = m_context.h2o2data.max_h2o2;
+    float humid    = m_context.h2o2data.max_humid;
+
+    if (nowSatur > m_context.stoped_satur || nowh2o2 > m_context.stoped_gs || humid > m_context.stoped_satur) {
+      logger->info("stop sprayLiquid");
+
+      m_deviceIoControlService->sprayLiquidPump_close();
+      usleep(1000 * 1000);
+      m_deviceIoControlService->airCompressor_setState(false);
+
+      m_context.sprayLiquidFlag = false;
+    }
+  } else {
+    float nowSatur = m_context.h2o2data.max_saturation;
+    float nowh2o2  = m_context.h2o2data.max_h2o2;
+    float humid    = m_context.h2o2data.max_humid;
+
+    if (nowSatur < m_context.continued_satur && nowh2o2 < m_context.continued_gs && humid < m_context.continued_satur) {
+      logger->info("start sprayLiquid");
 
-  drainingPump_close();
-  replenishingFluidsPump_close();
-  sprayLiquidPump_close();
+      m_deviceIoControlService->sprayLiquidPump_open();
+      usleep(1000 * 1000);
+      m_deviceIoControlService->airCompressor_setState(true);
 
-  heartingPlate_setPower(false);
-  blower_setPower(false);
-  airCompressor(false);
+      m_context.sprayLiquidFlag = true;
+    }
+  }
 }
+
 void DisinfectionCtrlService::startDisinfection(int loglevel, float roomVol) {
   lock_guard<recursive_mutex> lock(lock_);
 
+  /**
+   * @TODO
+   *  检查当前环境湿度，湿度过大，不允许消毒
+   */
+
   if (m_disinfectionThread) {
     stopDisinfection();
   }
+  initContext(m_context, loglevel, roomVol);
 
-  m_disinfectionID = createDisinfectionID();
-  // m_remaintime            = loglevel * 20 * 60;  // 计算总的加热时间
-  m_remaintime            = PRE_HEAT_TIME + loglevel * 20 * 60 * (roomVol / 20.0);  // 计算总的加热时间
-  m_disinfectionWorkState = 1;
-
-  m_disinfectionThread.reset(new Thread("m_disinfectionThread", [this, roomVol, loglevel]() {
+  m_disinfectionThread.reset(new Thread("m_disinfectionThread", [this]() {
     ThisThread thisThread;
-    // bool       preHeartFinishedFlag = false;
-
-    logger->info("startDisinfection {} {} {}", loglevel, roomVol, m_disinfectionID);
-    m_zcanHost->warning_light_ctrl_c1002(1, 1, 1, 1, 0);
-
-    auto starttime = zsteady_clock().now();
-    heartingPlate_setPower(true);
-    m_preheatFlag = 1;
     while (!thisThread.getExitFlag()) {
       thisThread.sleepForMs(1000);
-      if (m_disinfectionWorkState == 2) {
-        logger->info("disinfection paused {} {}", m_disinfectionID, m_remaintime);
-        continue;
-      }
+      logger->info("disinfection running {} {}s preheatFlag:{}", m_context.m_disinfectionID, m_context.m_remaintime, m_context.m_preheatFlag);
 
-      m_remaintime--;
-      if (m_remaintime == 0) {
-        logger->info("disinfection finished {}", m_disinfectionID);
-        break;
+      if (m_context.m_preheatFlag) {
+        processPreheatState(m_context);
+      } else {
+        processDisinfectionState(m_context);
       }
 
-      logger->info("disinfection running {} {}s preheatFlag:{}", m_disinfectionID, m_remaintime, m_preheatFlag);
-
-      if (m_preheatFlag && zsteady_clock().elapsedTimeS(starttime) > PRE_HEAT_TIME) {
-        logger->info("preheat finished {}", m_disinfectionID);
-        blower_setPower(true);
-        usleep(1000 * 1000);
-        airCompressor(true);
-        usleep(1000 * 1000);
-        sprayLiquidPump_open();
-        m_preheatFlag = false;
+      m_context.m_remaintime--;
+      if (m_context.m_remaintime == 0) {
+        logger->info("disinfection finished {}", m_context.m_disinfectionID);
+        break;
       }
     }
-
-    m_remaintime = 0;
-    logger->info("stop disinfection {}", m_disinfectionID);
-
-    sprayLiquidPump_close();
-    usleep(1000 * 1000);
-    airCompressor(false);
-    usleep(1000 * 1000);
-    blower_setPower(false);
-    usleep(1000 * 1000);
-    heartingPlate_setPower(false);
-    m_disinfectionWorkState = 3;
-    m_zcanHost->warning_light_ctrl_c1002(1, 0, 0, 0, 0);
+    finishDisinfection(m_context);
   }));
+  //
 }
 
 int DisinfectionCtrlService::getDisinfectionWorkState() { return m_disinfectionWorkState; }
 
-void DisinfectionCtrlService::pauseDisinfection() { m_disinfectionWorkState = 2; }
-void DisinfectionCtrlService::continueDisinfection() { m_disinfectionWorkState = 1; }
 void DisinfectionCtrlService::stopDisinfection() {
   lock_guard<recursive_mutex> lock(lock_);
   if (m_disinfectionThread) {
@@ -182,21 +310,31 @@ void DisinfectionCtrlService::stopDisinfection() {
 
 int32_t DisinfectionCtrlService::getEstimatedRemainingTimeS() {
   lock_guard<recursive_mutex> lock(lock_);
-  return m_remaintime;
+  return m_context.m_remaintime;
 }
 string DisinfectionCtrlService::getDisinfectionID() {
   lock_guard<recursive_mutex> lock(lock_);
-  return m_disinfectionID;
+  return m_context.m_disinfectionID;
 }
 
-// 加液
+int DisinfectionCtrlService::getReplenishingFluidsWorkState() { return m_replenishingFluidsWorkState; }
+int DisinfectionCtrlService::getDrainingWorkState() { return m_drainingWorkState; }
+
+/*******************************************************************************
+ *                                   // 加液                                   *
+ *******************************************************************************/
+/**
+ * @brief 开始加液
+ *
+ * @param stopatg
+ */
 void DisinfectionCtrlService::startReplenishingFluids(int stopatg) {
   lock_guard<recursive_mutex> lock(lock_);
   if (m_disinfectionThread) {
     m_disinfectionThread->join();
     m_disinfectionThread = nullptr;
   }
-  int32_t nowvolume = m_sensorDataScan->getDisinfectantVolume_g();
+  int32_t nowvolume = m_deviceIoControlService->getDisinfectantVolume_g();
   if (nowvolume > stopatg) {
     logger->warn("start Replenishing fail, nowvolume {} > stopatg {}", nowvolume, stopatg);
     return;
@@ -204,16 +342,16 @@ void DisinfectionCtrlService::startReplenishingFluids(int stopatg) {
 
   m_disinfectionThread.reset(new Thread("disinfectionThread", [this, stopatg]() {
     ThisThread thisThread;
-    replenishingFluidsPump_open();
+    m_deviceIoControlService->replenishingFluidsPump_open();
     logger->info("startReplenishingFluids {}g", stopatg);
     while (!thisThread.getExitFlag()) {
-      int32_t nowvolume = m_sensorDataScan->getDisinfectantVolume_g();
+      int32_t nowvolume = m_deviceIoControlService->getDisinfectantVolume_g();
       logger->info("replenishingFluids {}g", nowvolume);
       if (nowvolume > stopatg) {
         break;
       }
 
-      if (nowvolume > 5000) {
+      if (nowvolume > MAX_VOLUME) {
         logger->warn("replenishingFluids reach full level {}g", nowvolume);
         break;
       }
@@ -221,7 +359,8 @@ void DisinfectionCtrlService::startReplenishingFluids(int stopatg) {
       thisThread.sleepForMs(1000);
     }
     logger->info("stopReplenishingFluids");
-    replenishingFluidsPump_close();
+    // replenishingFluidsPump_close();
+    m_deviceIoControlService->replenishingFluidsPump_close();
     m_replenishingFluidsWorkState = 0;
   }));
 
@@ -229,7 +368,10 @@ void DisinfectionCtrlService::startReplenishingFluids(int stopatg) {
   m_replenishingFluidsWorkState = 1;
   logger->info("startReplenishingFluids ");
 }
-// 停止加液
+/**
+ * @brief 停止加液
+ *
+ */
 void DisinfectionCtrlService::stopReplenishingFluids() {
   lock_guard<recursive_mutex> lock(lock_);
   if (m_disinfectionThread) {
@@ -238,10 +380,17 @@ void DisinfectionCtrlService::stopReplenishingFluids() {
   }
 
   logger->info("stopReplenishingFluids");
-  replenishingFluidsPump_close();
+  // replenishingFluidsPump_close();
+  m_deviceIoControlService->replenishingFluidsPump_close();
   m_replenishingFluidsWorkState = 0;
 }
-// 开始排液
+/*******************************************************************************
+ *                                    排液                                     *
+ *******************************************************************************/
+/**
+ * @brief 开始排液
+ *
+ */
 void DisinfectionCtrlService::startDraining() {
   lock_guard<recursive_mutex> lock(lock_);
   if (m_disinfectionThread) {
@@ -250,10 +399,13 @@ void DisinfectionCtrlService::startDraining() {
   }
 
   logger->info("startDraining");
-  drainingPump_open();
+  // drainingPump_open();
+  m_deviceIoControlService->drainingPump_open();
   m_drainingWorkState = 1;
 }
-// 停止排液体
+/**
+ * @brief 停止排液体
+ */
 void DisinfectionCtrlService::stopDraining() {
   lock_guard<recursive_mutex> lock(lock_);
   if (m_disinfectionThread) {
@@ -262,7 +414,6 @@ void DisinfectionCtrlService::stopDraining() {
   }
   logger->info("stopDraining");
   m_drainingWorkState = 0;
-  drainingPump_close();
-}
-int DisinfectionCtrlService::getReplenishingFluidsWorkState() { return m_replenishingFluidsWorkState; }
-int DisinfectionCtrlService::getDrainingWorkState() { return m_drainingWorkState; }
+  // drainingPump_close();
+  m_deviceIoControlService->drainingPump_close();
+}

src/service/disinfection_ctl_service.hpp

@@ -14,11 +14,12 @@
 #include <string>
 #include <vector>
 
+#include "db/db_service.hpp"
+#include "disinfection_logs_manager.hpp"
 #include "iflytop/components/zcanreceiver/zcanhost.hpp"
 #include "iflytop/core/core.hpp"
-#include "service/sensor_data_scan.hpp"
+#include "service/device_io_control_service.hpp"
 #include "zservice_container/zservice_container.hpp"
-
 /**
  * @brief
  *
@@ -37,21 +38,48 @@ using namespace core;
 class DisinfectionCtrlService : public enable_shared_from_this<DisinfectionCtrlService> {
   ENABLE_LOGGER(DisinfectionCtrlService);
 
-  unique_ptr<Thread>         m_disinfectionThread;
-  shared_ptr<SensorDataScan> m_sensorDataScan;
-  string                     m_disinfectionID;
+  unique_ptr<Thread>                  m_disinfectionThread;
+  shared_ptr<DeviceIoControlService>  m_deviceIoControlService;
+  shared_ptr<DBService>               m_dbService;
+  shared_ptr<DisinfectionLogsManager> m_disinfectionLogsManager;
 
-  int             m_remaintime = 0;
   recursive_mutex lock_;
 
   int m_disinfectionWorkState       = 0;
   int m_replenishingFluidsWorkState = 0;
   int m_drainingWorkState           = 0;
 
-  bool m_preheatFlag = false;
-
   shared_ptr<ZCanHost> m_zcanHost;
 
+  class DisinfectionContext {
+   public:
+    string m_disinfectionID;
+    float  m_roomvol  = 0;
+    float  m_loglevel = 0;
+
+    zsteady_tp m_starttp;
+    zsteady_tp m_lastComputeDvalueTp;
+
+    DeviceIoControlService::all_h2o2sensor_data_t h2o2data;
+
+    bool  m_preheatFlag    = false;
+    int   m_remaintime     = 0;
+    float m_targetLoglevel = 0;
+    float m_nowLoglevel    = 0;
+    float dvalue           = 0;
+
+    bool sprayLiquidFlag = false;
+
+    int stoped_gs       = 0;
+    int continued_gs    = 0;
+    int stoped_satur    = 0;
+    int continued_satur = 0;
+
+    shared_ptr<DisinfectionLogger> csvlogger;
+  };
+
+  DisinfectionContext m_context;
+
  public:
   DisinfectionCtrlService();
 
@@ -64,26 +92,24 @@ class DisinfectionCtrlService : public enable_shared_from_this<DisinfectionCtrlS
    */
   void startDisinfection(int loglevel, float roomVol);
   void stopDisinfection();
-  void pauseDisinfection();
-  void continueDisinfection();
 
   int getDisinfectionWorkState();
   int getReplenishingFluidsWorkState();
   int getDrainingWorkState();
 
-  /**
-   * @brief
-   *
-   * @return true
-   * @return false
-   */
-
+  /*******************************************************************************
+   *                                    加液                                     *
+   *******************************************************************************/
   void startReplenishingFluids(int stopatg);
   void stopReplenishingFluids();
-
+  /*******************************************************************************
+   *                                    排液                                     *
+   *******************************************************************************/
   void startDraining();
   void stopDraining();
-
+  /*******************************************************************************
+   *                                    State                                    *
+   *******************************************************************************/
   bool    isDisinfectionRunning();
   int32_t getEstimatedRemainingTimeS();
   string  getDisinfectionID();
@@ -91,17 +117,14 @@ class DisinfectionCtrlService : public enable_shared_from_this<DisinfectionCtrlS
  private:
   string createDisinfectionID();
 
-  void drainingPump_open();
-  void drainingPump_close();
-
-  void replenishingFluidsPump_open();
-  void replenishingFluidsPump_close();
-
-  void sprayLiquidPump_open();
-  void sprayLiquidPump_close();
-
-  void heartingPlate_setPower(bool val);
-  void blower_setPower(bool val);
-  void airCompressor(bool val);
+ private:
+  float getDisinfectionDValue(float ppm);
+
+  void initContext(DisinfectionContext& context, int loglevel, float roomVol);
+  void computeRemainTime(DisinfectionContext& context);
+  void processPreheatState(DisinfectionContext& context);
+  void processDisinfectionState(DisinfectionContext& context);
+  void dumpDisinfectionLogs(DisinfectionContext& context);
+  void finishDisinfection(DisinfectionContext& context);
 };
 }  // namespace iflytop

src/service/disinfection_logs_manager.cpp

@@ -0,0 +1,30 @@
+#include "disinfection_logs_manager.hpp"
+using namespace iflytop;
+using namespace std;
+
+#define LOG_STORGE_PATH "./disinfection_logs/"
+
+DisinfectionLogger::DisinfectionLogger() {}
+DisinfectionLogger::~DisinfectionLogger() {
+  if (m_logfile.is_open()) {
+    m_logfile.close();
+  }
+}
+
+void DisinfectionLogger::initialize(string log_file_name) {  //
+  logger->info("create loggers:{}", log_file_name);
+  m_logfile.open(log_file_name, ios::out | ios::binary | ios::trunc);
+  if (!m_logfile.is_open()) {
+    logger->error("create loggers:{} failed", log_file_name);
+  }
+}
+void DisinfectionLogger::write(string log) { m_logfile.write(log.c_str(), log.size()); }
+
+DisinfectionLogsManager::DisinfectionLogsManager(/* args */) {}
+DisinfectionLogsManager::~DisinfectionLogsManager() {}
+
+shared_ptr<DisinfectionLogger> DisinfectionLogsManager::createNewLogger(string log_file_name) {
+  shared_ptr<DisinfectionLogger> logger = make_shared<DisinfectionLogger>();
+  logger->initialize(fmt::format("{}{}.csv", LOG_STORGE_PATH, log_file_name));
+  return logger;
+}

src/service/disinfection_logs_manager.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "iflytop/core/core.hpp"
+namespace iflytop {
+using namespace std;
+
+class DisinfectionLogger {
+  ENABLE_LOGGER(DisinfectionLogger);
+  ofstream m_logfile;
+
+ public:
+  DisinfectionLogger();
+  ~DisinfectionLogger();
+
+  void initialize(string log_file_name);
+  void write(string log);
+};
+
+class DisinfectionLogsManager {
+  ENABLE_LOGGER(DisinfectionLogsManager);
+
+ public:
+  DisinfectionLogsManager(/* args */);
+  ~DisinfectionLogsManager();
+
+  void initialize(){};
+
+  shared_ptr<DisinfectionLogger> createNewLogger(string log_file_name);
+};
+
+}  // namespace iflytop

src/service/sensor_data_scan.cpp

@@ -1,112 +0,0 @@
-#include "sensor_data_scan.hpp"
-
-using namespace iflytop;
-using namespace std;
-
-SensorDataScan::SensorDataScan() {}
-void SensorDataScan::initialize() { GET_TO_SERVICE(m_zcanHost); }
-#if 0
-模块           板子 硬件ID ID
-空压机-安全电磁阀 3 PC2 0
-空压机-通断电磁阀 3 PC3 1
-鼓风机-安全电磁阀 3 PC4 2
--通断电磁阀      3 PC5 3
-加热片-安全电磁阀 3 PC6 4
--通断电磁阀      3 PC7 5
-#endif
-void SensorDataScan::startScan() {
-  m_workThread.reset(new Thread("SensorDataScan", [this]() {
-    ThisThread thisThread;
-    uint32_t   i = 0;
-
-    int readpressuresensor_id = 1;
-
-    while (!thisThread.getExitFlag()) {
-      /* code */
-      thisThread.sleepForMs(1);
-      i++;
-
-      if (i % 1000 == 0) {
-        m_zcanHost->readadc(0, m_adc_0);
-        m_zcanHost->readadc(1, m_adc_1);
-        m_zcanHost->readadc(2, m_adc_2);
-        // m_zcanHost->readadc(3, m_adc_3);
-        // m_zcanHost->readadc(4, m_adc_4);
-        // m_zcanHost->readadc(5, m_adc_5);
-      }
-
-      if (i % 3000 == 0) {
-        // m_hpp272_data_1
-        m_zcanHost->hpp272_read_c1000(1, m_hpp272_data_1);
-      }
-
-      if (i % 300 == 0) {
-        if (readpressuresensor_id == 5) {
-          readpressuresensor_id = 1;
-        }
-        m_zcanHost->huacheng_pressure_sensor_read_c1005(readpressuresensor_id, m_pressure_sensor_data[readpressuresensor_id]);
-        readpressuresensor_id++;
-      }
-
-      if (i % 100 == 0) {
-        // m_zcanHost->readio(1, m_waterImmersionSensor1);
-        // m_zcanHost->readio(2, m_waterImmersionSensor2);
-      }
-    }
-  }));
-}
-
-int SensorDataScan::getAirCompressor_io1() { return m_zcanHost->read_writeio_state_cache(1); }
-int SensorDataScan::getAirCompressor_io2() { return m_zcanHost->read_writeio_state_cache(2); }
-int SensorDataScan::getAirCompressor_currentValue() { return m_adc_0 * 0.00167 - 1.25; }
-
-int SensorDataScan::getAirBlower_io1() { return m_zcanHost->read_writeio_state_cache(3); }
-int SensorDataScan::getAirBlower_io2() { return m_zcanHost->read_writeio_state_cache(4); }
-int SensorDataScan::getAirBlower_currentValue() { return m_adc_1 * 0.00167 - 1.25; }
-
-// heatingStrip
-int SensorDataScan::getHeatingStrip_io1() { return m_zcanHost->read_writeio_state_cache(5); }
-int SensorDataScan::getHeatingStrip_io2() { return m_zcanHost->read_writeio_state_cache(6); }
-int SensorDataScan::getHeatingStrip_currentValue() { return m_adc_2 * 0.00336 - 2.5; }
-
-int SensorDataScan::getSprinkler_PumpRPM() { return m_zcanHost->pumpctrl_c1004_get_speed_cache(2); }
-int SensorDataScan::getChargingPump_PumpRPM() { return m_zcanHost->pumpctrl_c1004_get_speed_cache(1); }
-
-int SensorDataScan::getDisinfectantVolume_g() {
-  // kpa;
-
-  // logger->info("m_pressure_sensor_data[1].pressure:  {}", m_pressure_sensor_data[1].precision);
-  // logger->info("m_pressure_sensor_data[1].unit:  {}", m_pressure_sensor_data[1].unit);
-  // logger->info("m_pressure_sensor_data[1].value:  {}", m_pressure_sensor_data[1].value);
-
-  float kpa = m_pressure_sensor_data[1].value / 1000.0;
-  int   g   = 2.11 * kpa * 1000;
-
-  // logger->info("g:  {}", g);
-  if (g < 450) { /*零点*/
-    return 0;
-  }
-  // logger->info("pa:  {}", pa);
-  // if (pa < 0) {
-  //   return 0;
-  // }
-  // m（kg）=2.11*P（kPa）
-  // pa = 1;  // TODO 检查传感器异常，则不允许加液
-  return g;
-}
-
-int SensorDataScan::getWaterImmersionSensor1() { return m_waterImmersionSensor1 ? 1 : 0; }
-int SensorDataScan::getWaterImmersionSensor2() { return m_waterImmersionSensor2 ? 1 : 0; }
-
-SensorDataScan::h2o2sensor_data_t SensorDataScan::getH2O2SenSorData1() {
-  SensorDataScan::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;
-  return data;
-}

src/service/sensor_data_scan.hpp

@@ -1,92 +0,0 @@
-//
-// 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"
-
-/**
- * @brief
- *
- * service: SensorDataScan
- *
- * 监听事件:
- * 依赖状态:
- * 依赖服务:
- * 作用:
- *
- */
-
-namespace iflytop {
-using namespace std;
-using namespace core;
-
-class SensorDataScan : public enable_shared_from_this<SensorDataScan> {
-  ENABLE_LOGGER(SensorDataScan);
-
-  unique_ptr<Thread>   m_workThread;
-  shared_ptr<ZCanHost> m_zcanHost;
-
-  //
-  ZCanHost::hpp272_data_t                         m_hpp272_data_1;
-  ZCanHost::huacheng_pressure_sensor_read_c1005_t m_pressure_sensor_data[5];
-
-
-  //
-  bool m_waterImmersionSensor1 = false;  // 漏液检测
-  bool m_waterImmersionSensor2 = false;  // 仓内液体检测
-
-  int m_adc_0 = 0;  //
-  int m_adc_1 = 0;  //
-  int m_adc_2 = 0;
-
- public:
-  SensorDataScan();
-  void initialize();
-  void startScan();
-
- public:
-  int getAirCompressor_io1();
-  int getAirCompressor_io2();
-  int getAirCompressor_currentValue();
-
-  int getAirBlower_io1();
-  int getAirBlower_io2();
-  int getAirBlower_currentValue();
-
-  // heatingStrip
-  int getHeatingStrip_io1();
-  int getHeatingStrip_io2();
-  int getHeatingStrip_currentValue();
-
-  int getSprinkler_PumpRPM();
-  int getChargingPump_PumpRPM();
-
-  int getDisinfectantVolume_g();  // g
-
-  int getWaterImmersionSensor1();
-  int getWaterImmersionSensor2();
-
-  typedef struct {
-    int h2o2;        // ppm
-    int temp;        // 温度
-    int humid;       // 湿度 %RS
-    int saturation;  // 相对饱和度 %RS
-  } h2o2sensor_data_t;
-
-  h2o2sensor_data_t getH2O2SenSorData1();
-};
-}  // namespace iflytop