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

update

storage-in-realtime
zhaohe 1 year ago
parent
2ec2a5afca
commit
90ac3e097a
12 changed files with 464 additions and 520 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
      .clang-format
  2. 4
      README.md
  3. 2
      iflytoplinuxsdk
  4. 2
      src/configs/project_setting.hpp
  5. 1
      src/main.cpp
  6. 16
      src/main_control_service.cpp
  7. 2
      src/main_control_service.hpp
  8. 210
      src/service/device_io_control_service.cpp
  9. 154
      src/service/device_io_control_service.hpp
  10. 358
      src/service/device_io_control_service_test.cpp
  11. 90
      src/service/device_io_control_service_test.hpp
  12. 143
      src/service/if_devoce_io_contrl_service.hpp

2
.clang-format
View File

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

4
README.md
View File

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

2
iflytoplinuxsdk

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

2
src/configs/project_setting.hpp
View File

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

1
src/main.cpp
View File

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

16
src/main_control_service.cpp
View File

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

2
src/main_control_service.hpp
View File

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

210
src/service/device_io_control_service.cpp
View File

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

154
src/service/device_io_control_service.hpp
View File

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

358
src/service/device_io_control_service_test.cpp
View File

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

90
src/service/device_io_control_service_test.hpp
View File

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

143
src/service/if_devoce_io_contrl_service.hpp
View File

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