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

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() {
  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::sprayLiquidPump_open() {
  logger->info("sprayLiquidPump_open");
  m_zcanHost->pumpctrl_c1004(2, 100, 200, 1, 15);
}
void DeviceIoControlService::sprayLiquidPump_close() {
  logger->info("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                      = {0};
  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;
}