project_boditech_vidas_a8000_v3
/
a8000_subboard_sdk
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

update

master
zhaohe 1 year ago
parent
f204e7c9f2
commit
a3c397af55
4 changed files with 125 additions and 122 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 149
      components/water_cooling_temperature_control_module/water_cooling_temperature_control_module.cpp
  2. 53
      components/water_cooling_temperature_control_module/water_cooling_temperature_control_module.hpp
  3. 32
      components/zcancmder/zcan_protocol_parser.cpp
  4. 13
      components/zcancmder/zcan_protocol_parser.hpp

149
components/water_cooling_temperature_control_module/water_cooling_temperature_control_module.cpp
View File

@ -77,30 +77,29 @@ void WaterCoolingTemperatureControlModule::createDefaultConfig(config_t* cfg) {
int32_t WaterCoolingTemperatureControlModule::module_xxx_reg(int32_t param_id, bool read, int32_t& val) { int32_t WaterCoolingTemperatureControlModule::module_xxx_reg(int32_t param_id, bool read, int32_t& val) {
switch (param_id) { switch (param_id) {
MODULE_COMMON_PROCESS_REG_CB(); MODULE_COMMON_PROCESS_REG_CB();
PROCESS_REG(kreg_pid_kp, REG_GET_FLOAT(m_cfg.pid_cfg.kp, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.kp, 0.01));
PROCESS_REG(kreg_pid_ki, REG_GET_FLOAT(m_cfg.pid_cfg.ki, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.ki, 0.01));
PROCESS_REG(kreg_pid_kd, REG_GET_FLOAT(m_cfg.pid_cfg.kd, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.kd, 0.01));
PROCESS_REG(kreg_pid_max_output, REG_GET_FLOAT(m_cfg.pid_cfg.max_output, 1), REG_SET_FLOAT(m_cfg.pid_cfg.max_output, 1));
PROCESS_REG(kreg_pid_min_output, REG_GET_FLOAT(m_cfg.pid_cfg.min_output, 1), REG_SET_FLOAT(m_cfg.pid_cfg.min_output, 1));
PROCESS_REG(kreg_pid_max_integral, REG_GET_FLOAT(m_cfg.pid_cfg.max_integral, 1), REG_SET_FLOAT(m_cfg.pid_cfg.max_integral, 1));
PROCESS_REG(kreg_pid_min_integral, REG_GET_FLOAT(m_cfg.pid_cfg.min_integral, 1), REG_SET_FLOAT(m_cfg.pid_cfg.min_integral, 1));
PROCESS_REG(kreg_compute_interval, REG_GET(m_cfg.pidcompute_periodms), REG_SET(m_cfg.pidcompute_periodms));
PROCESS_REG(kreg_pid_target, REG_GET_FLOAT(m_target_temperature, 0.1), REG_SET_FLOAT(m_target_temperature, 0.1));
// PROCESS_REG(kreg_module_private0, gettemperature_sensor_state(val), ACTION_NONE);
PROCESS_REG(kreg_pid_nowoutput, REG_GET(m_pidmodule.get_output()), ACTION_NONE);
PROCESS_REG(kreg_pid_feedbackval, REG_GET(read_pid_temperature()), ACTION_NONE);
PROCESS_REG(kreg_sensor_temperature0, REG_GET(getTemperatureSensorVal(0) * 100), ACTION_NONE);
PROCESS_REG(kreg_sensor_temperature1, REG_GET(getTemperatureSensorVal(1) * 100), ACTION_NONE);
PROCESS_REG(kreg_sensor_temperature2, REG_GET(getTemperatureSensorVal(2) * 100), ACTION_NONE);
PROCESS_REG(kreg_sensor_temperature3, REG_GET(getTemperatureSensorVal(3) * 100), ACTION_NONE);
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_kp, REG_GET_FLOAT(m_cfg.pid_cfg.kp, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.kp, 0.01));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_ki, REG_GET_FLOAT(m_cfg.pid_cfg.ki, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.ki, 0.01));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_kd, REG_GET_FLOAT(m_cfg.pid_cfg.kd, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.kd, 0.01));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_max_output, REG_GET_FLOAT(m_cfg.pid_cfg.max_output, 1), REG_SET_FLOAT(m_cfg.pid_cfg.max_output, 1));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_min_output, REG_GET_FLOAT(m_cfg.pid_cfg.min_output, 1), REG_SET_FLOAT(m_cfg.pid_cfg.min_output, 1));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_max_integral, REG_GET_FLOAT(m_cfg.pid_cfg.max_integral, 1), REG_SET_FLOAT(m_cfg.pid_cfg.max_integral, 1));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_min_integral, REG_GET_FLOAT(m_cfg.pid_cfg.min_integral, 1), REG_SET_FLOAT(m_cfg.pid_cfg.min_integral, 1));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_compute_interval, REG_GET(m_cfg.pidcompute_periodms), REG_SET(m_cfg.pidcompute_periodms));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_target, REG_GET_FLOAT(m_target_temperature, 0.1), REG_SET_FLOAT(m_target_temperature, 0.1));
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_nowoutput, REG_GET(m_pidmodule.get_output()), ACTION_NONE);
PROCESS_REG(kreg_water_cooling_tmp_controler_pid_feedbackval, REG_GET(read_pid_temperature()), ACTION_NONE);
PROCESS_REG(kreg_water_cooling_tmp_controler_temp0, REG_GET(getTemperatureSensorVal(0) * 100), ACTION_NONE);
PROCESS_REG(kreg_water_cooling_tmp_controler_temp1, REG_GET(getTemperatureSensorVal(1) * 100), ACTION_NONE);
PROCESS_REG(kreg_water_cooling_tmp_controler_temp2, REG_GET(getTemperatureSensorVal(2) * 100), ACTION_NONE);
PROCESS_REG(kreg_water_cooling_tmp_controler_temp3, REG_GET(getTemperatureSensorVal(3) * 100), ACTION_NONE);
default: default:
return err::kmodule_not_find_reg; return err::kmodule_not_find_reg;
break; break;
} }
if (!read) module_active_cfg();
return 0; return 0;
} }
@ -108,14 +107,12 @@ int32_t WaterCoolingTemperatureControlModule::module_get_status(int32_t* status)
*status = getworkstate(); *status = getworkstate();
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::gettemperature_sensor_state(int32_t& state) { int32_t WaterCoolingTemperatureControlModule::gettemperature_sensor_state(int32_t& state) {
for (int32_t i = 0; i < m_n_temperature_sensor; i++) { for (int32_t i = 0; i < m_n_temperature_sensor; i++) {
state |= m_temperature_sensor[i]->isOnline() << i; state |= m_temperature_sensor[i]->isOnline() << i;
} }
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::module_active_cfg() { int32_t WaterCoolingTemperatureControlModule::module_active_cfg() {
// m_pidmodule // m_pidmodule
m_pidmodule.update_kp(m_cfg.pid_cfg.kp); m_pidmodule.update_kp(m_cfg.pid_cfg.kp);
@ -127,19 +124,19 @@ int32_t WaterCoolingTemperatureControlModule::module_active_cfg() {
m_pidmodule.update_min_integral(m_cfg.pid_cfg.min_integral); m_pidmodule.update_min_integral(m_cfg.pid_cfg.min_integral);
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::module_start() {
int32_t WaterCoolingTemperatureControlModule::temp_controler_start_hearting(int32_t targetTemperature) {
m_thread.stop(); m_thread.stop();
module_clear_error(); module_clear_error();
ZLOGI(TAG, "module_start"); ZLOGI(TAG, "module_start");
m_thread.start([this]() { workloop(); }); m_thread.start([this]() { workloop(); });
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::module_stop() {
int32_t WaterCoolingTemperatureControlModule::temp_controler_stop_hearting() {
m_thread.stop(); m_thread.stop();
return 0; return 0;
} }
void WaterCoolingTemperatureControlModule::workloop() {
int32_t WaterCoolingTemperatureControlModule::module_stop() { return temp_controler_stop_hearting(); }
void WaterCoolingTemperatureControlModule::workloop() {
/** /**
* @brief * @brief
* 启动水泵 * 启动水泵
@ -152,6 +149,8 @@ void WaterCoolingTemperatureControlModule::workloop() {
* } * }
*/ */
module_active_cfg();
pump_start(m_cfg.pumplevel); pump_start(m_cfg.pumplevel);
fan_start(m_cfg.fanlevel); fan_start(m_cfg.fanlevel);
int32_t i = 0; int32_t i = 0;
@ -193,6 +192,40 @@ void WaterCoolingTemperatureControlModule::workloop() {
#define BIT(x, n) ((x >> n) & 0x01) #define BIT(x, n) ((x >> n) & 0x01)
int32_t WaterCoolingTemperatureControlModule::getworkstate() {
if (creg.module_errorcode != 0) {
return 2;
}
if (!m_thread.isworking()) {
return 0;
} else {
return 1;
}
}
int32_t WaterCoolingTemperatureControlModule::geterrorbitflag0() {
/**
* @brief
*/
ZITemperatureSensor* sensor = m_temperature_sensor[m_hardwared_config.temp_fb_index];
int32_t errorbitflag = 0;
errorbitflag |= m_fan_ctrl->isError() << 0;
errorbitflag |= m_pump_ctrl->isError() << 1;
errorbitflag |= m_pelter_ctrl->isError() << 2;
errorbitflag |= sensor->isError() << 3;
// if (m_fanTable[1]) errorbitflag |= m_fanTable[1]->isError() << 1;
// if (m_fanTable[2]) errorbitflag |= m_fanTable[2]->isError() << 2;
// if (m_fanTable[3]) errorbitflag |= m_fanTable[3]->isError() << 3;
// if (m_pump) errorbitflag |= m_pump->isError() << 4;
// if (m_peltier_ctrl[0]) errorbitflag |= m_peltier_ctrl[0]->isFault() << 8;
// if (m_peltier_ctrl[1]) errorbitflag |= m_peltier_ctrl[1]->isFault() << 9;
return errorbitflag;
}
int32_t WaterCoolingTemperatureControlModule::checkdevice() { int32_t WaterCoolingTemperatureControlModule::checkdevice() {
uint32_t module_errorbitflag0 = geterrorbitflag0(); uint32_t module_errorbitflag0 = geterrorbitflag0();
if (module_errorbitflag0 != 0) { if (module_errorbitflag0 != 0) {
@ -202,8 +235,8 @@ int32_t WaterCoolingTemperatureControlModule::checkdevice() {
BIT(module_errorbitflag0, 2), // BIT(module_errorbitflag0, 2), //
BIT(module_errorbitflag0, 3)); BIT(module_errorbitflag0, 3));
m_pelter_ctrl->dumpErrorInfo(); m_pelter_ctrl->dumpErrorInfo();
//TODO 设置错误码
// creg.module_errorcode = err::khwardware_error;
// TODO 设置错误码
// creg.module_errorcode = err::khwardware_error;
return 1; return 1;
} }
return 0; return 0;
@ -238,7 +271,6 @@ float WaterCoolingTemperatureControlModule::read_pid_temperature() {
void WaterCoolingTemperatureControlModule::pump_start(int32_t pump_speed) { void WaterCoolingTemperatureControlModule::pump_start(int32_t pump_speed) {
ZLOGI(TAG, "pump_start %d", pump_speed); ZLOGI(TAG, "pump_start %d", pump_speed);
// m_pump->startModule(pump_speed);
m_pump_ctrl->setPumpSpeed(pump_speed); m_pump_ctrl->setPumpSpeed(pump_speed);
} }
void WaterCoolingTemperatureControlModule::pump_stop() { void WaterCoolingTemperatureControlModule::pump_stop() {
@ -249,67 +281,19 @@ void WaterCoolingTemperatureControlModule::pump_stop() {
void WaterCoolingTemperatureControlModule::fan_start(int32_t pump_speed) { void WaterCoolingTemperatureControlModule::fan_start(int32_t pump_speed) {
ZLOGI(TAG, "fan_start %d", pump_speed); ZLOGI(TAG, "fan_start %d", pump_speed);
m_fan_ctrl->setFanSpeed(pump_speed); m_fan_ctrl->setFanSpeed(pump_speed);
// for (int32_t i = 0; i < m_fanNum; i++) {
// m_fanTable[i]->startModule(pump_speed);
// }
} }
void WaterCoolingTemperatureControlModule::fan_stop() { void WaterCoolingTemperatureControlModule::fan_stop() {
ZLOGI(TAG, "fan_stop"); ZLOGI(TAG, "fan_stop");
m_fan_ctrl->stop(); m_fan_ctrl->stop();
// for (int32_t i = 0; i < m_fanNum; i++) {
// m_fanTable[i]->stopModule();
// }
} }
void WaterCoolingTemperatureControlModule::peltier_set_power_level(int32_t level) { void WaterCoolingTemperatureControlModule::peltier_set_power_level(int32_t level) {
// ZLOGI(TAG, "peltier_set_power_level %d", level);
ZLOGI(TAG, "peltier_set_power_level %d", level);
m_pelter_ctrl->setSpeed(level); m_pelter_ctrl->setSpeed(level);
// for (int32_t i = 0; i < m_peltier_ctrl_num; i++) {
// m_peltier_ctrl[i]->move(level);
// m_peltier_ctrl[i]->enable(true);
// }
} }
void WaterCoolingTemperatureControlModule::peltier_stop() { void WaterCoolingTemperatureControlModule::peltier_stop() {
ZLOGI(TAG, "peltier_stop"); ZLOGI(TAG, "peltier_stop");
m_pelter_ctrl->stop(); m_pelter_ctrl->stop();
// for (int32_t i = 0; i < m_peltier_ctrl_num; i++) {
// m_peltier_ctrl[i]->move(0);
// m_peltier_ctrl[i]->enable(false);
// }
}
int32_t WaterCoolingTemperatureControlModule::getworkstate() {
if (creg.module_errorcode != 0) {
return 2;
}
if (!m_thread.isworking()) {
return 0;
} else {
return 1;
}
}
int32_t WaterCoolingTemperatureControlModule::geterrorbitflag0() {
/**
* @brief
*/
ZITemperatureSensor* sensor = m_temperature_sensor[m_hardwared_config.temp_fb_index];
int32_t errorbitflag = 0;
errorbitflag |= m_fan_ctrl->isError() << 0;
errorbitflag |= m_pump_ctrl->isError() << 1;
errorbitflag |= m_pelter_ctrl->isError() << 2;
errorbitflag |= sensor->isError() << 3;
// if (m_fanTable[1]) errorbitflag |= m_fanTable[1]->isError() << 1;
// if (m_fanTable[2]) errorbitflag |= m_fanTable[2]->isError() << 2;
// if (m_fanTable[3]) errorbitflag |= m_fanTable[3]->isError() << 3;
// if (m_pump) errorbitflag |= m_pump->isError() << 4;
// if (m_peltier_ctrl[0]) errorbitflag |= m_peltier_ctrl[0]->isFault() << 8;
// if (m_peltier_ctrl[1]) errorbitflag |= m_peltier_ctrl[1]->isFault() << 9;
return errorbitflag;
} }
float WaterCoolingTemperatureControlModule::getTemperatureSensorVal(int32_t index) { float WaterCoolingTemperatureControlModule::getTemperatureSensorVal(int32_t index) {
@ -319,7 +303,7 @@ float WaterCoolingTemperatureControlModule::getTemperatureSensorVal(int32_t inde
} }
return m_temperature_sensor[index]->getTemperature(); return m_temperature_sensor[index]->getTemperature();
} }
int32_t WaterCoolingTemperatureControlModule::test_peltier_set_power_level(int32_t level) {
int32_t WaterCoolingTemperatureControlModule::temp_controler_set_peltier_power_level(int32_t level) {
if (level == 0) { if (level == 0) {
peltier_stop(); peltier_stop();
} else { } else {
@ -327,7 +311,7 @@ int32_t WaterCoolingTemperatureControlModule::test_peltier_set_power_level(int32
} }
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::test_pump_set_level(int32_t level) {
int32_t WaterCoolingTemperatureControlModule::temp_controler_set_pump_level(int32_t level) {
if (level == 0) { if (level == 0) {
pump_stop(); pump_stop();
} else { } else {
@ -335,7 +319,7 @@ int32_t WaterCoolingTemperatureControlModule::test_pump_set_level(int32_t level)
} }
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::test_fan_set_level(int32_t level) {
int32_t WaterCoolingTemperatureControlModule::temp_controler_set_fan_level(int32_t level) {
if (level == 0) { if (level == 0) {
fan_stop(); fan_stop();
} else { } else {
@ -343,3 +327,8 @@ int32_t WaterCoolingTemperatureControlModule::test_fan_set_level(int32_t level)
} }
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::temp_controler_enable_log(int32_t enablelog) {
ZLOGI(TAG, "temp_controler_enable_log %d", enablelog);
m_enable_log = enablelog;
return 0;
}

53
components/water_cooling_temperature_control_module/water_cooling_temperature_control_module.hpp
View File

@ -22,10 +22,10 @@
#include "sdk\components\api\zi_pwm_fan_ctrl_module.hpp" #include "sdk\components\api\zi_pwm_fan_ctrl_module.hpp"
#include "sdk\components\api\zi_pwm_pump_ctrl_module.hpp" #include "sdk\components\api\zi_pwm_pump_ctrl_module.hpp"
// //
#include "a8000_protocol\api\zi_module.hpp"
#include "pid_module.hpp" #include "pid_module.hpp"
#include "sdk\components\api\zi_temperature_sensor.hpp" #include "sdk\components\api\zi_temperature_sensor.hpp"
#include "sdk\components\ti\drv8710.hpp" #include "sdk\components\ti\drv8710.hpp"
#include "a8000_protocol\api\zi_module.hpp"
namespace iflytop { namespace iflytop {
/** /**
@ -33,7 +33,7 @@ namespace iflytop {
* 水冷温度控制模块 * 水冷温度控制模块
*/ */
class WaterCoolingTemperatureControlModule : public ZIModule {
class WaterCoolingTemperatureControlModule : public ZIModule, public ZI_WaterCoolingTemperatureControler {
ENABLE_MODULE(WaterCoolingTemperatureControlModule, ktemperature_ctrl_module, PC_VERSION); ENABLE_MODULE(WaterCoolingTemperatureControlModule, ktemperature_ctrl_module, PC_VERSION);
public: public:
@ -79,47 +79,35 @@ class WaterCoolingTemperatureControlModule : public ZIModule {
static void createDefaultConfig(config_t* cfg); static void createDefaultConfig(config_t* cfg);
void initialize(int32_t id, config_t* cfg, hardwared_config_t* hardwaredconfig);
virtual int32_t module_ping() { return 0; };
void initialize(int32_t id, config_t* cfg, hardwared_config_t* hardwaredconfig);
virtual int32_t getid(int32_t* id) override; virtual int32_t getid(int32_t* id) override;
virtual int32_t module_get_status(int32_t* status) override; virtual int32_t module_get_status(int32_t* status) override;
virtual int32_t module_active_cfg() ;
virtual int32_t module_stop() ;
virtual int32_t module_start() ;
virtual int32_t module_active_cfg() override;
virtual int32_t module_clear_error() override; virtual int32_t module_clear_error() override;
virtual int32_t module_stop() override;
int32_t read_input_state();
int32_t read_output_io_state();
virtual int32_t temp_controler_start_hearting(int32_t targetTemperature) override;
virtual int32_t temp_controler_stop_hearting() override;
virtual int32_t temp_controler_set_peltier_power_level(int32_t level) override;
virtual int32_t temp_controler_set_pump_level(int32_t level) override;
virtual int32_t temp_controler_set_fan_level(int32_t level) override;
virtual int32_t temp_controler_enable_log(int32_t enablelog) override;
private: private:
void workloop(); void workloop();
int32_t module_xxx_reg(int32_t param_id, bool read, int32_t& val); int32_t module_xxx_reg(int32_t param_id, bool read, int32_t& val);
int32_t checkdevice(); int32_t checkdevice();
float read_pid_temperature();
void pump_start(int32_t pump_speed);
void pump_stop();
void fan_start(int32_t pump_speed);
void fan_stop();
void peltier_set_power_level(int32_t level);
void peltier_stop();
void geterrorcode();
public:
int32_t test_peltier_set_power_level(int32_t level);
int32_t test_pump_set_level(int32_t level);
int32_t test_fan_set_level(int32_t level);
float read_pid_temperature();
void pump_start(int32_t pump_speed);
void pump_stop();
void fan_start(int32_t pump_speed);
void fan_stop();
void peltier_set_power_level(int32_t level);
void peltier_stop();
void geterrorcode();
private: private:
int32_t getworkstate(); int32_t getworkstate();
@ -129,7 +117,6 @@ class WaterCoolingTemperatureControlModule : public ZIModule {
int32_t gettemperature_sensor_state(int32_t& state); int32_t gettemperature_sensor_state(int32_t& state);
float getTemperatureSensorVal(int32_t index); float getTemperatureSensorVal(int32_t index);
}; };
} // namespace iflytop } // namespace iflytop

32
components/zcancmder/zcan_protocol_parser.cpp
View File

@ -68,8 +68,12 @@ void ZCanProtocolParser::initialize(IZCanReceiver* cancmder) {
REGFN(pipette_ctrl_put_tip); REGFN(pipette_ctrl_put_tip);
REGFN(pipette_ctrl_move_to_ul); REGFN(pipette_ctrl_move_to_ul);
REGFN(water_cooling_temp_start_hearting);
REGFN(water_cooling_temp_stop_hearting);
REGFN(temp_controler_start_hearting);
REGFN(temp_controler_stop_hearting);
REGFN(temp_controler_set_peltier_power_level);
REGFN(temp_controler_set_pump_level);
REGFN(temp_controler_set_fan_level);
REGFN(temp_controler_enable_log);
REGFN(fan_controler_set_speed); REGFN(fan_controler_set_speed);
#if 0 #if 0
@ -450,13 +454,29 @@ int32_t ZCanProtocolParser::pipette_ctrl_move_to_ul(cmdcontxt_t* cxt) {
#undef MODULE_CLASS #undef MODULE_CLASS
#define MODULE_CLASS ZI_WaterCoolingTemperatureControler #define MODULE_CLASS ZI_WaterCoolingTemperatureControler
int32_t ZCanProtocolParser::water_cooling_temp_start_hearting(cmdcontxt_t* cxt) {
int32_t ZCanProtocolParser::temp_controler_start_hearting(cmdcontxt_t* cxt) {
CHECK_AND_GET_MODULE(1); CHECK_AND_GET_MODULE(1);
return module->water_cooling_temp_start_hearting(cxt->params[0]);
return module->temp_controler_start_hearting(cxt->params[0]);
} }
int32_t ZCanProtocolParser::water_cooling_temp_stop_hearting(cmdcontxt_t* cxt) {
int32_t ZCanProtocolParser::temp_controler_stop_hearting(cmdcontxt_t* cxt) {
CHECK_AND_GET_MODULE(0); CHECK_AND_GET_MODULE(0);
return module->water_cooling_temp_stop_hearting();
return module->temp_controler_stop_hearting();
}
int32_t ZCanProtocolParser::temp_controler_set_peltier_power_level(cmdcontxt_t* cxt) {
CHECK_AND_GET_MODULE(1);
return module->temp_controler_set_peltier_power_level(cxt->params[0]);
}
int32_t ZCanProtocolParser::temp_controler_set_pump_level(cmdcontxt_t* cxt) {
CHECK_AND_GET_MODULE(1);
return module->temp_controler_set_pump_level(cxt->params[0]);
}
int32_t ZCanProtocolParser::temp_controler_set_fan_level(cmdcontxt_t* cxt) {
CHECK_AND_GET_MODULE(1);
return module->temp_controler_set_fan_level(cxt->params[0]);
}
int32_t ZCanProtocolParser::temp_controler_enable_log(cmdcontxt_t* cxt) {
CHECK_AND_GET_MODULE(1);
return module->temp_controler_enable_log(cxt->params[0]);
} }
#undef MODULE_CLASS #undef MODULE_CLASS

13
components/zcancmder/zcan_protocol_parser.hpp
View File

@ -101,9 +101,16 @@ class ZCanProtocolParser : public IZCanReceiverListener {
static int32_t pipette_ctrl_put_tip(cmdcontxt_t* cxt); static int32_t pipette_ctrl_put_tip(cmdcontxt_t* cxt);
static int32_t pipette_ctrl_move_to_ul(cmdcontxt_t* cxt); static int32_t pipette_ctrl_move_to_ul(cmdcontxt_t* cxt);
static int32_t water_cooling_temp_start_hearting(cmdcontxt_t* cxt);
static int32_t water_cooling_temp_stop_hearting(cmdcontxt_t* cxt);
static int32_t temp_controler_start_hearting(cmdcontxt_t* cxt);
static int32_t temp_controler_stop_hearting(cmdcontxt_t* cxt);
static int32_t temp_controler_set_peltier_power_level(cmdcontxt_t* cxt);
static int32_t temp_controler_set_pump_level(cmdcontxt_t* cxt);
static int32_t temp_controler_set_fan_level(cmdcontxt_t* cxt);
static int32_t temp_controler_enable_log(cmdcontxt_t* cxt);
/***********************************************************************************************************************
* 风扇控制 *
***********************************************************************************************************************/
static int32_t fan_controler_set_speed(cmdcontxt_t* cxt); static int32_t fan_controler_set_speed(cmdcontxt_t* cxt);
#if 0 #if 0
static int32_t xymotor_enable(cmdcontxt_t* cxt); static int32_t xymotor_enable(cmdcontxt_t* cxt);

Write Preview
Loading…
Cancel
Save