p_transmit_disinfection_v3
/
tdcan
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

update

master
zhaohe 2 years ago
parent
aba0855859
commit
6a57fe00d9
13 changed files with 785 additions and 393 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      iflytoplinuxsdk
  2. 10
      src/db/db_service.cpp
  3. 1
      src/db/db_service.hpp
  4. 74
      src/main_control_service.cpp
  5. 6
      src/main_control_service.hpp
  6. 211
      src/service/device_io_control_service.cpp
  7. 129
      src/service/device_io_control_service.hpp
  8. 381
      src/service/disinfection_ctl_service.cpp
  9. 85
      src/service/disinfection_ctl_service.hpp
  10. 30
      src/service/disinfection_logs_manager.cpp
  11. 41
      src/service/disinfection_logs_manager.hpp
  12. 112
      src/service/sensor_data_scan.cpp
  13. 92
      src/service/sensor_data_scan.hpp

2
iflytoplinuxsdk

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

10
src/db/db_service.cpp
View File

@ -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);

1
src/db/db_service.hpp
View File

@ -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:
/*******************************************************************************

74
src/main_control_service.cpp
View File

@ -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
//开始加液
{

6
src/main_control_service.hpp
View File

@ -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;

211
src/service/device_io_control_service.cpp
View File

@ -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;
}

129
src/service/device_io_control_service.hpp
View File

@ -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

381
src/service/disinfection_ctl_service.cpp
View File

@ -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);
}
m_deviceIoControlService->heartingPlate_setPower(false);
m_deviceIoControlService->AirBlower_setState(false);
m_deviceIoControlService->airCompressor_setState(false);
}
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);
}
}
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);
}
drainingPump_close();
replenishingFluidsPump_close();
sprayLiquidPump_close();
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;
}
heartingPlate_setPower(false);
blower_setPower(false);
airCompressor(false);
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");
m_deviceIoControlService->sprayLiquidPump_open();
usleep(1000 * 1000);
m_deviceIoControlService->airCompressor_setState(true);
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();
// drainingPump_close();
m_deviceIoControlService->drainingPump_close();
}
int DisinfectionCtrlService::getReplenishingFluidsWorkState() { return m_replenishingFluidsWorkState; }
int DisinfectionCtrlService::getDrainingWorkState() { return m_drainingWorkState; }

85
src/service/disinfection_ctl_service.hpp
View File

@ -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

30
src/service/disinfection_logs_manager.cpp
View File

@ -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;
}

41
src/service/disinfection_logs_manager.hpp
View File

@ -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

112
src/service/sensor_data_scan.cpp
View File

@ -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;
}

92
src/service/sensor_data_scan.hpp
View File

@ -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
Write Preview
Loading…
Cancel
Save