Browse Source

recode

master
zhaohe 1 year ago
parent
commit
6364cdfbe3
  1. 4
      usrc/base/i_protocol_processer.hpp
  2. 2
      usrc/board/large_space_dm_liquid_ctrl_board.hpp
  3. 3
      usrc/board/large_space_dm_power_ctrl_board.hpp
  4. 32
      usrc/board/pipe_dm_liquid_ctrl_board.hpp
  5. 32
      usrc/board/pipe_dm_power_ctrl_board.hpp
  6. 50
      usrc/board_base/app_share/air_compressor_controller copy.hpp
  7. 6
      usrc/board_base/app_share/air_compressor_controller.hpp
  8. 6
      usrc/board_base/app_share/blower_controller.hpp
  9. 0
      usrc/board_base/app_share/h2o2_sensor_driver.cpp
  10. 6
      usrc/board_base/app_share/h2o2_sensor_driver.hpp
  11. 8
      usrc/board_base/app_share/heater_controller.hpp
  12. 4
      usrc/board_base/app_share/pxxpsbus.hpp
  13. 18
      usrc/board_base/app_share/tmc_motor_group.cpp
  14. 18
      usrc/board_base/app_share/tmc_motor_group.hpp
  15. 2
      usrc/board_base/app_share/warning_light_driver.hpp
  16. 0
      usrc/board_base/baseboard/large_space_dm_liquid_ctrl_board_hal.cpp
  17. 0
      usrc/board_base/baseboard/large_space_dm_liquid_ctrl_board_hal.hpp
  18. 0
      usrc/board_base/baseboard/large_space_dm_power_ctrl_board.cpp
  19. 0
      usrc/board_base/baseboard/large_space_dm_power_ctrl_board.hpp
  20. 0
      usrc/board_base/board_base.hpp
  21. 25
      usrc/protocol_processer_impl/large_space_dm_liquid_ctrl_board_pp.hpp
  22. 21
      usrc/protocol_processer_impl/large_space_dm_power_ctrl_board_pp.hpp
  23. 20
      usrc/protocol_processer_impl/public_cmd_processer.cpp
  24. 10
      usrc/protocol_processer_impl/public_cmd_processer.hpp

4
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)

2
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:

3
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 {

32
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

32
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

50
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

6
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));
}

6
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));
}

0
usrc/board/app_share/h2o2_sensor_driver.cpp → usrc/board_base/app_share/h2o2_sensor_driver.cpp

6
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个寄存器

8
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));
}

4
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;

18
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);

18
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:
};

2
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);

0
usrc/board/baseboard/large_space_dm_liquid_ctrl_board_hal.cpp → usrc/board_base/baseboard/large_space_dm_liquid_ctrl_board_hal.cpp

0
usrc/board/baseboard/large_space_dm_liquid_ctrl_board_hal.hpp → usrc/board_base/baseboard/large_space_dm_liquid_ctrl_board_hal.hpp

0
usrc/board/baseboard/large_space_dm_power_ctrl_board.cpp → usrc/board_base/baseboard/large_space_dm_power_ctrl_board.cpp

0
usrc/board/baseboard/large_space_dm_power_ctrl_board.hpp → usrc/board_base/baseboard/large_space_dm_power_ctrl_board.hpp

0
usrc/board/dep.hpp → usrc/board_base/board_base.hpp

25
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));
}

21
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:

20
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);
}

10
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
Loading…
Cancel
Save