update

service/disinfection_ctl_service.cpp

@@ -49,22 +49,12 @@ static bool zfeq(float a, float b, float eps = 0.01) {
   return false;
 }
 
-static string format_zsystem_tp(zsystem_tp tp) {
-  time_t    time = system_clock().to_time_t(tp);
-  struct tm tm   = {0};
-  localtime_r(&time, &tm);
-  return fmt::format("{:0>4}-{:0>2}-{:0>2} {:0>2}:{:0>2}:{:0>2}", tm.tm_year + 1900,  //
-                     tm.tm_mon + 1,                                                   //
-                     tm.tm_mday,                                                      //
-                     tm.tm_hour,                                                      //
-                     tm.tm_min, tm.tm_sec);
-}
-
 DisinfectionCtrlService::DisinfectionCtrlService() {}
 void DisinfectionCtrlService::initialize() {
   GET_TO_SERVICE(m_deviceIoControlService);
   GET_TO_SERVICE(m_dbService);
   GET_TO_SERVICE(m_disinfectionLogsManager);
+  GET_TO_SERVICE(m_disinfectionPrinterService);
 
   m_deviceIoControlService->drainingPump_close();
   m_deviceIoControlService->replenishingFluidsPump_close();
@@ -209,6 +199,25 @@ void DisinfectionCtrlService::dumpDisinfectionLogsToCSV(DisinfectionContext& con
 #endif
 }
 
+void DisinfectionCtrlService::pushDisinfectionPrinterTask(DisinfectionContext& context) {  //
+  shared_ptr<DisinfectionPrinterTask> task = make_shared<DisinfectionPrinterTask>();
+  auto                                ds   = GET_SERVICE(DeviceStateService);
+  auto                                dio  = m_deviceIoControlService;
+
+  task->start_tp          = context.start_tp;
+  task->complete_tp       = context.complete_tp;
+  task->stateSnapshotList = context.stateSnapshotList;
+  task->disinfectantUsage = context.beforeDisinfectantVolume_g - context.afterDisinfectantVolume_g;
+  task->disinfection_id   = context.m_disinfectionID;
+  task->usr               = ds->getLoginUid();
+
+  task->targetLog = context.cfg_targetLoglevel;
+  task->actualLog = context.state_now_loglevel;
+
+  task->disinfectantVolume = dio->getDisinfectantVolume_g();
+  m_disinfectionPrinterService->pushPrintTask(task);
+}
+
 void DisinfectionCtrlService::log(DisinfectionContext& context) {
 #if (defined PROJECT_TYPE_LARGE_SPACE_DISINFECTION) || (defined PROJECT_TYPE_SMALL_SPACE_DISINFECTION)
 
@@ -284,19 +293,16 @@ void DisinfectionCtrlService::initContext(DisinfectionContext& context,
   logger->info(" pre_heat_time_s {}", context.pre_heat_time_s);
   logger->info("");
 
-  // state_remaintime            = loglevel * 20 * 60;  // 计算总的加热时间
   context.state_remaintime   = context.pre_heat_time_s + loglevel * 90 * 60;  // 计算总的加热时间
   m_disinfectionWorkState    = 1;
   context.cfg_targetLoglevel = loglevel;
   context.state_now_loglevel = 0;
-  // m_context.m_preheatFlag  = true;
-  m_context.state_dvalue = 0;
-  // m_context.stopedflag     = false;
+  m_context.state_dvalue     = 0;
 
   m_context.m_state = kstate_preheat;
 
-  m_context.disinfection_start_tp        = zsystem_clock().now();
-  m_context.disinfection_start_steady_tp = zsteady_clock().now();
+  m_context.start_tp        = zsystem_clock().now();
+  m_context.start_steady_tp = zsteady_clock().now();
   for (int i = 0; i < MAX_H2O2_SENSOR_NUM; i++) {
     m_context.h2o2[i]       = 0;
     m_context.humid[i]      = 0;
@@ -315,8 +321,6 @@ void DisinfectionCtrlService::initContext(DisinfectionContext& context,
   m_deviceIoControlService->warningLightCtrl(0, 0, 1, 0);
   m_deviceIoControlService->heartingPlate_setPower(true);
   context.csvlogger = createCSVLogger(context.m_disinfectionID);
-
-  m_context.stoped_by_usr = false;
 }
 
 void DisinfectionCtrlService::finishDisinfection(DisinfectionContext& context) {
@@ -337,11 +341,10 @@ void DisinfectionCtrlService::finishDisinfection(DisinfectionContext& context) {
   m_disinfectionWorkState = 3;
 
   m_deviceIoControlService->warningLightCtrl(0, 1, 0, 0);
-  context.csvlogger = nullptr;
 }
 
 void DisinfectionCtrlService::processPreheatState(DisinfectionContext& context) {
-  int hasstarttime = zsteady_clock().elapsedTimeS(context.disinfection_start_steady_tp);
+  int hasstarttime = zsteady_clock().elapsedTimeS(context.start_steady_tp);
 
   // logger->info("preheat {}", context.m_disinfectionID);
   if ((context.m_state == kstate_preheat && hasstarttime > m_context.pre_heat_time_s)) {
@@ -478,19 +481,19 @@ void DisinfectionCtrlService::disinfectionLoop(bool& breakflag) {
   }
 
   if (breakflag) {
-    m_context.disinfection_complete_tp  = zsystem_clock().now();
+    m_context.complete_tp               = zsystem_clock().now();
     m_context.afterDisinfectantVolume_g = m_deviceIoControlService->getDisinfectantVolume_g();
     if (m_context.m_state != kstate_finished) {
-      m_context.m_state       = kstate_finished;
-      m_context.stoped_by_usr = true;
+      m_context.m_state = kstate_finished;
     }
     m_disinfectionWorkState = 0;
-
-    finishDisinfection(m_context);
     takeStateSnapshot(m_context);
     dumpDisinfectionLogsToCSV(m_context);
     log(m_context);
-    printfDisinfectionContextResult();
+    pushDisinfectionPrinterTask(m_context);
+    finishDisinfection(m_context);
+    m_context.csvlogger = nullptr;
+
   } else {
     if (forcelog || zsteady_clock().elapsedTimeS(m_context.state_lastlog_tp) > DVALUE_COMPUTEPERIOD_TIME_S) {
       m_context.state_lastlog_tp = zsteady_clock().now();
@@ -549,11 +552,6 @@ void DisinfectionCtrlService::startDisinfection(int loglevel,              //
   }));
   //
 }
-
-void DisinfectionCtrlService::printfDisinfectionContextResult() {}
-
-int DisinfectionCtrlService::getDisinfectionWorkState() { return m_context.m_state; }
-
 void DisinfectionCtrlService::stopDisinfection() {
   lock_guard<recursive_mutex> lock(lock_);
   if (m_disinfectionThread) {
@@ -562,8 +560,11 @@ void DisinfectionCtrlService::stopDisinfection() {
   }
 }
 
+
+int DisinfectionCtrlService::getDisinfectionWorkState() { return m_context.m_state; }
+
+
 int32_t DisinfectionCtrlService::getEstimatedRemainingTimeS() {
-  lock_guard<recursive_mutex> lock(lock_);
   if (m_context.m_state == kstate_preheat) {
     return getPreHeatRaminTimeS();
   } else if (m_context.m_state == kstate_disinfection) {
@@ -577,10 +578,9 @@ int32_t DisinfectionCtrlService::getEstimatedRemainingTimeS() {
   }
 }
 int32_t DisinfectionCtrlService::getPreHeatRaminTimeS() {
-  lock_guard<recursive_mutex> lock(lock_);
-  int32_t                     remaintime = 0;
+  int32_t remaintime = 0;
   if (m_context.m_state == kstate_preheat) {
-    remaintime = m_context.pre_heat_time_s - zsteady_clock().elapsedTimeS(m_context.disinfection_start_steady_tp);
+    remaintime = m_context.pre_heat_time_s - zsteady_clock().elapsedTimeS(m_context.start_steady_tp);
     if (remaintime < 0) {
       remaintime = 0;
     }
@@ -591,11 +591,9 @@ int32_t DisinfectionCtrlService::getPreHeatRaminTimeS() {
 }
 
 string DisinfectionCtrlService::getDisinfectionID() {
-  lock_guard<recursive_mutex> lock(lock_);
   return m_context.m_disinfectionID;
 }
 bool DisinfectionCtrlService::isPreheatState() {
-  lock_guard<recursive_mutex> lock(lock_);
   return m_context.m_state == kstate_preheat;
 }
 
@@ -789,6 +787,6 @@ void DisinfectionCtrlService::takeStateSnapshot(DisinfectionContext& context) {
   snapshot->max_humid      = cx.max_humid;
   snapshot->max_saturation = cx.max_saturation;
   snapshot->state          = cx.m_state;
-
+  snapshot->dloglevel      = cx.state_now_loglevel;
   cx.stateSnapshotList.push_back(snapshot);
 }

service/disinfection_ctl_service.hpp

@@ -20,6 +20,7 @@
 #include "iflytop/components/zcanreceiver/zcanhost.hpp"
 #include "iflytop/core/core.hpp"
 #include "service/device_io_control_service.hpp"
+#include "service/disinfection_printer_service.hpp"
 #include "utils/dvalue_computer.hpp"
 #include "zservice_container/zservice_container.hpp"
 /**
@@ -43,15 +44,16 @@ class DisinfectionCtrlService : public enable_shared_from_this<DisinfectionCtrlS
  private:
   recursive_mutex lock_;
 
-  unique_ptr<Thread>                   m_disinfectionThread;
-  shared_ptr<IF_DeviceIoContrlService> m_deviceIoControlService;
-  shared_ptr<DBService>                m_dbService;
-  shared_ptr<DisinfectionLogsManager>  m_disinfectionLogsManager;
-  DValueComputer                       m_dvalueComputer;
+  unique_ptr<Thread>                     m_disinfectionThread;
+  shared_ptr<IF_DeviceIoContrlService>   m_deviceIoControlService;
+  shared_ptr<DBService>                  m_dbService;
+  shared_ptr<DisinfectionLogsManager>    m_disinfectionLogsManager;
+  shared_ptr<DisinfectionPrinterService> m_disinfectionPrinterService;
+  DValueComputer                         m_dvalueComputer;
 
   int m_disinfectionWorkState       = 0;
   int m_replenishingFluidsWorkState = 0;
-  int m_drainingWorkState           = 0; //消毒工作状态,0:未工作,1:工作中
+  int m_drainingWorkState           = 0;  // 消毒工作状态,0:未工作,1:工作中
 
  public:
   DisinfectionContext m_context;
@@ -133,7 +135,6 @@ class DisinfectionCtrlService : public enable_shared_from_this<DisinfectionCtrlS
   void  processDisinfectionState(DisinfectionContext& context);
   void  finishDisinfection(DisinfectionContext& context);
 
-  void printfDisinfectionContextResult();
 
   void disinfectionLoop(bool& breakflag);
 
@@ -141,6 +142,8 @@ class DisinfectionCtrlService : public enable_shared_from_this<DisinfectionCtrlS
   shared_ptr<DisinfectionLogger> createCSVLogger(string log_file_name);
   void                           dumpDisinfectionLogsToCSV(DisinfectionContext& context);
 
+  void pushDisinfectionPrinterTask(DisinfectionContext& context);
+
   void log(DisinfectionContext& context);
   void takeStateSnapshot(DisinfectionContext& context);
   void updateH2O2SensorData(DisinfectionContext& context);

service/disinfection_printer_service.cpp

@@ -1,5 +1,90 @@
 #include "disinfection_printer_service.hpp"
 using namespace iflytop;
 
-void DisinfectionPrinterService::initialize() {}
-void DisinfectionPrinterService::pushPrintTask(shared_ptr<DisinfectionPrinterTask> task) {}
+static string format_zsystem_tp(zsystem_tp tp) {
+  time_t    time = system_clock().to_time_t(tp);
+  struct tm tm   = {0};
+  localtime_r(&time, &tm);
+  return fmt::format("{:0>4}-{:0>2}-{:0>2} {:0>2}:{:0>2}:{:0>2}", tm.tm_year + 1900,  //
+                     tm.tm_mon + 1,                                                   //
+                     tm.tm_mday,                                                      //
+                     tm.tm_hour,                                                      //
+                     tm.tm_min, tm.tm_sec);
+}
+
+void DisinfectionPrinterService::initialize() {
+  logger->info("initialize");
+  GET_TO_SERVICE(m_deviceIoControlService);
+
+  m_workThread.reset(new Thread("DisinfectionPrinterServiceThread", [this]() {
+    while (true) {
+      shared_ptr<DisinfectionPrinterTask> task;
+      {
+        lock_guard<recursive_mutex> lock(lock_);
+        if (!tasks.empty()) {
+          task = tasks.front();
+          tasks.pop();
+        }
+      }
+      if (!task) {
+        this_thread::sleep_for(chrono::milliseconds(1000));
+        continue;
+      }
+
+      printTask(task);
+    }
+  }));
+}
+void DisinfectionPrinterService::pushPrintTask(shared_ptr<DisinfectionPrinterTask> task) {
+  lock_guard<recursive_mutex> lock(lock_);
+  logger->info("pushPrintTask");
+  tasks.push(task);
+}
+
+void DisinfectionPrinterService::printTask(shared_ptr<DisinfectionPrinterTask> task) {
+  /**
+   * @brief 打印
+   */
+  auto    dio         = m_deviceIoControlService;
+  int32_t totaltime_s = zsystem_clock().tpToS(task->complete_tp) - zsystem_clock().tpToS(task->start_tp);
+
+  dio->printerPrintf(fmt::format("= = = = = = = = = = = = = = = \n"));
+  dio->printerPrintf(fmt::format("          全思美特\n"));
+  dio->printerPrintf(fmt::format("操作人    {}\n", task->usr));
+  dio->printerPrintf(fmt::format("开始时间  {}\n", format_zsystem_tp(task->start_tp)));
+  dio->printerPrintf(fmt::format("结束时间  {}\n", format_zsystem_tp(task->complete_tp)));
+  dio->printerPrintf(fmt::format("总耗时            {}:{}\n", totaltime_s / 60, totaltime_s % 60));
+  dio->printerPrintf(fmt::format("消毒液使用           {}g\n", task->disinfectantUsage));
+  dio->printerPrintf(fmt::format("目标LOG             {}\n", task->targetLog));
+  dio->printerPrintf(fmt::format("实际LOG             {}\n", task->actualLog));
+  dio->printerPrintf(fmt::format("= = = = = = = = = = = = = = = \n"));
+
+  disinfection_state_t state = kstate_idle;
+  for (size_t i = 0; i < task->stateSnapshotList.size(); i++) {
+    disinfection_state_t      now_state = task->stateSnapshotList[i]->state;
+    shared_ptr<StateSnapshot> ss        = task->stateSnapshotList[i];
+
+    if (now_state != state) {
+      dio->printerPrintf(fmt::format("{}\n", format_zsystem_tp(ss->time)));
+      if (now_state == kstate_preheat) {
+        dio->printerPrintf(fmt::format("预热中...\n"));
+      } else if (now_state == kstate_preheat) {
+        dio->printerPrintf(fmt::format("消毒中...\n"));
+      } else if (now_state == kstate_degradation) {
+        dio->printerPrintf(fmt::format("降解中...\n"));
+      } else if (now_state == kstate_finished) {
+        dio->printerPrintf(fmt::format("结束...\n"));
+      }
+      dio->printerPrintf(fmt::format("{}ppm {}%RS {}%RH {}Log\n", ss->min_h2o2, ss->max_saturation, ss->max_humid, ss->dloglevel));
+    } else {
+      if (now_state == kstate_degradation) {
+        dio->printerPrintf(fmt::format("{}\n", format_zsystem_tp(ss->time)));
+        dio->printerPrintf(fmt::format("{}ppm {}%RS {}%RH {}Log\n", ss->min_h2o2, ss->max_saturation, ss->max_humid, ss->dloglevel));
+      }
+    }
+  }
+
+  dio->printerPrintf(fmt::format("\n"));
+  dio->printerPrintf(fmt::format("\n"));
+  dio->printerPrintf(fmt::format("\n"));
+}

service/disinfection_printer_service.hpp

@@ -35,10 +35,12 @@ class DisinfectionPrinterService : public enable_shared_from_this<DisinfectionPr
   ENABLE_LOGGER(DisinfectionPrinterService);
 
  private:
+  shared_ptr<IF_DeviceIoContrlService> m_deviceIoControlService;
+
   recursive_mutex lock_;
 
-  unique_ptr<Thread>                        m_workThread;
-  list<shared_ptr<DisinfectionPrinterTask>> tasks;
+  unique_ptr<Thread>                         m_workThread;
+  queue<shared_ptr<DisinfectionPrinterTask>> tasks;
 
  public:
   DisinfectionPrinterService() {}
@@ -47,5 +49,8 @@ class DisinfectionPrinterService : public enable_shared_from_this<DisinfectionPr
   void initialize();
 
   void pushPrintTask(shared_ptr<DisinfectionPrinterTask> task);
+
+ private:
+  void printTask(shared_ptr<DisinfectionPrinterTask> task);
 };
 }  // namespace iflytop

service/disinfection_state.hpp

@@ -56,25 +56,35 @@ class StateSnapshot {
   int max_h2o2;
   int max_humid;
   int max_saturation;
+
+  int dloglevel;
 };
 
 class DisinfectionPrinterTask {
  public:
-  list<shared_ptr<StateSnapshot>> stateSnapshotList;  // 状态快照I
+  string disinfection_id;
+  string usr;
+
+  vector<shared_ptr<StateSnapshot>> stateSnapshotList;  // 状态快照I
 
   int disinfectantUsage;  // 消毒剂使用量
 
   zsystem_tp start_tp;
   zsystem_tp complete_tp;
 
-  bool stoped_by_usr = false;
+  int targetLog;
+  int actualLog;
+
+  int disinfectantVolume;  // g
 };
 
 class DisinfectionContext {
  public:
   string               m_disinfectionID;
   disinfection_state_t m_state = kstate_idle;
-  zsteady_tp           disinfection_start_steady_tp;
+  zsteady_tp           start_steady_tp;
+  zsystem_tp           start_tp;
+  zsystem_tp           complete_tp;
 
   /**
    * @brief 消毒中配置
@@ -118,16 +128,11 @@ class DisinfectionContext {
   /*******************************************************************************
    *                                 日志与统计                                  *
    *******************************************************************************/
-  shared_ptr<DisinfectionLogger>  csvlogger;          // 日志记录器
-  list<shared_ptr<StateSnapshot>> stateSnapshotList;  // 状态快照I
+  shared_ptr<DisinfectionLogger>    csvlogger;          // 日志记录器
+  vector<shared_ptr<StateSnapshot>> stateSnapshotList;  // 状态快照I
 
   int beforeDisinfectantVolume_g;  // 消毒前消毒剂量
   int afterDisinfectantVolume_g;   // 消毒后消毒剂量
-
-  zsystem_tp disinfection_start_tp;
-  zsystem_tp disinfection_complete_tp;
-
-  bool stoped_by_usr = false;
 };
 
 }  // namespace iflytop