#include "hardware.hpp"

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

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

static osThreadId H2O2CaptureThreadId;
static osThreadId AdcCaptureThreadId;

// MINI_PWM 鼓风机
static TIM_HandleTypeDef* m_miniPwmBlower_htim;
static uint32_t           m_miniPwmBlower_channle;
static ZGPIO              m_miniPwmBlower_enGpio;
static ZGPIO              m_miniPwmBlower_fbGpio;

// 加热片控制
static ZGPIO m_Heater_ctrlGpio;
static ZGPIO m_Heater_safeCtrlGpio;
static ZADC  m_Heater_electricCurrentAdc;
static ZADC  m_Heater_temperatureAdc;

// H2O2过氧化氢
static ModbusBlockHost m_H2o2Sensor_TempSensorModbusBlockHost;  //
static ZADC            m_H2o2Sensor_H2O2Adc;                    // H2O2传感器控制
static HMP110          m_H2o2Sensor_HMP110;                     // H2O2传感器
static int32_t         m_hmp100_detectId = -1;

static void onAdcCaptureThreadId(void const* argument) {
  while (1) {
    osDelay(30);
    m_Heater_electricCurrentAdc.updateAdcValToCache();
    m_Heater_temperatureAdc.updateAdcValToCache();
  }
}

static void onH2O2CaptureThreadId(void const* argument) {
  while (1) {
    osDelay(1000);
    if (m_hmp100_detectId > 0) {
      m_H2o2Sensor_H2O2Adc.updateAdcValToCache();
      m_H2o2Sensor_HMP110.updateSensorDataAndErrorcode();

      // float    mv   = adcv / 4095.0 * 3.3 * 1000;
      // float    ma   = mv / 150.0;
      // float    ppm  = (ma - 4) / (20 - 4) * 2000;
    }
  }
}

void Hardware::init() {
  m_miniPwmBlower_htim    = &htim3;
  m_miniPwmBlower_channle = TIM_CHANNEL_3;
  m_miniPwmBlower_enGpio.initAsOutput(PC10, kxs_gpio_nopull, true, false);
  m_miniPwmBlower_fbGpio.initAsInput(PC9, kxs_gpio_nopull, kxs_gpio_rising_irq, false);

  m_Heater_ctrlGpio.initAsOutput(PC6, kxs_gpio_nopull, true, false);
  m_Heater_safeCtrlGpio.initAsOutput(PC7, kxs_gpio_nopull, true, false);
  //   m_Heater_electricCurrentAdc.initialize(&hadc1, ADC_CHANNEL_0);   //暂时注释掉，板子少了一个ADC，该ADC用于H2O2浓度
  m_Heater_temperatureAdc.initialize(&hadc1, ADC_CHANNEL_1);  // PA0

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

  /**
   * @brief 探测HMP110
   */
  osDelay(2000);  // 等待传感器上电
  if (m_H2o2Sensor_HMP110.ping(1)) {
    m_hmp100_detectId = 1;
  }
  if (m_H2o2Sensor_HMP110.ping(240)) {
    m_hmp100_detectId = 240;
  }
  m_H2o2Sensor_HMP110.setid(m_hmp100_detectId);
  ZLOGI(TAG, "H2O2 Sensor detect id: %d", m_hmp100_detectId);

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

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

/***********************************************************************************************************************
 *                                                      FUMP_IMPL                                                      *
 ***********************************************************************************************************************/
void Hardware::mini_pwm_blower_ctrl(int32_t duty) {
  duty = 100 - duty;
  if (duty < 0) duty = 0;
  if (duty > 100) duty = 100;

  TIM_OC_InitTypeDef sConfigOC = {0};
  sConfigOC.OCMode             = TIM_OCMODE_PWM1;
  sConfigOC.Pulse              = duty / 100.0 * __HAL_TIM_GET_AUTORELOAD(m_miniPwmBlower_htim);
  sConfigOC.OCPolarity         = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode         = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState        = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState       = TIM_OCNIDLESTATE_RESET;

  HAL_TIM_PWM_ConfigChannel(m_miniPwmBlower_htim, &sConfigOC, m_miniPwmBlower_channle);
  HAL_TIM_PWM_Stop(m_miniPwmBlower_htim, m_miniPwmBlower_channle);
  HAL_TIM_PWM_Start(m_miniPwmBlower_htim, m_miniPwmBlower_channle);

  m_miniPwmBlower_enGpio.write(duty != 0);
}
int32_t Hardware::mini_pwm_blower_read_fbcount() {  //
  return 0;
}

void    Hardware::heater_ctrl(int32_t val) { m_Heater_ctrlGpio.write(val); }
void    Hardware::heater_ctrl_safe_valve(int32_t val) { m_Heater_safeCtrlGpio.write(val); }
int32_t Hardware::heater_read_electric_current() {
  // float    mv   = adcv / 4095.0 * 3.3 * 1000;
  // float    ma   = mv / 150.0;
  int32_t adcv = m_Heater_electricCurrentAdc.getCacheVal();
  int32_t ma   = (adcv / 4095.0 * 3.3 * 1000) / 150.0;
  return ma;
}
int32_t Hardware::heater_read_temperature_data() {
  // float    mv   = adcv / 4095.0 * 3.3 * 1000;
  // float    ma   = mv / 150.0;
  // float    ppm  = (ma - 4) / (20 - 4) * 2000;
  int32_t adcv = m_Heater_temperatureAdc.getCacheVal();
  int32_t ma   = (adcv / 4095.0 * 3.3 * 1000) / 150.0;
  int32_t temp = (ma - 4) / (20 - 4) * (3000 - 0) + 0;
  return temp;  // C*10
}

bool Hardware::h2o2_sensor_is_online() {
  if (m_hmp100_detectId <= 0) {
    return false;
  }
  int32_t ecode = m_H2o2Sensor_HMP110.read_cache_errorcode();
  if (ecode == -1) {
    return false;
  }
  return true;
}
int32_t Hardware::h2o2_sensor_read_calibration_date(int32_t* year, int32_t* month, int32_t* day) { return 0; }
int32_t Hardware::h2o2_sensor_read_sub_ic_errorcode() { return m_H2o2Sensor_HMP110.read_cache_errorcode(); }
int32_t Hardware::h2o2_sensor_read_sub_ic_reg(int32_t add, uint16_t* val, size_t len) { return m_H2o2Sensor_HMP110.read_reg(add, val, len); }
int32_t Hardware::h2o2_sensor_data(report_h2o2_data_t* readdata) {
  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;
}