recode

usrc/base/i_protocol_processer.hpp

@@ -15,8 +15,8 @@ using namespace std;
 using namespace zscanprotocol;
 using namespace transmit_disfection_protocol;
 
-#define REG_FN(fn)                  cmdprocesser.push_back(CmdProcesser(kfn_##fn, bind(&ThisClass::fn, this, placeholders::_1)))
-#define BIND_FN(ClassName, obj, fn) cmdprocesser.push_back(CmdProcesser(kfn_##fn, bind(&ClassName::fn, obj, placeholders::_1)));
+#define REG_FN(fn)                  cmdprocesser.push_back(CmdProcesser(k##fn, bind(&ThisClass::fn, this, placeholders::_1)))
+#define BIND_FN(ClassName, obj, fn) cmdprocesser.push_back(CmdProcesser(k##fn, bind(&ClassName::fn, obj, placeholders::_1)));
 
 #define GET_PARAM(off) ((((int32_t*)(cxt->packet->params))[off]))
 #define PRAAM_LEN()    ((cxt->packetlen - sizeof(zcanbus_packet_t)) / 4)

usrc/board/large_space_dm_liquid_ctrl_board.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include "dep.hpp"
+#include "board_base/board_base.hpp"
 namespace iflytop {
 class LargeSpaceDmLiquidCtrlBoard {
  public:

usrc/board/large_space_dm_power_ctrl_board.hpp

@@ -1,5 +1,6 @@
 #pragma once
-#include "dep.hpp"
+#include "board_base/board_base.hpp"
+
 //
 
 namespace iflytop {

usrc/board/pipe_dm_liquid_ctrl_board.hpp

@@ -0,0 +1,32 @@
+#pragma once
+#include "board_base/board_base.hpp"
+namespace iflytop {
+class PipeDMLiquidCtrlBoard {
+ public:
+  ZGPIO              evaporationBinWS;  // 蒸发仓水浸
+  ZGPIO              deviceBottomWS;    // 设备底部水浸
+  WarningLightDriver wlDriver;          // 报警灯
+  TmcMotorGroup      tmcPowerGroup;     // TMC电机
+  PXXPSBus           psBus;             // PXX压力传感器总线
+
+ public:
+  static PipeDMLiquidCtrlBoard* ins() {
+    static PipeDMLiquidCtrlBoard instance;
+    return &instance;
+  }
+  void initialize() {
+    // 水浸初始化
+    evaporationBinWS.initAsInput(PC7, kxs_gpio_nopull, kxs_gpio_no_irq, true /*mirror*/);
+    deviceBottomWS.initAsInput(PC8, kxs_gpio_nopull, kxs_gpio_no_irq, true /*mirror*/);
+    // TMC电机初始化
+    LargeSpaceDMLiquidCtrlBoardHal::HSPI1_INIT();
+    tmcPowerGroup.initialize(PB2, {&hspi1, PC4 /*cs*/, PB13 /*en*/}, {&hspi1, PA4 /*cs*/, PB12 /*en*/});
+    // 三色指示灯初始化
+    wlDriver.initialize(PD8, PD7, PD9, PD10);
+    // 压力传感器初始化
+    osDelay(1500);  // 等待传感器上电
+    LargeSpaceDMLiquidCtrlBoardHal::HUART3_INIT(9600, UART_STOPBITS_1);
+    psBus.initialize(&huart3);
+  }
+};
+}  // namespace iflytop

usrc/board/pipe_dm_power_ctrl_board.hpp

@@ -0,0 +1,32 @@
+#pragma once
+#include "board_base/board_base.hpp"
+
+//
+
+namespace iflytop {
+#define H2O2_SENSOR_TYPE_HMP110
+using namespace transmit_disfection_protocol;
+
+class PipeDMPowerCtrlBoard {
+ public:
+  HeaterController        heaterCtrler;
+  BlowerController        blowerCtrler;
+  AirCompressorController airComCtrler;
+  H2O2SensorDriver        h2o2Sensor;
+
+ public:
+  static PipeDMPowerCtrlBoard* ins() {
+    static PipeDMPowerCtrlBoard instance;
+    return &instance;
+  }
+  void initialize() {
+    LargeSpaceDmPowerCtrlBoardHal::HADC1_INIT();
+    LargeSpaceDmPowerCtrlBoardHal::HUART2_INIT(19200, UART_STOPBITS_2);
+
+    heaterCtrler.initialize(PC7, &hadc1, ADC_CHANNEL_2, &hadc1, ADC_CHANNEL_8);
+    blowerCtrler.initialize(PC5, &hadc1, ADC_CHANNEL_1);
+    airComCtrler.initialize(PC3, &hadc1, ADC_CHANNEL_0);
+    h2o2Sensor.initialize(&huart2, &hadc1, ADC_CHANNEL_10);
+  }
+};
+}  // namespace iflytop

usrc/board_base/app_share/air_compressor_controller copy.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include "base/appdep.hpp"
+
+namespace iflytop {
+using namespace zscanprotocol;
+using namespace transmit_disfection_protocol;
+
+class AirCompressorController {
+  ZGPIO m_AirCompressor_ctrlGpio;
+  ZADC  m_AirCompressor_iAdc;
+
+ public:
+  static AirCompressorController* ins() {
+    static AirCompressorController instance;
+    return &instance;
+  }
+
+  void initialize(Pin_t ctrlGpio, ADC_HandleTypeDef* iadc, uint32_t ich) {
+    m_AirCompressor_ctrlGpio.initAsOutput(ctrlGpio, kxs_gpio_nopull, true, false);
+    m_AirCompressor_iAdc.initialize("AirComAdc", iadc, ich);
+
+    AppPeriodTaskMgr::ins()->regTask("AirComAdc", AirCompressorController::periodTask, this, 10);
+  }
+
+  // FN
+  void    air_compressor_ctrl(int32_t val) { m_AirCompressor_ctrlGpio.write(val); }
+  void    air_compressor_ctrl_safe_valve(int32_t val) {}
+  int32_t air_compressor_read_electric_current() { return airCompressorAdcToCurrent(m_AirCompressor_iAdc.getCacheVal()); }
+
+  // PP
+  void fn_air_compressor_ctrl(ProcessContext* cxt) {  //
+    air_compressor_ctrl(GET_PARAM(0));
+    zcanbus_send_ack(cxt->packet, NULL, 0);
+  }
+  void fn_air_compressor_ctrl_safe_valve(ProcessContext* cxt) {  //
+    air_compressor_ctrl_safe_valve(GET_PARAM(0));
+    zcanbus_send_ack(cxt->packet, NULL, 0);
+  }
+  void fn_air_compressor_read_electric_current(ProcessContext* cxt) {  //
+    auto val = air_compressor_read_electric_current();
+    zcanbus_send_ack(cxt->packet, (uint8_t*)val, sizeof(val));
+  }
+
+ private:
+  static void periodTask(void* p) { ((AirCompressorController*)p)->periodTask(); }
+  void        periodTask() { m_AirCompressor_iAdc.updateAdcValToCache(); }
+};
+}  // namespace iflytop
+
+#pragma once

usrc/board/app_share/air_compressor_controller.hpp → usrc/board_base/app_share/air_compressor_controller.hpp

@@ -28,15 +28,15 @@ class AirCompressorController {
   int32_t air_compressor_read_electric_current() { return airCompressorAdcToCurrent(m_AirCompressor_iAdc.getCacheVal()); }
 
   // PP
-  void air_compressor_ctrl(ProcessContext* cxt) {  //
+  void fn_air_compressor_ctrl(ProcessContext* cxt) {  //
     air_compressor_ctrl(GET_PARAM(0));
     zcanbus_send_ack(cxt->packet, NULL, 0);
   }
-  void air_compressor_ctrl_safe_valve(ProcessContext* cxt) {  //
+  void fn_air_compressor_ctrl_safe_valve(ProcessContext* cxt) {  //
     air_compressor_ctrl_safe_valve(GET_PARAM(0));
     zcanbus_send_ack(cxt->packet, NULL, 0);
   }
-  void air_compressor_read_electric_current(ProcessContext* cxt) {  //
+  void fn_air_compressor_read_electric_current(ProcessContext* cxt) {  //
     auto val = air_compressor_read_electric_current();
     zcanbus_send_ack(cxt->packet, (uint8_t*)val, sizeof(val));
   }

usrc/board/app_share/blower_controller.hpp → usrc/board_base/app_share/blower_controller.hpp

@@ -23,15 +23,15 @@ class BlowerController {
   int32_t blower_read_electric_current() { return blowserAdcToCurrent(m_Blowser_electricCurrentAdc.getCacheVal()); }
 
   // PP
-  void blower_ctrl(ProcessContext* cxt) {  //
+  void fn_blower_ctrl(ProcessContext* cxt) {  //
     blower_ctrl(GET_PARAM(0));
     zcanbus_send_ack(cxt->packet, NULL, 0);
   }
-  void blower_ctrl_safe_valve(ProcessContext* cxt) {  //
+  void fn_blower_ctrl_safe_valve(ProcessContext* cxt) {  //
     blower_ctrl_safe_valve(GET_PARAM(0));
     zcanbus_send_ack(cxt->packet, NULL, 0);
   }
-  void blower_read_electric_current(ProcessContext* cxt) {  //
+  void fn_blower_read_electric_current(ProcessContext* cxt) {  //
     auto val = blower_read_electric_current();
     zcanbus_send_ack(cxt->packet, (uint8_t*)val, sizeof(val));
   }

usrc/board/app_share/h2o2_sensor_driver.hpp → usrc/board_base/app_share/h2o2_sensor_driver.hpp

@@ -20,16 +20,16 @@ class H2O2SensorDriver {
   int32_t h2o2_sensor_data(report_h2o2_data_t* sensorData);
 
   // PP
-  void h2o2_sensor_read_calibration_date(ProcessContext* cxt) {
+  void fn_h2o2_sensor_read_calibration_date(ProcessContext* cxt) {
     int32_t data[3];
     h2o2_sensor_read_calibration_date(&data[0], &data[1], &data[2]);
     zcanbus_send_ack(cxt->packet, (uint8_t*)&data, sizeof(data));
   }
-  void h2o2_sensor_read_sub_ic_errorcode(ProcessContext* cxt) {
+  void fn_h2o2_sensor_read_sub_ic_errorcode(ProcessContext* cxt) {
     int32_t ecode = h2o2_sensor_read_sub_ic_errorcode();
     zcanbus_send_ack(cxt->packet, (uint8_t*)&ecode, sizeof(ecode));
   }
-  void h2o2_sensor_read_sub_ic_reg(ProcessContext* cxt) {
+  void fn_h2o2_sensor_read_sub_ic_reg(ProcessContext* cxt) {
     int32_t addr   = GET_PARAM(0);
     int32_t regNum = GET_PARAM(1);
     if (regNum > 10) regNum = 10;  // 最多读10个寄存器

usrc/board/app_share/heater_controller.hpp → usrc/board_base/app_share/heater_controller.hpp

@@ -25,19 +25,19 @@ class HeaterController {
   int32_t heater_read_electric_current() { return hearterAdcToCurrent(m_Heater_electricCurrentAdc.getCacheVal()); }
 
   // PP
-  void heater_ctrl(ProcessContext* cxt) {  //
+  void fn_heater_ctrl(ProcessContext* cxt) {  //
     heater_ctrl(GET_PARAM(0));
     zcanbus_send_ack(cxt->packet, NULL, 0);
   }
-  void heater_ctrl_safe_valve(ProcessContext* cxt) {  //
+  void fn_heater_ctrl_safe_valve(ProcessContext* cxt) {  //
     heater_ctrl_safe_valve(GET_PARAM(0));
     zcanbus_send_ack(cxt->packet, NULL, 0);
   }
-  void heater_read_electric_current(ProcessContext* cxt) {  //
+  void fn_heater_read_electric_current(ProcessContext* cxt) {  //
     auto val = heater_read_electric_current();
     zcanbus_send_ack(cxt->packet, (uint8_t*)val, sizeof(val));
   }
-  void heater_read_temperature_data(ProcessContext* cxt) {  //
+  void fn_heater_read_temperature_data(ProcessContext* cxt) {  //
     auto val = heater_read_temperature_data();
     zcanbus_send_ack(cxt->packet, (uint8_t*)val, sizeof(val));
   }

usrc/board/app_share/pxxpsbus.hpp → usrc/board_base/app_share/pxxpsbus.hpp

@@ -10,7 +10,7 @@ class PXXPSBus {
  public:
   void initialize(UART_HandleTypeDef* huart) { psbus.init(huart); }
 
-  void psbus_read_data(ProcessContext* cxt) {
+  void fn_psbus_read_data(ProcessContext* cxt) {
     CHECK_PARAM_LEN(PRAAM_LEN(), 1);
     int32_t index = GET_PARAM(0);
 
@@ -26,7 +26,7 @@ class PXXPSBus {
       zcanbus_send_errorack(cxt->packet, kerr_subdevice_offline);
     }
   }
-  void psbus_scan(ProcessContext* cxt) {
+  void fn_psbus_scan(ProcessContext* cxt) {
     auto* sensors   = psbus.sensors;
     int   numSensor = psbus.sensorNum;
 

usrc/board/app_share/tmc_motor_group.cpp → usrc/board_base/app_share/tmc_motor_group.cpp

@@ -113,7 +113,7 @@ void TmcMotorGroup::initialize(Pin_t tmcPowerPin, TMC51X0Cfg cfg0, TMC51X0Cfg cf
     return;                                                           \
   }
 
-void TmcMotorGroup::pump_rotate(ProcessContext* cxt) {
+void TmcMotorGroup::fn_pump_rotate(ProcessContext* cxt) {
   CHECK_PARAM_LEN(PRAAM_LEN(), 2);
   MOTOR_CHECK();
 
@@ -128,7 +128,7 @@ void TmcMotorGroup::pump_rotate(ProcessContext* cxt) {
   zcanbus_send_ack(cxt->packet, NULL, 0);
   motorErrorFlag_set(GET_PARAM(0), false);
 }
-void TmcMotorGroup::pump_stop(ProcessContext* cxt) {
+void TmcMotorGroup::fn_pump_stop(ProcessContext* cxt) {
   CHECK_PARAM_LEN(PRAAM_LEN(), 1);
   MOTOR_CHECK();
 
@@ -136,7 +136,7 @@ void TmcMotorGroup::pump_stop(ProcessContext* cxt) {
   motor(GET_PARAM(0))->stop();
   zcanbus_send_ack(cxt->packet, NULL, 0);
 }
-void TmcMotorGroup::pump_set_ihold_irun_idelay(ProcessContext* cxt) {
+void TmcMotorGroup::fn_pump_set_ihold_irun_idelay(ProcessContext* cxt) {
   CHECK_PARAM_LEN(PRAAM_LEN(), 4);
   MOTOR_CHECK();
 
@@ -149,7 +149,7 @@ void TmcMotorGroup::pump_set_ihold_irun_idelay(ProcessContext* cxt) {
 
   zcanbus_send_ack(cxt->packet, NULL, 0);
 }
-void TmcMotorGroup::pump_set_acc(ProcessContext* cxt) {
+void TmcMotorGroup::fn_pump_set_acc(ProcessContext* cxt) {
   CHECK_PARAM_LEN(PRAAM_LEN(), 2);
   MOTOR_CHECK();
 
@@ -163,7 +163,7 @@ void TmcMotorGroup::pump_set_acc(ProcessContext* cxt) {
   zcanbus_send_ack(cxt->packet, NULL, 0);
 }
 
-void TmcMotorGroup::pump_set_ramp(ProcessContext* cxt) {
+void TmcMotorGroup::fn_pump_set_ramp(ProcessContext* cxt) {
   CHECK_PARAM_LEN(PRAAM_LEN(), 5);
   MOTOR_CHECK();
 
@@ -184,16 +184,16 @@ void TmcMotorGroup::pump_set_ramp(ProcessContext* cxt) {
   motor(GET_PARAM(0))->setV1(v1);
   zcanbus_send_ack(cxt->packet, NULL, 0);
 }
-void TmcMotorGroup::pump_set_tzw(ProcessContext* cxt) {}
+void TmcMotorGroup::fn_pump_set_tzw(ProcessContext* cxt) {}
 
-void TmcMotorGroup::pump_set_subic_reg(ProcessContext* cxt) {
+void TmcMotorGroup::fn_pump_set_subic_reg(ProcessContext* cxt) {
   CHECK_PARAM_LEN(PRAAM_LEN(), 3);
   MOTOR_CHECK();
   ZLOGI(TAG, "pump_set_subic_reg: %d %d %x", GET_PARAM(0), GET_PARAM(1), GET_PARAM(2));
   motor(GET_PARAM(0))->writeIntExt(GET_PARAM(1), GET_PARAM(2));
   zcanbus_send_ack(cxt->packet, NULL, 0);
 }
-void TmcMotorGroup::pump_get_subic_reg(ProcessContext* cxt) {
+void TmcMotorGroup::fn_pump_get_subic_reg(ProcessContext* cxt) {
   CHECK_PARAM_LEN(PRAAM_LEN(), 2);
   MOTOR_CHECK();
   int32_t val = motor(GET_PARAM(0))->readIntExt(GET_PARAM(1));
@@ -201,7 +201,7 @@ void TmcMotorGroup::pump_get_subic_reg(ProcessContext* cxt) {
 
   zcanbus_send_ack(cxt->packet, (uint8_t*)&val, sizeof(val));
 }
-void TmcMotorGroup::pump_ping(ProcessContext* cxt) {
+void TmcMotorGroup::fn_pump_ping(ProcessContext* cxt) {
   CHECK_PARAM_LEN(PRAAM_LEN(), 1);
   MOTOR_CHECK();
   zcanbus_send_ack(cxt->packet, NULL, 0);

usrc/board/app_share/tmc_motor_group.hpp → usrc/board_base/app_share/tmc_motor_group.hpp

@@ -19,15 +19,15 @@ class TmcMotorGroup {
     return &m_motor[index];
   }
 
-  void pump_rotate(ProcessContext* cxt);
-  void pump_stop(ProcessContext* cxt);
-  void pump_set_ihold_irun_idelay(ProcessContext* cxt);
-  void pump_set_acc(ProcessContext* cxt);
-  void pump_set_ramp(ProcessContext* cxt);
-  void pump_set_tzw(ProcessContext* cxt);
-  void pump_set_subic_reg(ProcessContext* cxt);
-  void pump_get_subic_reg(ProcessContext* cxt);
-  void pump_ping(ProcessContext* cxt);
+  void fn_pump_rotate(ProcessContext* cxt);
+  void fn_pump_stop(ProcessContext* cxt);
+  void fn_pump_set_ihold_irun_idelay(ProcessContext* cxt);
+  void fn_pump_set_acc(ProcessContext* cxt);
+  void fn_pump_set_ramp(ProcessContext* cxt);
+  void fn_pump_set_tzw(ProcessContext* cxt);
+  void fn_pump_set_subic_reg(ProcessContext* cxt);
+  void fn_pump_get_subic_reg(ProcessContext* cxt);
+  void fn_pump_ping(ProcessContext* cxt);
 
  public:
 };

usrc/board/app_share/warning_light_driver.hpp → usrc/board_base/app_share/warning_light_driver.hpp

@@ -39,7 +39,7 @@ class WarningLightDriver {
       triLight_BEEP.write(0);
   }
 
-  void triple_warning_light_ctl(ProcessContext* cxt) {
+  void fn_triple_warning_light_ctl(ProcessContext* cxt) {
     CHECK_PARAM_LEN(PRAAM_LEN(), 4);
 
     int32_t r       = GET_PARAM(0);

usrc/protocol_processer_impl/large_space_dm_liquid_ctrl_board_pp.hpp

@@ -14,8 +14,6 @@ using namespace transmit_disfection_protocol;
 // ------------------------------------------------------
 
 class LargeSpaceDmLiquidCtrlBoardPP : public IProtocolProcesser {
-  uint8_t boardResetFlag;  // 0: 重启标志
-
  public:
   static LargeSpaceDmLiquidCtrlBoardPP* ins() {
     static LargeSpaceDmLiquidCtrlBoardPP ins;
@@ -24,18 +22,31 @@ class LargeSpaceDmLiquidCtrlBoardPP : public IProtocolProcesser {
   virtual const char* getName() override { return "LiquidCtrlBoardCmdProcesser"; };
 
   virtual void initialize() override {
-    REG_FN(evaporation_tank_water_sensor_read_state);
-    REG_FN(device_bottom_water_sensor_read_state);
+    REG_FN(fn_evaporation_tank_water_sensor_read_state);
+    REG_FN(fn_device_bottom_water_sensor_read_state);
     //
-    BIND_FN(WarningLightDriver, &DEVICE->wlDriver, triple_warning_light_ctl);
+    BIND_FN(WarningLightDriver, &DEVICE->wlDriver, fn_triple_warning_light_ctl);
+
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_rotate);
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_stop);
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_set_ihold_irun_idelay);
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_set_acc);
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_set_ramp);
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_set_tzw);
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_set_subic_reg);
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_get_subic_reg);
+    BIND_FN(TmcMotorGroup, &DEVICE->tmcPowerGroup, fn_pump_ping);
+
+    BIND_FN(PXXPSBus, &DEVICE->psBus, fn_psbus_read_data);
+    BIND_FN(PXXPSBus, &DEVICE->psBus, fn_psbus_scan);
   }
 
  private:
-  void evaporation_tank_water_sensor_read_state(ProcessContext* cxt) {
+  void fn_evaporation_tank_water_sensor_read_state(ProcessContext* cxt) {
     int32_t val = DEVICE->evaporationBinWS.read();
     zcanbus_send_ack(cxt->packet, (uint8_t*)&val, sizeof(val));
   }
-  void device_bottom_water_sensor_read_state(ProcessContext* cxt) {
+  void fn_device_bottom_water_sensor_read_state(ProcessContext* cxt) {
     int32_t val = DEVICE->deviceBottomWS.read();
     zcanbus_send_ack(cxt->packet, (uint8_t*)&val, sizeof(val));
   }

usrc/protocol_processer_impl/large_space_dm_power_ctrl_board_pp.hpp

@@ -14,15 +14,30 @@ using namespace transmit_disfection_protocol;
 // /-----------------------------
 
 class LargeSpaceDmPowerCtrlBoardPP : public IProtocolProcesser {
-  uint8_t boardResetFlag;  // 0: 重启标志
-
  public:
   static LargeSpaceDmPowerCtrlBoardPP* ins() {
     static LargeSpaceDmPowerCtrlBoardPP ins;
     return &ins;
   }
 
-  virtual void        initialize() override {}
+  virtual void initialize() override {
+    BIND_FN(HeaterController, &DEVICE->heaterCtrler, fn_heater_ctrl);
+    BIND_FN(HeaterController, &DEVICE->heaterCtrler, fn_heater_ctrl_safe_valve);
+    BIND_FN(HeaterController, &DEVICE->heaterCtrler, fn_heater_read_electric_current);
+    BIND_FN(HeaterController, &DEVICE->heaterCtrler, fn_heater_read_temperature_data);
+
+    BIND_FN(BlowerController, &DEVICE->blowerCtrler, fn_blower_ctrl);
+    BIND_FN(BlowerController, &DEVICE->blowerCtrler, fn_blower_ctrl_safe_valve);
+    BIND_FN(BlowerController, &DEVICE->blowerCtrler, fn_blower_read_electric_current);
+
+    BIND_FN(AirCompressorController, &DEVICE->airComCtrler, fn_air_compressor_ctrl);
+    BIND_FN(AirCompressorController, &DEVICE->airComCtrler, fn_air_compressor_ctrl_safe_valve);
+    BIND_FN(AirCompressorController, &DEVICE->airComCtrler, fn_air_compressor_read_electric_current);
+
+    BIND_FN(H2O2SensorDriver, &DEVICE->h2o2Sensor, fn_h2o2_sensor_read_calibration_date);
+    BIND_FN(H2O2SensorDriver, &DEVICE->h2o2Sensor, fn_h2o2_sensor_read_sub_ic_errorcode);
+    BIND_FN(H2O2SensorDriver, &DEVICE->h2o2Sensor, fn_h2o2_sensor_read_sub_ic_reg);
+  }
   virtual const char* getName() override { return "LargeSpaceDmPowerCtrlBoardPP"; };
 
  private:

usrc/protocol_processer_impl/public_cmd_processer.cpp

@@ -6,14 +6,14 @@ using namespace transmit_disfection_protocol;
 #define ThisClass PublicCmdProcesser
 
 void PublicCmdProcesser::initialize() {
-  REG_FN(read_board_info);
-  REG_FN(read_sysinfo);
-  REG_FN(read_taskinfo);
-  REG_FN(heart_ping);
-  REG_FN(clear_reset_flag);
+  REG_FN(fn_read_board_info);
+  REG_FN(fn_read_sysinfo);
+  REG_FN(fn_read_taskinfo);
+  REG_FN(fn_heart_ping);
+  REG_FN(fn_clear_reset_flag);
 }
 
-void PublicCmdProcesser::read_board_info(ProcessContext* cxt) {
+void PublicCmdProcesser::fn_read_board_info(ProcessContext* cxt) {
   static ack_read_board_info_data_t ack;
   ack.boardType        = PublicBoard::ins()->getBoardTypeId();
   ack.projectId        = PublicBoard::ins()->getProjId();
@@ -23,7 +23,7 @@ void PublicCmdProcesser::read_board_info(ProcessContext* cxt) {
 
   zcanbus_send_ack(cxt->packet, (uint8_t*)&ack, sizeof(ack));
 }
-void PublicCmdProcesser::read_sysinfo(ProcessContext* cxt) {
+void PublicCmdProcesser::fn_read_sysinfo(ProcessContext* cxt) {
   static ack_sysinfo_t ack;
   ack.free_heap_size  = SysMgr::ins()->osGetMinimumEverFreeHeapSize();
   ack.total_heap_size = SysMgr::ins()->osGetTotalHeapSize();
@@ -31,7 +31,7 @@ void PublicCmdProcesser::read_sysinfo(ProcessContext* cxt) {
   ack.sysHasRun       = SysMgr::ins()->osGetSysRunTime() / 1000;
   zcanbus_send_ack(cxt->packet, (uint8_t*)&ack, sizeof(ack));
 }
-void PublicCmdProcesser::read_taskinfo(ProcessContext* cxt) {
+void PublicCmdProcesser::fn_read_taskinfo(ProcessContext* cxt) {
   static ask_taskinfo_t ack;
   int32_t               taskoff = GET_PARAM(0);
   osThreadId            taskId  = SysMgr::ins()->osGetId(taskoff);
@@ -42,14 +42,14 @@ void PublicCmdProcesser::read_taskinfo(ProcessContext* cxt) {
 
   zcanbus_send_ack(cxt->packet, (uint8_t*)&ack, sizeof(ack));
 }
-void PublicCmdProcesser::heart_ping(ProcessContext* cxt) {
+void PublicCmdProcesser::fn_heart_ping(ProcessContext* cxt) {
   static report_heatpacket_data_t heatpacket;
   heatpacket.boardType  = PublicBoard::ins()->getBoardTypeId();
   heatpacket.heartIndex = GET_PARAM(0);
   heatpacket.flag       = gBoardFlag;
   zcanbus_send_report(kreport_heatpacket_pong, (uint8_t*)&heatpacket, sizeof(heatpacket), 30);
 }
-void PublicCmdProcesser::clear_reset_flag(ProcessContext* cxt) {
+void PublicCmdProcesser::fn_clear_reset_flag(ProcessContext* cxt) {
   gBoardFlagClearResetFlag();
   zcanbus_send_ack(cxt->packet, NULL, 0);
 }

usrc/protocol_processer_impl/public_cmd_processer.hpp

@@ -21,11 +21,11 @@ class PublicCmdProcesser : public IProtocolProcesser {
   virtual const char* getName() override { return "PublicCmdProcesser"; };
 
  private:
-  void read_board_info(ProcessContext* cxt);
-  void read_sysinfo(ProcessContext* cxt);
-  void read_taskinfo(ProcessContext* cxt);
-  void heart_ping(ProcessContext* cxt);
-  void clear_reset_flag(ProcessContext* cxt);
+  void fn_read_board_info(ProcessContext* cxt);
+  void fn_read_sysinfo(ProcessContext* cxt);
+  void fn_read_taskinfo(ProcessContext* cxt);
+  void fn_heart_ping(ProcessContext* cxt);
+  void fn_clear_reset_flag(ProcessContext* cxt);
 };
 
 }  // namespace iflytop