You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
341 lines
12 KiB
341 lines
12 KiB
#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) {
|
|
int adcv = 0;
|
|
|
|
if (m_zcanHost->readadc(0, adcv) == 0) {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
m_adc_0 = adcv;
|
|
}
|
|
if (m_zcanHost->readadc(1, adcv) == 0) {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
m_adc_1 = adcv;
|
|
}
|
|
if (m_zcanHost->readadc(2, adcv) == 0) {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
m_adc_2 = adcv;
|
|
}
|
|
// 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
|
|
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;
|
|
}
|
|
// hydrogen_peroxide_volume
|
|
// water_vapor_saturation_pressure_h2o_h2o2
|
|
// logger->info("---------hpp272_read_c1000---------");
|
|
// logger->info("hydrogen_peroxide_volume :{}", m_hpp272_data_1.hydrogen_peroxide_volume);
|
|
// logger->info("h2o_h2o2_rs :{}", m_hpp272_data_1.h2o_h2o2_rs);
|
|
// logger->info("temperature1 :{}", m_hpp272_data_1.temperature1);
|
|
// logger->info("relative_humidity :{}", m_hpp272_data_1.relative_humidity);
|
|
// logger->info("absolute_hydrogen_peroxide :{}", m_hpp272_data_1.absolute_hydrogen_peroxide);
|
|
// logger->info("h2o_h2o2dew_point_temperature :{}", m_hpp272_data_1.h2o_h2o2dew_point_temperature);
|
|
// logger->info("reserved1 :{}", m_hpp272_data_1.reserved1);
|
|
// logger->info("water_volume :{}", m_hpp272_data_1.water_volume);
|
|
// logger->info("water_vapor_pressure :{}", m_hpp272_data_1.water_vapor_pressure);
|
|
// logger->info("absolute_humidity :{}", m_hpp272_data_1.absolute_humidity);
|
|
// logger->info("water_vapor_saturation_pressure_h2o:{}", m_hpp272_data_1.water_vapor_saturation_pressure_h2o);
|
|
// logger->info("temperature2 :{}", m_hpp272_data_1.temperature2);
|
|
// logger->info("h2o2_vapor_pressure :{}", m_hpp272_data_1.h2o2_vapor_pressure);
|
|
// logger->info("water_vapor_saturation_pressure_h2o_h2o2:{}", m_hpp272_data_1.water_vapor_saturation_pressure_h2o_h2o2);
|
|
// logger->info("");
|
|
}
|
|
|
|
if (i % 300 == 0) {
|
|
if (readpressuresensor_id == 5) {
|
|
readpressuresensor_id = 1;
|
|
}
|
|
ZCanHost::huacheng_pressure_sensor_read_c1005_t sdata;
|
|
if (m_zcanHost->huacheng_pressure_sensor_read_c1005(readpressuresensor_id, sdata) == 0) {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
m_pressure_sensor_data[readpressuresensor_id] = sdata;
|
|
}
|
|
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::airCompressor_getio1() { return m_zcanHost->read_writeio_state_cache(0); }
|
|
int DeviceIoControlService::airCompressor_getio2() { return m_zcanHost->read_writeio_state_cache(1); }
|
|
int DeviceIoControlService::airCompressor_getcurrentValue() { return m_adc_0 * 0.00167 - 1.25; }
|
|
int DeviceIoControlService::airCompressor_getstate() { return m_zcanHost->read_writeio_state_cache(0) && m_zcanHost->read_writeio_state_cache(1); }
|
|
|
|
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;
|
|
}
|
|
int DeviceIoControlService::airBlower_getio1() { return m_zcanHost->read_writeio_state_cache(2); }
|
|
int DeviceIoControlService::airBlower_getio2() { return m_zcanHost->read_writeio_state_cache(3); }
|
|
int DeviceIoControlService::airBlower_getstate() { return m_zcanHost->read_writeio_state_cache(2) && m_zcanHost->read_writeio_state_cache(3); }
|
|
|
|
int DeviceIoControlService::airBlower_getcurrentValue() { return m_adc_1 * 0.00167 - 1.25; }
|
|
// heatingStrip
|
|
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::heatingStrip_getio1() { return m_zcanHost->read_writeio_state_cache(4); }
|
|
int DeviceIoControlService::heatingStrip_getio2() { return m_zcanHost->read_writeio_state_cache(5); }
|
|
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); }
|
|
|
|
void DeviceIoControlService::drainingPump_open() {
|
|
logger->info("drainingPump_open");
|
|
m_zcanHost->pumpctrl_c1004(1, 100, -300, 1, 20);
|
|
}
|
|
void DeviceIoControlService::drainingPump_close() {
|
|
logger->info("drainingPump_close");
|
|
m_zcanHost->pumpctrl_c1004(1, 100, 0, 1, 20);
|
|
}
|
|
|
|
void DeviceIoControlService::replenishingFluidsPump_open() {
|
|
logger->info("replenishingFluidsPump_open");
|
|
m_zcanHost->pumpctrl_c1004(1, 100, 300, 1, 20);
|
|
}
|
|
void DeviceIoControlService::replenishingFluidsPump_close() {
|
|
logger->info("replenishingFluidsPump_close");
|
|
m_zcanHost->pumpctrl_c1004(1, 100, 0, 1, 20);
|
|
}
|
|
|
|
void DeviceIoControlService::replenishingFluidsPump_open_for_test(int gpm) {
|
|
logger->info("replenishingFluidsPump_open_for_test {}", gpm);
|
|
int speed = gpm * 7.5;
|
|
if (speed > 300) {
|
|
speed = 300;
|
|
} else if (speed < -300) {
|
|
speed = -300;
|
|
}
|
|
m_zcanHost->pumpctrl_c1004(1, 100, speed, 1, 20);
|
|
}
|
|
void DeviceIoControlService::replenishingFluidsPump_close_for_test() {
|
|
logger->info("replenishingFluidsPump_close_for_test");
|
|
m_zcanHost->pumpctrl_c1004(1, 100, 0, 1, 20);
|
|
}
|
|
/*******************************************************************************
|
|
* sprayLiquidPump *
|
|
*******************************************************************************/
|
|
void DeviceIoControlService::sprayLiquidPump_open(int gpm) {
|
|
logger->info("sprayLiquidPump_open");
|
|
int speed = gpm * 7.5;
|
|
if (speed > 300) {
|
|
speed = 300;
|
|
} else if (speed < 0) {
|
|
speed = 0;
|
|
}
|
|
m_zcanHost->pumpctrl_c1004(2, 100, speed, 1, 15);
|
|
}
|
|
void DeviceIoControlService::sprayLiquidPump_close() {
|
|
logger->info("sprayLiquidPump_close");
|
|
m_zcanHost->pumpctrl_c1004(2, 100, 0, 1, 15);
|
|
}
|
|
|
|
void DeviceIoControlService::sprayLiquidPump_open_for_test(int gpm) {
|
|
logger->info("sprayLiquidPump_open");
|
|
int speed = gpm * 7.5;
|
|
if (speed > 300) {
|
|
speed = 300;
|
|
} else if (speed < -300) {
|
|
speed = -300;
|
|
}
|
|
m_zcanHost->pumpctrl_c1004(2, 100, speed, 1, 15);
|
|
}
|
|
void DeviceIoControlService::sprayLiquidPump_close_for_test() {
|
|
logger->info("sprayLiquidPump_close");
|
|
m_zcanHost->pumpctrl_c1004(2, 100, 0, 1, 15);
|
|
}
|
|
|
|
int DeviceIoControlService::sprayLiquidPump_getRPM() { return m_zcanHost->pumpctrl_c1004_get_speed_cache(2); }
|
|
int DeviceIoControlService::sprayLiquidPump_getGPM() { return sprayLiquidPump_getRPM() / 7.5; }
|
|
|
|
int DeviceIoControlService::sprayLiquidPump_getState() { //
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
|
|
return (sprayLiquidPump_getRPM() != 0);
|
|
}
|
|
/*******************************************************************************
|
|
* SensorState *
|
|
*******************************************************************************/
|
|
int DeviceIoControlService::getDisinfectantVolume_g() {
|
|
// kpa;
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
|
|
float kpa = m_pressure_sensor_data[1].value / 1000.0;
|
|
int g = 2.11 * kpa * 1000;
|
|
if (g < 450) { /*零点*/
|
|
return 0;
|
|
} else {
|
|
g -= 450;
|
|
}
|
|
return g;
|
|
}
|
|
int DeviceIoControlService::getPressureSensorData(int index) {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
|
|
return m_pressure_sensor_data[index].value;
|
|
}
|
|
|
|
int DeviceIoControlService::getWaterImmersionSensor1() {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
|
|
return m_waterImmersionSensor1 ? 1 : 0;
|
|
}
|
|
int DeviceIoControlService::getWaterImmersionSensor2() {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
|
|
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;
|
|
|
|
return data;
|
|
}
|
|
|
|
bool DeviceIoControlService::getAllSensorData(DeviceIoControlService::all_h2o2sensor_data_t& data) {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
|
|
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;
|
|
}
|