v2.4.3 | 增加过氧化青传感器上报字段， 重构H2O2传感器信息同步逻辑，

appsrc/appbase/appbase.hpp

@@ -15,4 +15,5 @@
 #include "appbean/device_state.hpp"
 #include "appbase/appbean/h2o2_sensor_data_snapshot.hpp"
 #include "appbase/appbean/air_leak_test_mode.hpp"
-#include "appbase/appbean/project_type_enum.hpp"
+#include "appbase/appbean/project_type_enum.hpp"
+#include "appbase/appbean/h2o2_sensor_type.hpp"

appsrc/appbase/appbean/h2o2_sensor_data_snapshot.hpp

@@ -16,10 +16,10 @@ class H2O2SensorDataSnapshot {
  public:
   vector<bool> isExpired = {};
 
-  vector<float> h2o2       = {};  // ppm
-  vector<float> rh      = {};  // %RH
-  vector<float> temp       = {};  // °C
-  vector<float> rs = {};  // %RS
+  vector<float> h2o2 = {};  // ppm
+  vector<float> rh   = {};  // %RH
+  vector<float> temp = {};  // °C
+  vector<float> rs   = {};  // %RS
 
   float minH2O2       = 0;
   float maxH2O2       = 0;
@@ -27,5 +27,7 @@ class H2O2SensorDataSnapshot {
   float maxSaturation = 0;
 
   int getSensorDataNum() { return h2o2.size(); }
+
+  NLOHMANN_DEFINE_TYPE_INTRUSIVE(H2O2SensorDataSnapshot, isExpired, h2o2, rh, temp, rs, minH2O2, maxH2O2, maxHumid, maxSaturation);
 };
 }  // namespace iflytop

appsrc/appbase/appbean/h2o2_sensor_type.cpp

@@ -0,0 +1,2 @@
+#include "h2o2_sensor_type.hpp"
+H2O2SensorTypeZENUM_IMPL

appsrc/appbase/appbean/h2o2_sensor_type.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include "iflytop/core/components/zenum_template/zenum_template.hpp"
+
+#define H2O2SensorTypeZENUM_IMPL        ZENUM_IMPL(H2O2SensorType, H2O2SensorTypeLIST)
+#define H2O2SensorTypeLIST(type, marco) /**/ \
+  marco(type, Internal)           /**/ \
+      marco(type, WiredExtSensor)       /**/ \
+      marco(type, WirelessExtSensor)    /**/
+
+ZENUM_DECLAR(H2O2SensorType, H2O2SensorTypeLIST);

appsrc/appconfig/basic/zappversion.hpp

@@ -1,3 +1,3 @@
 #pragma once
-#define VERSION      "2.4.2"
+#define VERSION      "2.4.3"
 #define PROJECT_NAME "TRANSMIT_DM"

appsrc/baseservice/db/device_ext_setting_dao.cpp

@@ -40,11 +40,12 @@ DeviceExtSetting DeviceExtSettingDAO::getDeviceExtSetting() {  //
   setting.deviceId                           = get("deviceId", "");
   setting.printerUartPath                    = get("printerUartPath", "/dev/ttyS5");
   setting.dvalueCoefficient                  = get("dvalueCoefficient", 2);
-  setting.projectType                       = get("projectType", "");
+  setting.projectType                        = get("projectType", "");
   setting.h2o2SensorExpireTimeMonth          = get("h2o2SensorExpireTimeMonth", 12);
   setting.deviceType                         = get("deviceType", "");
   setting.emptyThePipeLineTimeS              = get("emptyThePipeLineTimeS", 20);
   setting.emptyingLiquidStorageTankCondtionG = get("emptyingLiquidStorageTankCondtionG", 20);
+  setting.h2o2Sensorh2o2MinVal               = get("h2o2Sensorh2o2MinVal", 20);
   return setting;
 }
 
@@ -63,4 +64,7 @@ void DeviceExtSettingDAO::setDvalueCoefficient(float dvalueCoefficient) { set("d
 void DeviceExtSettingDAO::setH2o2SensorExpireTimeMonth(int32_t h2o2SensorExpireTimeMonth) { set("h2o2SensorExpireTimeMonth", to_string(h2o2SensorExpireTimeMonth)); }
 void DeviceExtSettingDAO::setDeviceType(string deviceType) { set("deviceType", deviceType); }
 void DeviceExtSettingDAO::setEmptyThePipeLineTimeS(int32_t val) { set("emptyThePipeLineTimeS", val); }
-void DeviceExtSettingDAO::setEmptyingLiquidStorageTankCondtionG(int32_t val) { set("emptyingLiquidStorageTankCondtionG", val); }
+void DeviceExtSettingDAO::setEmptyingLiquidStorageTankCondtionG(int32_t val) { set("emptyingLiquidStorageTankCondtionG", val); }
+void DeviceExtSettingDAO::setH2o2Sensorh2o2MinVal(int32_t h2o2Sensorh2o2MinVal) { set("h2o2Sensorh2o2MinVal", to_string(h2o2Sensorh2o2MinVal)); }
+
+int32_t DeviceExtSettingDAO::getH2O2Sensorh2o2MinVal() { return get("h2o2Sensorh2o2MinVal", 10); }

appsrc/baseservice/db/device_ext_setting_dao.hpp

@@ -37,9 +37,9 @@ namespace db {
 
 class DeviceExtSetting {
  public:
-  string deviceId;      // 设备ID
+  string deviceId;     // 设备ID
   string projectType;  // 项目类型,用作逻辑
-  string deviceType;    // 设备类型,只做展示用，不做业务逻辑
+  string deviceType;   // 设备类型,只做展示用，不做业务逻辑
 
   string  canIF;       // can接口
   int32_t canBitrate;  // can波特率
@@ -53,8 +53,10 @@ class DeviceExtSetting {
   int32_t emptyThePipeLineTimeS;               // 清空管路时间
   int32_t emptyingLiquidStorageTankCondtionG;  // 排空储液桶条件(g)
 
+  int32_t h2o2Sensorh2o2MinVal = 10;  // h2o2传感器最小值,单位ppm,小于此值认为是无效数据
+
   NLOHMANN_DEFINE_TYPE_INTRUSIVE(DeviceExtSetting, deviceId, projectType, deviceType, canIF, canBitrate, printerUartPath, dvalueCoefficient, h2o2SensorExpireTimeMonth, emptyThePipeLineTimeS,
-                                 emptyingLiquidStorageTankCondtionG);
+                                 emptyingLiquidStorageTankCondtionG, h2o2Sensorh2o2MinVal);
 };
 
 }  // namespace db
@@ -94,9 +96,13 @@ class DeviceExtSettingDAO : public KeyValDBV2Dao {
   void setDvalueCoefficient(float dvalueCoefficient);
   void setH2o2SensorExpireTimeMonth(int32_t h2o2SensorExpireTimeMonth);
   void setDeviceType(string deviceType);
+  void setH2o2Sensorh2o2MinVal(int32_t h2o2Sensorh2o2MinVal);
 
   void setEmptyThePipeLineTimeS(int32_t val);
   void setEmptyingLiquidStorageTankCondtionG(int32_t val);
+
+
+  int32_t getH2O2Sensorh2o2MinVal();
   // void setTestMode(bool testMode);
 };
 

appsrc/service/app/disinfection_ctrl/disinfection_ctrl_service.cpp

@@ -322,7 +322,7 @@ void DisinfectionCtrlService::pushSnapshot(shared_ptr<DisinfectionStateSnapshot>
  *                                StateMachine                                 *
  *******************************************************************************/
 
-void DisinfectionCtrlService::beforeStateProcess() { s_h2o2Snapshot = dics->getH2O2SensorMgr()->takeSnapshot(); }
+void DisinfectionCtrlService::beforeStateProcess() { s_h2o2Snapshot = h2o2SensorStateSyncService->takeSnapshot(); }
 
 void DisinfectionCtrlService::changeToNextState() {
   /**
@@ -393,8 +393,6 @@ void DisinfectionCtrlService::changeToNextState() {
 
 void DisinfectionCtrlService::processStateIdle(DisinfectionEvent* event) {}
 
-
-
 void DisinfectionCtrlService::processStateInit(DisinfectionEvent* event) {
   if (event->event == kevent_enter_state) {
     /**
@@ -419,7 +417,7 @@ void DisinfectionCtrlService::processStateInit(DisinfectionEvent* event) {
 }
 
 void DisinfectionCtrlService::processStateDehumidificationBeforeDisinfection(DisinfectionEvent* event) {
-  auto h2o2s = dics->getH2O2SensorMgr();
+  auto h2o2s = h2o2SensorStateSyncService;
   if (event->event == kevent_enter_state) {
     tryLogState(true);
     ZASSERT(PORT.isDT100N());

appsrc/service/app/disinfection_ctrl/disinfection_ctrl_service.hpp

@@ -11,9 +11,9 @@
 //
 #include "baseservice/baseservice.hpp"
 #include "disinfection_state_machine.hpp"
-#include "service/hardware/base/h2o2_sensor_data_mgr.hpp"
 #include "service/hardware/device_io_ctrl_service.hpp"
 #include "service/hardware/disinfectant_weight_update_service.hpp"
+#include "service/hardware/h2o2_sensor_state_sync.hpp"
 //
 namespace iflytop {
 using namespace disinfection;
@@ -28,6 +28,8 @@ class DisinfectionCtrlService : public enable_shared_from_this<DisinfectionCtrlS
   } RunType_t;
 
  public:
+  SERVICE(H2O2SensorStateSyncService, h2o2SensorStateSyncService);
+
   shared_ptr<DeviceStateService> ds;
 
   shared_ptr<DeviceIoControlService>          dics;
@@ -96,7 +98,7 @@ class DisinfectionCtrlService : public enable_shared_from_this<DisinfectionCtrlS
   }
   bool isDisinfectionTakeBreak() { return s_isDisinfectionTakeBreak; }
 
-  shared_ptr<H2O2SensorDataSnapshot> getH2O2Snapshot() { return dics->getH2O2SensorMgr()->takeSnapshot(); }
+  shared_ptr<H2O2SensorDataSnapshot> getH2O2Snapshot() { return h2o2SensorStateSyncService->takeSnapshot(); }
 
  private:
   void beforeStateProcess();

appsrc/service/app/disinfection_ctrl_service_ext.hpp

@@ -12,7 +12,7 @@
 #include "baseservice/baseservice.hpp"
 #include "disinfection_ctrl/disinfection_ctrl_service.hpp"
 #include "disinfection_ctrl/disinfection_state_machine.hpp"
-#include "service/hardware/base/h2o2_sensor_data_mgr.hpp"
+#include "service/hardware/h2o2_sensor_state_sync.hpp"
 #include "service/hardware/device_io_ctrl_service.hpp"
 #include "service/hardware/disinfectant_weight_update_service.hpp"
 //

appsrc/service/app_core.cpp

@@ -28,6 +28,7 @@
 #include "equipment_usage_info_mgr_service.hpp"
 #include "service/hardware/sensor_state_sync_service.hpp"
 #include "setting/ext_setting_mgr_service.hpp"
+#include "service/hardware/h2o2_sensor_state_sync.hpp"
 
 // DeviceExtSettingDAO
 
@@ -142,6 +143,8 @@ void AppCore::initialize() {
   BUILD_AND_REG_SERRVICE(DisinfectantWeightUpdateService);
   BUILD_AND_REG_SERRVICE(WarningLightControler);
   BUILD_AND_REG_SERRVICE(SensorStateSyncService);
+  BUILD_AND_REG_SERRVICE(H2O2SensorStateSyncService);
+  
   //
   BUILD_AND_REG_SERRVICE(PipelinePressureControl);
   BUILD_AND_REG_SERRVICE(UDiskMgrService);

appsrc/service/debug_page_test_service.cpp

@@ -1,6 +1,5 @@
 #include "debug_page_test_service.hpp"
 
-#include "appsrc/service/hardware/base/h2o2_sensor_data_mgr.hpp"
 #include "hardware/device_io_ctrl_service.hpp"
 using namespace iflytop;
 void DebugPageTestService::initialize() {
@@ -86,8 +85,19 @@ void DebugPageTestService::startGenFakeH2O2Data(shared_ptr<MsgProcessContext> cx
           float rs   = cache.random[i] ? (rand() % 100) : cache.rs[i];
 
           logger->debug("genFakeH2O2DataThread: h2o2={}, rh={}, temp={}, rs={}", h2o2, rh, temp, rs);
-          H2O2ReportData data;
-          GET_SERVICE(DeviceIoControlService)->getH2O2SensorMgr()->updateH2o2SensorData(i, &data, h2o2, rh, temp, rs);
+          report_h2o2_data_t reportData;
+          reportData.rh   = rh * 10;
+          reportData.h2o2 = h2o2;
+          reportData.temp = temp * 10;  // 温度是整数,乘以10
+          reportData.rs   = rs * 10;    // rs is in %RS, convert to float
+
+          if (i == 0) {
+            h2o2SensorStateSyncService->updateH2o2SensorData(H2O2SensorType::Internal, 1, &reportData);
+          } else if (i == 1) {
+            h2o2SensorStateSyncService->updateH2o2SensorData(H2O2SensorType::WiredExtSensor, 1, &reportData);
+          } else if (i == 2) {
+            h2o2SensorStateSyncService->updateH2o2SensorData(H2O2SensorType::WiredExtSensor, 2, &reportData);
+          }
         }
       }
     }

appsrc/service/debug_page_test_service.hpp

@@ -10,10 +10,12 @@
 #include <vector>
 //
 #include "baseservice/baseservice.hpp"
+#include "service/hardware/h2o2_sensor_state_sync.hpp"
 namespace iflytop {
 class DebugPageTestService : public enable_shared_from_this<DebugPageTestService> {
   THISCLASS(DebugPageTestService);
   unique_ptr<Thread> m_genFakeH2O2DataThread;
+  SERVICE(H2O2SensorStateSyncService, h2o2SensorStateSyncService);
 
  public:
   void initialize();

appsrc/service/front_end_realtime_display_content_mgr.cpp

@@ -6,6 +6,8 @@ using namespace iflytop;
 void FrontEndRealtimeDisplayContentMgr::initialize() {  //
   REG_EXTFN_VOID(readH2O2SensorData, json());
   REG_EXTFN_VOID(readH2O2SensorRawData, json());
+  REG_EXTFN_VOID(readH2O2SensorSnapshot, json());
+  
   //
   stateUpdateThread.reset(new Thread("FERDC-stateUpdateThread", [this]() {
     while (!ThisThread().getExitFlag()) {
@@ -20,35 +22,43 @@ void FrontEndRealtimeDisplayContentMgr::initialize() {  //
 }
 
 json FrontEndRealtimeDisplayContentMgr::readH2O2SensorData() {
-  auto h2o2Mgr = GET_SERVICE(DeviceIoControlService)->getH2O2SensorMgr();
+  auto h2o2SSSS = h2o2SensorStateSyncService;
 
   // h2o2Mgr->getCacheData()
   json sensordata = json::array();
-  if (PORT.getExtH2O2SensorNum() >= 0) {
-    sensordata[0]["h2o2"]     = !h2o2Mgr->isDataExpired(0) ? h2o2Mgr->getCacheData(0)->h2o2 : -1;
-    sensordata[0]["temp"]     = !h2o2Mgr->isDataExpired(0) ? h2o2Mgr->getCacheData(0)->temp : -1;
-    sensordata[0]["rh"]       = !h2o2Mgr->isDataExpired(0) ? h2o2Mgr->getCacheData(0)->rh : -1;
-    sensordata[0]["rs"]       = !h2o2Mgr->isDataExpired(0) ? h2o2Mgr->getCacheData(0)->rs : -1;
-    sensordata[0]["type"]     = "Internal";  // Internal sensor
-    sensordata[0]["sensorId"] = 1;           // Internal sensor
-  }
+  int  i          = 0;
 
+  sensordata[i]["type"]         = H2O2SensorType::Internal;
+  sensordata[i]["sensorId"]     = 1;
+  sensordata[i]["h2o2"]         = h2o2SSSS->getCacheDataCpy(H2O2SensorType::Internal, 1)->h2o2;
+  sensordata[i]["temp"]         = h2o2SSSS->getCacheDataCpy(H2O2SensorType::Internal, 1)->temp;
+  sensordata[i]["rh"]           = h2o2SSSS->getCacheDataCpy(H2O2SensorType::Internal, 1)->rh;
+  sensordata[i]["rs"]           = h2o2SSSS->getCacheDataCpy(H2O2SensorType::Internal, 1)->rs;
+  sensordata[i]["online"]       = h2o2SSSS->getCacheDataCpy(H2O2SensorType::Internal, 1)->isOnline;
+  sensordata[i]["preheartWell"] = h2o2SSSS->getCacheDataCpy(H2O2SensorType::Internal, 1)->preHeatWell;
+
+  i++;
   if (PORT.getExtH2O2SensorNum() >= 1) {
-    sensordata[1]["h2o2"]     = !h2o2Mgr->isDataExpired(1) ? h2o2Mgr->getCacheData(1)->h2o2 : -1;
-    sensordata[1]["temp"]     = !h2o2Mgr->isDataExpired(1) ? h2o2Mgr->getCacheData(1)->temp : -1;
-    sensordata[1]["rh"]       = !h2o2Mgr->isDataExpired(1) ? h2o2Mgr->getCacheData(1)->rh : -1;
-    sensordata[1]["rs"]       = !h2o2Mgr->isDataExpired(1) ? h2o2Mgr->getCacheData(1)->rs : -1;
-    sensordata[1]["type"]     = "WiredExSensor";  // WiredExSensor sensor
-    sensordata[1]["sensorId"] = 1;
+    sensordata[i]["type"]         = H2O2SensorType::WiredExtSensor;
+    sensordata[i]["sensorId"]     = 1;
+    sensordata[i]["h2o2"]         = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 1)->h2o2;
+    sensordata[i]["temp"]         = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 1)->temp;
+    sensordata[i]["rh"]           = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 1)->rh;
+    sensordata[i]["rs"]           = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 1)->rs;
+    sensordata[i]["online"]       = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 1)->isOnline;
+    sensordata[i]["preheartWell"] = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 1)->preHeatWell;
   }
 
+  i++;
   if (PORT.getExtH2O2SensorNum() >= 2) {
-    sensordata[2]["h2o2"]     = !h2o2Mgr->isDataExpired(2) ? h2o2Mgr->getCacheData(2)->h2o2 : -1;
-    sensordata[2]["temp"]     = !h2o2Mgr->isDataExpired(2) ? h2o2Mgr->getCacheData(2)->temp : -1;
-    sensordata[2]["rh"]       = !h2o2Mgr->isDataExpired(2) ? h2o2Mgr->getCacheData(2)->rh : -1;
-    sensordata[2]["rs"]       = !h2o2Mgr->isDataExpired(2) ? h2o2Mgr->getCacheData(2)->rs : -1;
-    sensordata[1]["type"]     = "WiredExSensor";  // WiredExSensor sensor
-    sensordata[1]["sensorId"] = 2;
+    sensordata[i]["type"]         = H2O2SensorType::WiredExtSensor;
+    sensordata[i]["sensorId"]     = 2;
+    sensordata[i]["h2o2"]         = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 2)->h2o2;
+    sensordata[i]["temp"]         = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 2)->temp;
+    sensordata[i]["rh"]           = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 2)->rh;
+    sensordata[i]["rs"]           = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 2)->rs;
+    sensordata[i]["online"]       = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 2)->isOnline;
+    sensordata[i]["preheartWell"] = h2o2SSSS->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 2)->preHeatWell;
   }
 
   json rely;
@@ -60,23 +70,25 @@ json FrontEndRealtimeDisplayContentMgr::readH2O2SensorData() {
 }
 
 void FrontEndRealtimeDisplayContentMgr::readH2O2SensorData(shared_ptr<MsgProcessContext> cxt) { cxt->rely["val"] = readH2O2SensorData(); }
+void FrontEndRealtimeDisplayContentMgr::readH2O2SensorSnapshot(shared_ptr<MsgProcessContext> cxt) {
+  auto h2o2SSSS = h2o2SensorStateSyncService;
+  cxt->rely = *h2o2SSSS->takeSnapshot();
 
-void FrontEndRealtimeDisplayContentMgr::readH2O2SensorRawData(shared_ptr<MsgProcessContext> cxt) {
-  auto h2o2Mgr = GET_SERVICE(DeviceIoControlService)->getH2O2SensorMgr();
+}
 
+void FrontEndRealtimeDisplayContentMgr::readH2O2SensorRawData(shared_ptr<MsgProcessContext> cxt) {
   // h2o2Mgr->getCacheData()
   json sensordata = json::array();
   if (PORT.getExtH2O2SensorNum() >= 0) {
-    sensordata[0] = !h2o2Mgr->isDataExpired(0) ? json(h2o2Mgr->getCacheData(0)->reportData) : json();
+    sensordata[0] = json(h2o2SensorStateSyncService->getCacheDataCpy(H2O2SensorType::Internal, 1)->reportData);
   }
 
   if (PORT.getExtH2O2SensorNum() >= 1) {
-    sensordata[1] = !h2o2Mgr->isDataExpired(1) ? json(h2o2Mgr->getCacheData(1)->reportData) : json();
+    sensordata[1] = json(h2o2SensorStateSyncService->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 1)->reportData);
   }
 
   if (PORT.getExtH2O2SensorNum() >= 2) {
-    sensordata[2] = !h2o2Mgr->isDataExpired(2) ? json(h2o2Mgr->getCacheData(2)->reportData) : json();
+    sensordata[2] = json(h2o2SensorStateSyncService->getCacheDataCpy(H2O2SensorType::WiredExtSensor, 2)->reportData);
   }
-
   cxt->rely["val"] = sensordata;
 }

appsrc/service/front_end_realtime_display_content_mgr.hpp

@@ -10,10 +10,14 @@
 #include <vector>
 //
 #include "baseservice/baseservice.hpp"
+#include "service/hardware/h2o2_sensor_state_sync.hpp"
+
 namespace iflytop {
 class FrontEndRealtimeDisplayContentMgr : public enable_shared_from_this<FrontEndRealtimeDisplayContentMgr> {
   THISCLASS(FrontEndRealtimeDisplayContentMgr);
 
+  SERVICE(H2O2SensorStateSyncService, h2o2SensorStateSyncService);
+
   shared_ptr<DeviceStateService> m_ds;
   unique_ptr<Thread>             stateUpdateThread;
 
@@ -23,6 +27,7 @@ class FrontEndRealtimeDisplayContentMgr : public enable_shared_from_this<FrontEn
  private:
   json readH2O2SensorData();
   void readH2O2SensorData(shared_ptr<MsgProcessContext> cxt);
+  void readH2O2SensorSnapshot(shared_ptr<MsgProcessContext> cxt);
   void readH2O2SensorRawData(shared_ptr<MsgProcessContext> cxt);
 };
 

appsrc/service/hardware/base/can_packet_dumper.hpp

@@ -14,7 +14,7 @@
 /**
  * @brief
  *
- * service: H2O2SensorDataMgr
+ * service: 
  *
  * 监听事件:
  * 依赖状态:

appsrc/service/hardware/base/h2o2_sensor_data_mgr.cpp

@@ -1,169 +0,0 @@
-#include "h2o2_sensor_data_mgr.hpp"
-
-#include "appbase/utils/h2o2_computer/zh2o2_computer.h"
-using namespace iflytop;
-
-bool H2O2SensorDataMgr::isDataExpired(uint8_t sensorId) { return isDataExpired(getSensorDataCache(sensorId)); }
-
-int H2O2SensorDataMgr::getMinH2O2() { return m_minH2O2; }
-int H2O2SensorDataMgr::getMaxH2O2() { return m_maxH2O2; }
-int H2O2SensorDataMgr::getMaxHumid() { return m_maxHumid; }
-int H2O2SensorDataMgr::getMaxSaturation() { return m_maxSaturation; }
-
-shared_ptr<H2O2SensorDataCache> H2O2SensorDataMgr::getCacheData(uint8_t sensorId) { return getSensorDataCache(sensorId); }
-
-shared_ptr<H2O2SensorDataSnapshot> H2O2SensorDataMgr::takeSnapshot() {
-  lock_guard<recursive_mutex>        lock(m_lock);
-  shared_ptr<H2O2SensorDataSnapshot> snapshot = make_shared<H2O2SensorDataSnapshot>();
-  ZASSERT(PORT.getExtH2O2SensorNum() <= 2);
-
-  vector<shared_ptr<H2O2SensorDataCache>> sensorDataList;
-
-  if (PORT.getExtH2O2SensorNum() == 0) {
-    sensorDataList.push_back(getSensorDataCache(0));
-  } else if (PORT.getExtH2O2SensorNum() == 1) {
-    sensorDataList.push_back(getSensorDataCache(0));
-    sensorDataList.push_back(getSensorDataCache(1));
-  } else if (PORT.getExtH2O2SensorNum() == 2) {
-    sensorDataList.push_back(getSensorDataCache(0));
-    sensorDataList.push_back(getSensorDataCache(1));
-    sensorDataList.push_back(getSensorDataCache(2));
-  }
-
-  for (auto& sensorData : sensorDataList) {
-    auto sdata = sensorData;
-    snapshot->isExpired.push_back(isDataExpired(sdata));
-    if (isDataExpired(sdata)) {
-      snapshot->h2o2.push_back(0);
-      snapshot->rh.push_back(0);
-      snapshot->temp.push_back(0);
-      snapshot->rs.push_back(0);
-    } else {
-      snapshot->h2o2.push_back(sdata->h2o2);
-      snapshot->rh.push_back(sdata->rh);
-      snapshot->temp.push_back(sdata->temp);
-      snapshot->rs.push_back(sdata->rs);
-    }
-  }
-
-  snapshot->maxH2O2       = m_maxH2O2;
-  snapshot->minH2O2       = m_minH2O2;
-  snapshot->maxHumid      = m_maxHumid;
-  snapshot->maxSaturation = m_maxSaturation;
-  return snapshot;
-}
-
-bool H2O2SensorDataMgr::isDataExpired(shared_ptr<H2O2SensorDataCache> data) {
-  if (zsys_haspassedms(data->updatetime) > 10 * 1000) return true;
-  if (data->updatetime == 0) return true;
-
-  return false;
-}
-shared_ptr<H2O2SensorDataCache> H2O2SensorDataMgr::getSensorDataCache(uint8_t sensorId) {
-  lock_guard<recursive_mutex> lock(m_lock);
-
-  for (auto& sensor_data : m_h2o2SensorDataList) {
-    if (sensor_data->sensorId == sensorId) {
-      return sensor_data;
-    }
-  }
-  auto sensor_data      = make_shared<H2O2SensorDataCache>();
-  sensor_data->sensorId = sensorId;
-  m_h2o2SensorDataList.push_back(sensor_data);
-  return sensor_data;
-}
-
-void H2O2SensorDataMgr::convertH2o2Data(report_h2o2_data_t* from, H2O2ReportData* to) {
-  to->sensor_error  = from->sensor_error;
-  to->h2o2          = from->h2o2;
-  to->rh            = from->rh;
-  to->temp          = from->temp;
-  to->rs            = from->rs;
-  to->h2o2adc       = from->h2o2adc;
-  to->df_ptemp      = from->df_ptemp;
-  to->ah            = from->ah;
-  to->mr            = from->mr;
-  to->wet_bulb_temp = from->wet_bulb_temp;
-  to->enthalpy      = from->enthalpy;
-}
-
-void H2O2SensorDataMgr::updateH2o2SensorData(uint8_t sensorId, report_h2o2_data_t* _h2o2data) {
-  lock_guard<recursive_mutex> lock(m_lock);
-  H2O2ReportData              h2o2data;
-
-  convertH2o2Data(_h2o2data, &h2o2data);
-
-  // 打印10次日志,以后的调试通过前端读取获取
-  static int logcnt = 0;
-  logcnt++;
-
-  if (logcnt < 10 || GET_SERVICE(DeviceStateService)->getDeviceState() == DeviceState::Disinfection) {
-    logger->info("update h2o2 : {} {}", sensorId, json(h2o2data).dump());
-  } else {
-    logger->debug("update h2o2 : {} {}", sensorId, json(h2o2data).dump());
-  }
-
-  if (zsteady_clock().gets() > SENSOR_PREHEART_TIME_S) {
-    float h2o2 = h2o2data.h2o2;
-    float temp = h2o2data.temp / 10.0;
-    float rh   = h2o2data.rh / 10.0;
-    float rs   = 0;
-    if (h2o2data.rs == 0) {
-      rs = zh2o2_compute_rs(h2o2, zh2o2_t2k(temp), rh, AIR_PRESSURE);
-    }
-    if (h2o2 < 30) {
-      h2o2 = 0;
-    }
-    updateH2o2SensorData(sensorId, &h2o2data, h2o2, rh, temp, rs);
-  } else {
-    float h2o2 = 0;
-    float temp = h2o2data.temp / 10.0;
-    float rh   = 0;
-    float rs   = 0;
-    updateH2o2SensorData(sensorId, &h2o2data, h2o2, rh, temp, rs);
-  }
-}
-
-void H2O2SensorDataMgr::updateH2o2SensorData(uint8_t sensorId, H2O2ReportData* reportdata, float h2o2, float rh, float temp, float rs) {
-  lock_guard<recursive_mutex> lock(m_lock);
-
-  auto dataCache        = getSensorDataCache(sensorId);
-  dataCache->h2o2       = h2o2;
-  dataCache->temp       = temp;
-  dataCache->rh         = rh;
-  dataCache->rs         = rs;
-  dataCache->updatetime = zsys_get_ticket();
-  dataCache->reportData = *reportdata;
-  statisticsSensorData();
-}
-
-void H2O2SensorDataMgr::statisticsSensorData() {
-  lock_guard<recursive_mutex> lock(m_lock);
-
-  m_minH2O2       = -1;
-  m_maxH2O2       = 0;
-  m_maxHumid      = 0;
-  m_maxSaturation = 0;
-
-  for (auto& sensor_data : m_h2o2SensorDataList) {
-    if (isDataExpired(sensor_data)) {
-      continue;
-    }
-
-    if (m_minH2O2 == -1) m_minH2O2 = sensor_data->h2o2;
-
-    if (sensor_data->h2o2 < m_minH2O2) {
-      m_minH2O2 = sensor_data->h2o2;
-    }
-    if (sensor_data->h2o2 > m_maxH2O2) {
-      m_maxH2O2 = sensor_data->h2o2;
-    }
-    if (sensor_data->rh > m_maxHumid) {
-      m_maxHumid = sensor_data->rh;
-    }
-    if (sensor_data->rs > m_maxSaturation) {
-      m_maxSaturation = sensor_data->rs;
-    }
-  }
-  // logger->info("statisticsSensorData: minH2O2 = {}, maxH2O2 = {}, maxHumid = {}, maxSaturation = {}", m_minH2O2, m_maxH2O2, m_maxHumid, m_maxSaturation);
-}

appsrc/service/hardware/device_io_ctrl_service.cpp

@@ -179,17 +179,15 @@ int DeviceIoControlService::processReportMsg(uint8_t from, uint8_t *hex, uint32_
   if (DS->isTestMode()) return 0;
   tdcan_frame_t *packet = (tdcan_frame_t *)hex;
 
-  // logger->warn(".................................");
-
   if (packet->fnid == kreport_h2o2_sensor_data) {
     report_h2o2_data_t *h2o2data = (report_h2o2_data_t *)packet->params;
-    int                 sensorId = 0;
-    if (from < 100) {
-      sensorId = 0;
+    if (from == 2 || from == 3) {
+      signalOnReport(H2O2SensorType::Internal, 1, h2o2data);
     } else {
-      sensorId = from - 100;
+      signalOnReport(H2O2SensorType::WiredExtSensor, from - 100, h2o2data);
     }
-    m_h2o2SensorDataMgr->updateH2o2SensorData(sensorId, h2o2data);
+
+    // m_h2o2SensorDataMgr->updateH2o2SensorData(sensorId, h2o2data);
   } else if (packet->fnid == kreport_heatpacket_pong) {
     report_heatpacket_data_t *ack = (report_heatpacket_data_t *)packet->params;
     processHeartReportMsg(from, ack);

appsrc/service/hardware/device_io_ctrl_service.hpp

@@ -12,7 +12,6 @@
 #include "baseservice/baseservice.hpp"
 //
 #include "base/can_packet_dumper.hpp"
-#include "base/h2o2_sensor_data_mgr.hpp"
 
 /**
  * @brief
@@ -29,15 +28,17 @@
 namespace iflytop {
 using namespace std;
 using namespace core;
+using namespace nod;
 
 class DeviceIoControlService : public enable_shared_from_this<DeviceIoControlService> {
   THISCLASS(DeviceIoControlService);
 
  private:
   unique_ptr<WorkQueue> m_workQueue;
+  unique_ptr<Thread>    heartThread;
 
-  shared_ptr<H2O2SensorDataMgr> m_h2o2SensorDataMgr = make_shared<H2O2SensorDataMgr>();
-  unique_ptr<Thread>            heartThread;
+ public:
+  nod::signal<void(H2O2SensorType type, int sensorid, report_h2o2_data_t *sensordata)> signalOnReport;
 
  public:
   void initialize();
@@ -113,7 +114,7 @@ class DeviceIoControlService : public enable_shared_from_this<DeviceIoControlSer
   int SprayPumpPostPS_readPa();      // pa
   int AddLiquidPumpPostPS_readPa();  // pa
 
-  shared_ptr<H2O2SensorDataMgr> getH2O2SensorMgr() { return m_h2o2SensorDataMgr; }
+  // shared_ptr<H2O2SensorDataMgr> getH2O2SensorMgr() { return m_h2o2SensorDataMgr; }
 
   /**
    * @brief 液路选择器
@@ -130,7 +131,7 @@ class DeviceIoControlService : public enable_shared_from_this<DeviceIoControlSer
    * 1:低液位
    * 2:中液位
    * 3:高液位
-   * 
+   *
    */
   int LiquidLevelSensor_getLevel();
 

appsrc/service/hardware/disinfectant_weight_update_service.hpp

@@ -13,7 +13,6 @@
 #include "device_io_ctrl_service.hpp"
 //
 #include "base/can_packet_dumper.hpp"
-#include "base/h2o2_sensor_data_mgr.hpp"
 //
 #include "appcomponents/algo/moving_average_filter.hpp"
 /**

appsrc/service/hardware/h2o2_sensor_state_sync.cpp

@@ -0,0 +1,194 @@
+#include "h2o2_sensor_state_sync.hpp"
+
+#include "appbase/utils/h2o2_computer/zh2o2_computer.h"
+using namespace iflytop;
+
+void H2O2SensorStateSyncService::initialize() {
+  m_h2o2SensorStateUpdateThread.reset(new Thread("H2O2SensorStateUpdateThread", [this]() {
+    ThisThread thisThread;
+    while (!thisThread.getExitFlag()) {
+      thisThread.sleepForMs(10 * 1000);
+      updateH2o2SensorState();
+    }
+  }));
+
+  deviceIoControlService->signalOnReport.connect([this](H2O2SensorType type, int sensorid, report_h2o2_data_t* sensordata) {  //
+    updateH2o2SensorData(type, sensorid, sensordata);
+  });
+}
+
+void H2O2SensorStateSyncService::updateH2o2SensorData(H2O2SensorType type, int sensorId, report_h2o2_data_t* sensordata) {
+  lock_guard<recursive_mutex> lock(m_lock);
+
+  H2O2ReportData                  h2o2rRportData = toH2O2ReportData(sensordata);
+  shared_ptr<H2O2SensorDataCache> h2o2data       = findDataCache(type, sensorId);
+
+  // 打印10次日志,以后的调试通过前端读取获取
+  static int logcnt = 0;
+  logcnt++;
+
+  if (logcnt < 10 || GET_SERVICE(DeviceStateService)->getDeviceState() == DeviceState::Disinfection) {
+    logger->info("update h2o2 : {} {}", sensorId, json(h2o2rRportData).dump());
+  } else {
+    logger->debug("update h2o2 : {} {}", sensorId, json(h2o2rRportData).dump());
+  }
+
+  float h2o2 = h2o2rRportData.h2o2;
+  float temp = h2o2rRportData.temp / 10.0;
+  float rh   = h2o2rRportData.rh / 10.0;
+  float rs   = 0;
+  if (h2o2rRportData.rs == 0) {
+    rs = zh2o2_compute_rs(h2o2, zh2o2_t2k(temp), rh, AIR_PRESSURE);
+  } else {
+    rs = h2o2rRportData.rs / 10.0;  // rs is in %RS, convert to float
+  }
+  if (h2o2 < DeviceExtSettingDAO::ins()->getH2O2Sensorh2o2MinVal()) {
+    h2o2 = 0;  // 如果H2O2小于10ppm,则认为是无效数据
+  }
+
+  // 更新数据
+  h2o2data->h2o2       = h2o2;
+  h2o2data->temp       = temp;
+  h2o2data->rh         = rh;
+  h2o2data->rs         = rs;
+  h2o2data->reportData = h2o2rRportData;  // 记录报告数据
+  if (!h2o2data->isOnline) {
+    logger->info("H2O2 sensor {} is online, update time: {}", sensorId, zsys_get_ticket());
+    h2o2data->isOnline   = true;
+    h2o2data->onlineTime = zsys_get_ticket();
+  }
+  h2o2data->updatetime = zsys_get_ticket();
+  statisticsSensorData();
+}
+
+void H2O2SensorStateSyncService::updateH2o2SensorState() {  //
+  lock_guard<recursive_mutex> lock(m_lock);
+  int64_t                     now = zsys_get_ticket();
+  for (auto& sensor_data : m_h2o2SensorDataList) {
+    if (sensor_data->isOnline) {
+      if (now - sensor_data->updatetime > 1000 * 60 * 1) {  // 超过5分钟没有更新数据,则认为离线
+        sensor_data->isOnline    = false;
+        sensor_data->h2o2        = -1;
+        sensor_data->rh          = -1;
+        sensor_data->temp        = -1;
+        sensor_data->rs          = -1;
+        sensor_data->preHeatWell = false;
+        sensor_data->updatetime  = 0;
+        logger->warn("H2O2 sensor {} is offline, last update time: {}", sensor_data->sensorId, sensor_data->updatetime);
+        statisticsSensorData();
+      } else {
+        if (!sensor_data->preHeatWell) {
+          // if (now - sensor_data->onlineTime >= 5 * 60 * 1000) {
+          if (zsteady_clock().gets() > SENSOR_PREHEART_TIME_S) {
+            sensor_data->preHeatWell = true;  // 如果在线时间超过5分钟,则认为预热完成
+            logger->info("H2O2 sensor {} preheat well", sensor_data->sensorId);
+            statisticsSensorData();
+          }
+        }
+      }
+    }
+  }
+}
+shared_ptr<H2O2SensorDataCache> H2O2SensorStateSyncService::getCacheDataCpy(H2O2SensorType type, uint8_t sensorId) {
+  lock_guard<recursive_mutex>     lock(m_lock);
+  auto                            sensor_data     = findDataCache(type, sensorId);
+  shared_ptr<H2O2SensorDataCache> sensor_data_cpy = make_shared<H2O2SensorDataCache>();
+  *sensor_data_cpy                                = *sensor_data;  // 深拷贝
+  return sensor_data_cpy;
+}
+
+shared_ptr<H2O2SensorDataSnapshot> H2O2SensorStateSyncService::takeSnapshot() {
+  lock_guard<recursive_mutex>        lock(m_lock);
+  shared_ptr<H2O2SensorDataSnapshot> snapshot = make_shared<H2O2SensorDataSnapshot>();
+  ZASSERT(PORT.getExtH2O2SensorNum() <= 2);
+
+  vector<shared_ptr<H2O2SensorDataCache>> sensorDataList;
+
+  if (PORT.getExtH2O2SensorNum() == 0) {
+    sensorDataList.push_back(findDataCache(H2O2SensorType::Internal, 1));
+  } else if (PORT.getExtH2O2SensorNum() == 1) {
+    sensorDataList.push_back(findDataCache(H2O2SensorType::Internal, 1));
+    sensorDataList.push_back(findDataCache(H2O2SensorType::WiredExtSensor, 1));
+  } else if (PORT.getExtH2O2SensorNum() == 2) {
+    sensorDataList.push_back(findDataCache(H2O2SensorType::Internal, 1));
+    sensorDataList.push_back(findDataCache(H2O2SensorType::WiredExtSensor, 2));
+    sensorDataList.push_back(findDataCache(H2O2SensorType::WiredExtSensor, 3));
+  }
+
+  for (auto& sensorData : sensorDataList) {
+    auto sdata = sensorData;
+    snapshot->isExpired.push_back(!sdata->isOnline);
+    snapshot->h2o2.push_back(sdata->h2o2);
+    snapshot->rh.push_back(sdata->rh);
+    snapshot->temp.push_back(sdata->temp);
+    snapshot->rs.push_back(sdata->rs);
+  }
+
+  snapshot->maxH2O2       = m_maxH2O2;
+  snapshot->minH2O2       = m_minH2O2;
+  snapshot->maxHumid      = m_maxHumid;
+  snapshot->maxSaturation = m_maxSaturation;
+  return snapshot;
+}
+
+void H2O2SensorStateSyncService::statisticsSensorData() {
+  lock_guard<recursive_mutex> lock(m_lock);
+
+  m_minH2O2       = -1;
+  m_maxH2O2       = 0;
+  m_maxHumid      = 0;
+  m_maxSaturation = 0;
+
+  for (auto& sensor_data : m_h2o2SensorDataList) {
+    if (!sensor_data->isOnline) {
+      continue;
+    }
+
+    if (m_minH2O2 == -1) m_minH2O2 = sensor_data->h2o2;
+
+    if (sensor_data->h2o2 < m_minH2O2) {
+      m_minH2O2 = sensor_data->h2o2;
+    }
+    if (sensor_data->h2o2 > m_maxH2O2) {
+      m_maxH2O2 = sensor_data->h2o2;
+    }
+    if (sensor_data->rh > m_maxHumid) {
+      m_maxHumid = sensor_data->rh;
+    }
+    if (sensor_data->rs > m_maxSaturation) {
+      m_maxSaturation = sensor_data->rs;
+    }
+  }
+}
+
+H2O2ReportData H2O2SensorStateSyncService::toH2O2ReportData(report_h2o2_data_t* from) {
+  H2O2ReportData to;
+  to.sensor_error  = from->sensor_error;
+  to.h2o2          = from->h2o2;
+  to.rh            = from->rh;
+  to.temp          = from->temp;
+  to.rs            = from->rs;
+  to.h2o2adc       = from->h2o2adc;
+  to.df_ptemp      = from->df_ptemp;
+  to.ah            = from->ah;
+  to.mr            = from->mr;
+  to.wet_bulb_temp = from->wet_bulb_temp;
+  to.enthalpy      = from->enthalpy;
+  return to;
+}
+
+shared_ptr<H2O2SensorDataCache> H2O2SensorStateSyncService::findDataCache(H2O2SensorType type, uint8_t sensorId) {
+  lock_guard<recursive_mutex> lock(m_lock);
+
+  for (auto& sensor_data : m_h2o2SensorDataList) {
+    if (sensor_data->sensorId == sensorId && sensor_data->type.eq(type.getId())) {
+      return sensor_data;
+    }
+  }
+  auto sensor_data         = make_shared<H2O2SensorDataCache>();
+  sensor_data->sensorId    = sensorId;
+  sensor_data->type        = type;
+  sensor_data->preHeatWell = false;
+  m_h2o2SensorDataList.push_back(sensor_data);
+  return sensor_data;
+}

appsrc/service/hardware/base/h2o2_sensor_data_mgr.hpp → appsrc/service/hardware/h2o2_sensor_state_sync.hpp

@@ -12,11 +12,13 @@
 
 //
 #include "baseservice/baseservice.hpp"
+#include "baseservice/db/device_ext_setting_dao.hpp"
+#include "device_io_ctrl_service.hpp"
 
 /**
  * @brief
  *
- * service: H2O2SensorDataMgr
+ * service: H2O2SensorStateSyncService
  *
  * 监听事件:
  * 依赖状态:
@@ -49,8 +51,14 @@ class H2O2ReportData {
 
 class H2O2SensorDataCache {
  public:
-  uint8_t sensorId   = 0;
+  H2O2SensorType type     = H2O2SensorType::Internal;  // Sensor type
+  uint8_t        sensorId = 0;
+
   int64_t updatetime = 0;
+  int64_t onlineTime = 0;
+
+  bool isOnline    = false;
+  bool preHeatWell = false;
 
   float h2o2 = -1;  // ppm
   float rh   = -1;  // %RH
@@ -60,12 +68,15 @@ class H2O2SensorDataCache {
   H2O2ReportData reportData;
 };
 
-class H2O2SensorDataMgr : public enable_shared_from_this<H2O2SensorDataMgr> {
-  THISCLASS(H2O2SensorDataMgr);
+class H2O2SensorStateSyncService : public enable_shared_from_this<H2O2SensorStateSyncService> {
+  THISCLASS(H2O2SensorStateSyncService);
 
-  recursive_mutex m_lock;
+  SERVICE(DeviceIoControlService, deviceIoControlService);
+  
 
   list<shared_ptr<H2O2SensorDataCache>> m_h2o2SensorDataList;
+  unique_ptr<Thread>                    m_h2o2SensorStateUpdateThread;
+  recursive_mutex                       m_lock;
 
   float m_minH2O2       = 0;
   float m_maxH2O2       = 0;
@@ -73,26 +84,24 @@ class H2O2SensorDataMgr : public enable_shared_from_this<H2O2SensorDataMgr> {
   float m_maxSaturation = 0;
 
  public:
-  bool isDataExpired(uint8_t sensorId);
+  void initialize();
 
-  shared_ptr<H2O2SensorDataCache>    getCacheData(uint8_t sensorId);
   shared_ptr<H2O2SensorDataSnapshot> takeSnapshot();
+  shared_ptr<H2O2SensorDataCache> getCacheDataCpy(H2O2SensorType type, uint8_t sensorId);
 
-  int getMinH2O2();
-  int getMaxH2O2();
-  int getMaxHumid();
-  int getMaxSaturation();
-
- public:
-  void convertH2o2Data(report_h2o2_data_t* h2o2data, H2O2ReportData* reportData);
-
-  void updateH2o2SensorData(uint8_t sensorId, report_h2o2_data_t* h2o2data);
-  void updateH2o2SensorData(uint8_t sensorId, H2O2ReportData* reportdata, float h2o2, float rh, float temp, float rs);
+  int getMinH2O2() { return m_minH2O2; }
+  int getMaxH2O2() { return m_maxH2O2; }
+  int getMaxHumid() { return m_maxHumid; }
+  int getMaxSaturation() { return m_maxSaturation; }
+  void updateH2o2SensorData(H2O2SensorType type, int sensorid, report_h2o2_data_t* sensordata);
 
  private:
-  shared_ptr<H2O2SensorDataCache> getSensorDataCache(uint8_t sensorId);
+  void updateH2o2SensorState();
 
+ private:
+  H2O2ReportData                  toH2O2ReportData(report_h2o2_data_t* h2o2data);
+  shared_ptr<H2O2SensorDataCache> findDataCache(H2O2SensorType type, uint8_t sensorId);
   void statisticsSensorData();
-  bool isDataExpired(shared_ptr<H2O2SensorDataCache> data);
+
 };
 }  // namespace iflytop

appsrc/service/hardware/sensor_state_sync_service.hpp

@@ -13,7 +13,6 @@
 #include "device_io_ctrl_service.hpp"
 //
 #include "base/can_packet_dumper.hpp"
-#include "base/h2o2_sensor_data_mgr.hpp"
 //
 #include "appcomponents/algo/moving_average_filter.hpp"
 
@@ -38,7 +37,6 @@ class SensorStateSyncService : public enable_shared_from_this<SensorStateSyncSer
 
   unique_ptr<Thread>                 updateThread;
   shared_ptr<DeviceIoControlService> deviceIoControlService;
-shared_ptr<H2O2SensorDataMgr> h2o2SensorDataMgr;
 
   float m_airCompressorCurrent = 0;
   float m_blowerCurrent        = 0;

appsrc/service/hardware/warning_light_controler.hpp

@@ -13,7 +13,6 @@
 #include "device_io_ctrl_service.hpp"
 //
 #include "base/can_packet_dumper.hpp"
-#include "base/h2o2_sensor_data_mgr.hpp"
 //
 #include "appcomponents/algo/moving_average_filter.hpp"
 /**