tdcan/src/service/device_io_control_service.cpp

#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

#define GPM_TO_SPEED(gpm)   (gpm * 3.07)
#define SPEED_TO_GPM(speed) (speed / 3.07)

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_TO_SPEED(gpm);
  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_TO_SPEED(gpm);
  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_TO_SPEED(gpm);
  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 SPEED_TO_GPM(sprayLiquidPump_getRPM()); }

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