transmit_disinfection_micro/usrc/module/blower_controller.hpp

#pragma once
#include "base/appdep.hpp"

namespace iflytop {
using namespace transmit_disfection_protocol;

typedef enum {
  kIOBlower,
  kHighPowerUartBlower,
  kMiniPwmBlower,
} BlowerType_t;

class BlowerController {
  BlowerType_t m_blowerType = kIOBlower;

  // kIOBlower
  ZGPIO m_ctrlGpio;

  // kHighPowerUartBlower
  ModbusBlockHost m_modbusblock;

  // kMiniPwmBlower
  TIM_HandleTypeDef* m_miniPwmBlower_htim;
  uint32_t           m_miniPwmBlower_channle;
  ZGPIO              m_miniPwmBlower_enGpio;
  ZGPIO              m_miniPwmBlower_fbGpio;

  ZADC m_iadc;
  bool m_iadcIsInit = false;

  bool m_isInitialized = false;
  bool isopen          = false;

 public:
  void initialize(Pin_t ctrlGpio, ADC_HandleTypeDef* iadc, uint32_t ich) {
    m_ctrlGpio.initAsOutput(ctrlGpio, kxs_gpio_nopull, true, false);
    m_iadc.initialize("Blower-iadc", iadc, ich);
    AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000);
    m_blowerType    = kIOBlower;
    m_isInitialized = true;
    bindFn();
  }

  void initializeAsHighPowerUartBlower(Pin_t ctrlGpio, UART_HandleTypeDef* huart, ADC_HandleTypeDef* iadc, uint32_t ich) {
    m_ctrlGpio.initAsOutput(ctrlGpio, kxs_gpio_nopull, true, false);
    m_modbusblock.initialize(huart);
    m_iadc.initialize("Blower-iadc", iadc, ich);
    AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000);
    m_blowerType    = kHighPowerUartBlower;
    m_isInitialized = true;
    bindFn();
  }
  void initializeAsMiniPwmBlower(TIM_HandleTypeDef* htim, uint32_t channel, Pin_t enGpio, Pin_t fbGpio) {
    m_miniPwmBlower_htim    = htim;
    m_miniPwmBlower_channle = channel;
    m_miniPwmBlower_enGpio.initAsOutput(enGpio, kxs_gpio_nopull, true, false);
    m_miniPwmBlower_fbGpio.initAsInput(fbGpio, kxs_gpio_nopull, kxs_gpio_rising_irq, false);
    AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000);
    m_blowerType    = kMiniPwmBlower;
    m_isInitialized = true;
    bindFn();
  }

  bool isInitialized() { return m_isInitialized; }

  void bindFn() {
    BIND_FN(BlowerController, this, fn_blower_ctrl);
    BIND_FN(BlowerController, this, fn_blower_ctrl_safe_valve);
    BIND_FN(BlowerController, this, fn_blower_read_ei);
    BIND_FN(BlowerController, this, fn_blower_is_error);
    BIND_FN(BlowerController, this, fn_blower_read_ei_adc_raw);
    BIND_FN(BlowerController, this, fn_blower_is_open);
  }

  /***********************************************************************************************************************
   *                                                        FN                                                           *
   ***********************************************************************************************************************/
  void    blower_ctrl(int32_t val) {}
  void    blower_ctrl_safe_valve(int32_t val) {}
  int32_t blower_read_ei() {
    if (m_blowerType == kIOBlower || m_blowerType == kHighPowerUartBlower) {
      return blowserAdcToCurrent(m_iadc.getCacheVal());
    }
    return 0;
  }
  int32_t blower_read_iadc() {
    if (m_blowerType == kIOBlower || m_blowerType == kHighPowerUartBlower) {
      return m_iadc.getCacheVal();
    }
    return 0;
  }

  int32_t blower_is_error() {
    // TODO: 栏杆箱消毒机添加故障检测
    return 0;
  }

  void periodTask() {
    if (m_iadc.isInited()) m_iadc.updateAdcValToCache();
  }

  /***********************************************************************************************************************
   *                                                         PP                                                          *
   ***********************************************************************************************************************/
  void fn_blower_ctrl(ProcessContext* cxt) {  //
    int32_t val = GET_PARAM(0);
    if (m_blowerType == kIOBlower) {
      m_ctrlGpio.write(val);
      zcanbus_send_ack(cxt->packet, NULL, 0);
      isopen = GET_PARAM(0) > 0 ? true : false;
    } else if (m_blowerType == kHighPowerUartBlower) {
      m_ctrlGpio.write(val);
      bool suc = val > 0 ? m_modbusblock.writeReg06(1, 0x2000, 1, 50) : m_modbusblock.writeReg06(1, 0x2000, 6, 50);
      if (suc) {
        m_ctrlGpio.write(val);
        zcanbus_send_ack(cxt->packet, NULL, 0);
        isopen = GET_PARAM(0) > 0 ? true : false;
      } else {
        zcanbus_send_errorack(cxt->packet, err::kerr_overtime);
      }

    } else if (m_blowerType == kMiniPwmBlower) {
      mini_pwm_blower_ctrl(val);
    }
  }
  void fn_blower_ctrl_safe_valve(ProcessContext* cxt) {  //
    blower_ctrl_safe_valve(GET_PARAM(0));
    zcanbus_send_ack(cxt->packet, NULL, 0);
  }
  void fn_blower_read_ei(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, blower_read_ei()); }
  void fn_blower_read_ei_adc_raw(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, m_iadc.getCacheVal()); }
  void fn_blower_is_error(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, blower_is_error()); }
  void fn_blower_is_open(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, isopen); }

 private:
  void 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);
  }
};
}  // namespace iflytop