dbdb_ext_valve_board_pv1/usrc/base/hardware.cpp

#include "hardware.hpp"

#include "adc.h"
#include "tim.h"
#include "zsdk/zcanreceiver/zcanreceiver.hpp"
#define TAG "HARD"
using namespace iflytop;

/***********************************************************************************************************************
 *                                                         EXT                                                         *
 ***********************************************************************************************************************/

static osThreadId H2O2CaptureThreadId;
static osThreadId AdcCaptureThreadId;

/***********************************************************************************************************************
 *                                                        FUNC                                                         *
 ***********************************************************************************************************************/
static void c_onAdcCaptureThread(void const* argument) { Hardware::ins().onAdcCaptureThread(); }
static void c_onH2O2CaptureThread(void const* argument) { Hardware::ins().onH2O2CaptureThread(); }

void Hardware::init() {
  /***********************************************************************************************************************
   *                                                       加热片                                                        *
   ***********************************************************************************************************************/
  m_Heater_ctrlGpio.initAsOutput(HEATER_CTRL_GPIO, kxs_gpio_nopull, true, false);
  m_Heater_safeCtrlGpio.initAsOutput(HEATER_SAFE_CTRL_GPIO, kxs_gpio_nopull, true, false);
  m_Heater_electricCurrentAdc.initialize(&hadc1, HEATER_ELECTRIC_CURRENT_ADC_CH);
  m_Heater_temperatureAdc.initialize(&hadc1, HEATER_TEMPERATURE_ADC_CH);
  /***********************************************************************************************************************
   *                                                       鼓风机                                                        *
   ***********************************************************************************************************************/

  m_Blowser_ctrlGpio.initAsOutput(BLOWER_CTRL_GPIO, kxs_gpio_nopull, true, false);
  m_Blowser_safeCtrlGpio.initAsOutput(BLOWER_SAFE_CTRL_GPIO, kxs_gpio_nopull, true, false);
  m_Blowser_electricCurrentAdc.initialize(&hadc1, BLOWER_ELECTRIC_CURRENT_ADC_CH);

  /***********************************************************************************************************************
   *                                                       空压机                                                        *
   ***********************************************************************************************************************/
  m_AirCompressor_ctrlGpio.initAsOutput(AIRCOMPRESSOR_CTRL_GPIO, kxs_gpio_nopull, true, false);
  m_AirCompressor_safeCtrlGpio.initAsOutput(AIRCOMPRESSOR_SAFE_CTRL_GPIO, kxs_gpio_nopull, true, false);
  m_AirCompressor_electricCurrentAdc.initialize(&hadc1, AIRCOMPRESSOR_ELECTRIC_CURRENT_ADC_CH);

  /***********************************************************************************************************************
   *                                                     H2O2传感器                                                      *
   ***********************************************************************************************************************/
  /**
   * @brief 探测HMP110
   */
  osDelay(2000);  // 等待传感器上电

#ifdef H2O2_SENSOR_TYPE_HMP110

  ZASSERT(huart2.Init.BaudRate == 19200);
  m_H2o2Sensor_ModbusBlockHost.initialize(&huart2);
  m_H2o2Sensor_H2O2Adc.initialize(&hadc1, ADC_CHANNEL_0);  // PA0
  m_H2o2Sensor_HMP110.init(&m_H2o2Sensor_ModbusBlockHost);

  if (m_H2o2Sensor_HMP110.ping(1)) {
    m_h2o2sensor_detectId = 1;
  }
  if (m_H2o2Sensor_HMP110.ping(240)) {
    m_h2o2sensor_detectId = 240;
  }
  m_H2o2Sensor_HMP110.setid(m_h2o2sensor_detectId);
  ZLOGI(TAG, "H2O2 HMP110 Sensor detect id: %d", m_h2o2sensor_detectId);
#endif

#ifdef H2O2_SENSOR_TYPE_HPP272

  ZASSERT(huart3.Init.BaudRate == 19200);
  ZASSERT(huart3.Init.StopBits == UART_STOPBITS_2);
  m_H2o2Sensor_ModbusBlockHost.initialize(&huart3);
  m_H2o2Sensor_HPP272.init(&m_H2o2Sensor_ModbusBlockHost);

  if (m_H2o2Sensor_HPP272.ping(1)) {
    m_h2o2sensor_detectId = 1;
  }
  if (m_H2o2Sensor_HPP272.ping(240)) {
    m_h2o2sensor_detectId = 240;
  }

  m_H2o2Sensor_HPP272.setid(m_h2o2sensor_detectId);
  ZLOGI(TAG, "H2O2 HPP272 Sensor detect id: %d", m_h2o2sensor_detectId);

#endif

  osThreadDef(AdcCaptureThread, c_onAdcCaptureThread, osPriorityNormal, 0, 1024);
  AdcCaptureThreadId = osThreadCreate(osThread(AdcCaptureThread), NULL);

  osThreadDef(H2O2CaptureThread, c_onH2O2CaptureThread, osPriorityNormal, 0, 1024);
  H2O2CaptureThreadId = osThreadCreate(osThread(H2O2CaptureThread), NULL);
}

/***********************************************************************************************************************
 *                                                        H2O2                                                         *
 ***********************************************************************************************************************/

bool Hardware::h2o2_sensor_is_online() {
#ifdef H2O2_SENSOR_TYPE_HMP110
  if (m_h2o2sensor_detectId <= 0) return false;
  int32_t ecode = m_H2o2Sensor_HMP110.read_cache_errorcode();
  if (ecode == -1) return false;
#endif

#ifdef H2O2_SENSOR_TYPE_HPP272
  if (m_h2o2sensor_detectId <= 0) return false;
  int32_t ecode = m_H2o2Sensor_HPP272.read_cache_errorcode();
  if (ecode == -1) return false;
#endif

  return true;
}
int32_t Hardware::h2o2_sensor_read_calibration_date(int32_t* year, int32_t* month, int32_t* day) {  //
  *year  = 1;
  *month = 2;
  *day   = 3;
  return 0;
}
int32_t Hardware::h2o2_sensor_read_sub_ic_errorcode() {  //
#ifdef H2O2_SENSOR_TYPE_HPP272
  return m_H2o2Sensor_HPP272.read_cache_errorcode();
#endif

#ifdef H2O2_SENSOR_TYPE_HMP110
  return m_H2o2Sensor_HMP110.read_cache_errorcode();
#endif
}
int32_t Hardware::h2o2_sensor_read_sub_ic_reg(int32_t add, uint16_t* val, size_t len) {  //
#ifdef H2O2_SENSOR_TYPE_HPP272
  return m_H2o2Sensor_HPP272.read_reg(add, val, len);
#endif

#ifdef H2O2_SENSOR_TYPE_HMP110
  return m_H2o2Sensor_HMP110.read_reg(add, val, len);
#endif
}
int32_t Hardware::h2o2_sensor_data(report_h2o2_data_t* readdata) {
#ifdef H2O2_SENSOR_TYPE_HMP110
  int32_t                     ecode      = m_H2o2Sensor_HMP110.read_cache_errorcode();
  int32_t                     h2o2adcVal = m_H2o2Sensor_H2O2Adc.getCacheVal();
  HMP110::hmp110_sensordata_t sensordata;
  m_H2o2Sensor_HMP110.read_cache_sensor_data(&sensordata);

  // float    mv   = adcv / 4095.0 * 3.3 * 1000;
  // float    ma   = mv / 150.0;
  // float    ppm  = (ma - 4) / (20 - 4) * 2000;
  int32_t h2o2ma  = (h2o2adcVal / 4095.0 * 3.3 * 1000) / 150.0;
  int32_t h2o2ppm = (h2o2ma - 4) / (20 - 4) * 2000;

  readdata->subid        = 0;
  readdata->sensor_error = ecode != 0;
  readdata->h2o2         = h2o2ppm;
  readdata->humid        = sensordata.rh;
  readdata->temp         = sensordata.temp;
  readdata->saturation   = 0;

  ZLOGI(TAG, "ppm:%d, rh:%d, temp:%d, df_ptemp:%d, ah:%d, mr:%d, wbt:%d, eh:%d",  //
        h2o2ppm,                                                                  //
        sensordata.rh,                                                            //
        sensordata.temp,                                                          //
        sensordata.df_ptemp,                                                      //
        sensordata.ah,                                                            //
        sensordata.mr,                                                            //
        sensordata.wet_bulb_temp,                                                 //
        sensordata.enthalpy);

  return 0;
#endif
#ifdef H2O2_SENSOR_TYPE_HPP272

  int32_t               ecode = m_H2o2Sensor_HPP272.read_cache_errorcode();
  HPP272::hpp272_data_t sensordata;
  m_H2o2Sensor_HPP272.read_cache_sensor_data(&sensordata);

  readdata->sensor_error = ecode != 0;
  readdata->h2o2         = sensordata.hydrogen_peroxide_volume / 10.0;
  readdata->humid        = sensordata.relative_humidity / 10.0;
  readdata->temp         = sensordata.temperature1 / 10.0;
  readdata->saturation   = sensordata.h2o_h2o2_rs / 10.0;

  ZLOGI(TAG, "h2o2 %d, humid %d, temp %d, sat %d",
        sensordata.hydrogen_peroxide_volume / 10,  //
        sensordata.relative_humidity / 10,         //
        sensordata.temperature1 / 10,              //
        sensordata.h2o_h2o2_rs / 10);

  return 0;
#endif
}

void Hardware::onAdcCaptureThread() {
  while (1) {
    // osDelay(30);
    m_Heater_electricCurrentAdc.updateAdcValToCache();
    m_Heater_temperatureAdc.updateAdcValToCache();
    m_AirCompressor_electricCurrentAdc.updateAdcValToCache();
    m_Blowser_electricCurrentAdc.updateAdcValToCache();


    osDelay(1000);
    int32_t adcv1 =  m_Blowser_electricCurrentAdc.getCacheVal();
    int32_t adcv2 =  m_AirCompressor_electricCurrentAdc.getCacheVal();
    int32_t adcv3 =  m_Heater_electricCurrentAdc.getCacheVal();
    ZLOGI(TAG, "b:%d, a:%d, h:%d", adcv1, adcv2, adcv3);
  }
}
void Hardware::onH2O2CaptureThread() {
  while (1) {
    osDelay(1000);

#ifdef H2O2_SENSOR_TYPE_HMP110
    if (m_h2o2sensor_detectId > 0) {
      m_H2o2Sensor_H2O2Adc.updateAdcValToCache();
      m_H2o2Sensor_HMP110.updateSensorDataAndErrorcode();
    }
#endif

#ifdef H2O2_SENSOR_TYPE_HPP272
    if (m_h2o2sensor_detectId > 0) {
      m_H2o2Sensor_HPP272.updateSensorDataAndErrorcode();
    }
#endif
  }
}