Browse Source

update

master
zhaohe 2 years ago
parent
commit
095edb8324
  1. 147
      components/step_motor_ctrl_module/step_motor_ctrl_module.cpp
  2. 20
      components/step_motor_ctrl_module/step_motor_ctrl_module.hpp
  3. 123
      components/xy_robot_ctrl_module/xy_robot_ctrl_module.cpp
  4. 11
      components/xy_robot_ctrl_module/xy_robot_ctrl_module.hpp
  5. 272
      components/zprotocol_helper/micro_computer_module_device_script_cmder_paser.cpp
  6. 8
      components/zprotocol_helper/micro_computer_module_device_script_cmder_paser.hpp
  7. 2
      components/zprotocols/zcancmder_v2

147
components/step_motor_ctrl_module/step_motor_ctrl_module.cpp

@ -219,6 +219,7 @@ int32_t StepMotorCtrlModule::enable(bool venable) {
zlock_guard l(m_lock); zlock_guard l(m_lock);
ZLOGI(TAG, "m%d enable %d", m_id, venable); ZLOGI(TAG, "m%d enable %d", m_id, venable);
m_stepM1->enable(venable); m_stepM1->enable(venable);
m_enable = venable;
return 0; return 0;
} }
int32_t StepMotorCtrlModule::stop(uint8_t stopType) { int32_t StepMotorCtrlModule::stop(uint8_t stopType) {
@ -255,11 +256,11 @@ int32_t StepMotorCtrlModule::rotate(int32_t speed, int32_t lastforms, action_cb_
_rotate(speed, m_param.acc, m_param.dec); _rotate(speed, m_param.acc, m_param.dec);
int32_t startticket = zos_get_tick(); int32_t startticket = zos_get_tick();
//bool reachtime = false;
// bool reachtime = false;
while (!m_thread.getExitFlag()) { while (!m_thread.getExitFlag()) {
if ((int32_t)zos_haspassedms(startticket) > lastforms && lastforms != 0) { if ((int32_t)zos_haspassedms(startticket) > lastforms && lastforms != 0) {
//reachtime = true;
// reachtime = true;
m_stepM1->stop(); m_stepM1->stop();
break; break;
} }
@ -294,7 +295,7 @@ int32_t StepMotorCtrlModule::read_detailed_status(detailed_status_t& debug_info)
debug_info.io_state |= (0x01 << i); debug_info.io_state |= (0x01 << i);
} }
} }
debug_info.last_exec_status = m_lastexecstatus;
debug_info.last_exec_status = m_module_last_cmd_exec_status;
getnowpos(debug_info.x); getnowpos(debug_info.x);
return 0; return 0;
} }
@ -558,8 +559,8 @@ int32_t StepMotorCtrlModule::move_by_block(int32_t dx, int32_t velocity, int ove
} }
void StepMotorCtrlModule::call_exec_status_cb(int32_t status, action_cb_status_t status_cb) { void StepMotorCtrlModule::call_exec_status_cb(int32_t status, action_cb_status_t status_cb) {
m_lastexecstatus = status;
auto cache_status_cb = m_status_cb;
m_module_last_cmd_exec_status = status;
auto cache_status_cb = m_status_cb;
if (cache_status_cb) cache_status_cb(status); if (cache_status_cb) cache_status_cb(status);
} }
void StepMotorCtrlModule::create_default_cfg(flash_config_t& cfg) { void StepMotorCtrlModule::create_default_cfg(flash_config_t& cfg) {
@ -613,7 +614,7 @@ int32_t StepMotorCtrlModule::getid(int32_t* id) {
int32_t StepMotorCtrlModule::module_stop() { return stop(0); } int32_t StepMotorCtrlModule::module_stop() { return stop(0); }
int32_t StepMotorCtrlModule::module_break() { return stop(0); } int32_t StepMotorCtrlModule::module_break() { return stop(0); }
int32_t StepMotorCtrlModule::module_get_last_exec_status(int32_t* status) { int32_t StepMotorCtrlModule::module_get_last_exec_status(int32_t* status) {
*status = m_lastexecstatus;
*status = m_module_last_cmd_exec_status;
return 0; return 0;
} }
int32_t StepMotorCtrlModule::module_get_status(int32_t* status) { int32_t StepMotorCtrlModule::module_get_status(int32_t* status) {
@ -651,45 +652,81 @@ int32_t StepMotorCtrlModule::module_get_error(int32_t* iserror) {
#endif #endif
#define SET_CONFIG(param_id, configval) \
case param_id: \
if (set) { \
configval = param_value; \
} else { \
param_value = configval; \
} \
#define SET_REG(param_id, modulereg) \
case param_id: \
modulereg = val; \
break; break;
int32_t StepMotorCtrlModule::_module_set_or_get_param(bool set, int32_t param_id, int32_t& param_value) {
#define GET_REG(param_id, modulereg) \
case param_id: \
*val = modulereg; \
break;
int32_t StepMotorCtrlModule::module_set_param(int32_t param_id, int32_t val) {
switch (param_id) { switch (param_id) {
SET_CONFIG(kcfg_motor_x_shift, m_param.shift_x);
SET_CONFIG(kcfg_motor_x_shaft, m_param.x_shaft);
SET_CONFIG(kcfg_motor_x_one_circle_pulse, m_param.distance_scale);
SET_CONFIG(kcfg_motor_default_velocity, m_param.maxspeed);
SET_CONFIG(kcfg_motor_default_acc, m_param.acc);
SET_CONFIG(kcfg_motor_default_dec, m_param.dec);
// SET_CONFIG(kcfg_motor_default_break_dec, m_param.dec);
SET_CONFIG(kcfg_motor_run_to_zero_max_x_d, m_param.run_to_zero_max_d);
SET_CONFIG(kcfg_motor_look_zero_edge_max_x_d, m_param.look_zero_edge_max_d);
SET_CONFIG(kcfg_motor_run_to_zero_speed, m_param.run_to_zero_speed);
SET_CONFIG(kcfg_motor_run_to_zero_dec, m_param.run_to_zero_dec);
SET_CONFIG(kcfg_motor_look_zero_edge_speed, m_param.look_zero_edge_speed);
SET_CONFIG(kcfg_motor_look_zero_edge_dec, m_param.look_zero_edge_dec);
SET_CONFIG(k_cfg_stepmotor_ihold, m_param.ihold);
SET_CONFIG(k_cfg_stepmotor_irun, m_param.irun);
SET_CONFIG(k_cfg_stepmotor_iholddelay, m_param.iholddelay);
SET_REG(kreg_motor_x_shift, m_param.shift_x);
SET_REG(kreg_motor_x_shaft, m_param.x_shaft);
SET_REG(kreg_motor_x_one_circle_pulse, m_param.distance_scale);
SET_REG(kreg_motor_default_velocity, m_param.maxspeed);
SET_REG(kreg_motor_default_acc, m_param.acc);
SET_REG(kreg_motor_default_dec, m_param.dec);
// SET_REG(kreg_motor_default_break_dec, m_param.dec);
SET_REG(kreg_motor_run_to_zero_max_x_d, m_param.run_to_zero_max_d);
SET_REG(kreg_motor_look_zero_edge_max_x_d, m_param.look_zero_edge_max_d);
SET_REG(kreg_motor_run_to_zero_speed, m_param.run_to_zero_speed);
SET_REG(kreg_motor_run_to_zero_dec, m_param.run_to_zero_dec);
SET_REG(kreg_motor_look_zero_edge_speed, m_param.look_zero_edge_speed);
SET_REG(kreg_motor_look_zero_edge_dec, m_param.look_zero_edge_dec);
SET_REG(kreg_stepmotor_ihold, m_param.ihold);
SET_REG(kreg_stepmotor_irun, m_param.irun);
SET_REG(kreg_stepmotor_iholddelay, m_param.iholddelay);
default: default:
return err::kmodule_not_find_config_index; return err::kmodule_not_find_config_index;
} }
return 0; return 0;
} }
int32_t StepMotorCtrlModule::module_get_param(int32_t param_id, int32_t* val) {
int32_t nowpos = 0;
read_pos(nowpos);
int32_t StepMotorCtrlModule::module_set_param(int32_t param_id, int32_t param_value) {
return _module_set_or_get_param(true, param_id, param_value);
}
int32_t StepMotorCtrlModule::module_get_param(int32_t param_id, int32_t* param_value) {
return _module_set_or_get_param(false, param_id, *param_value);
switch (param_id) {
GET_REG(kreg_motor_x_shift, m_param.shift_x);
GET_REG(kreg_motor_x_shaft, m_param.x_shaft);
GET_REG(kreg_motor_x_one_circle_pulse, m_param.distance_scale);
GET_REG(kreg_motor_default_velocity, m_param.maxspeed);
GET_REG(kreg_motor_default_acc, m_param.acc);
GET_REG(kreg_motor_default_dec, m_param.dec);
// GET_REG(kreg_motor_default_break_dec, m_param.dec);
GET_REG(kreg_motor_run_to_zero_max_x_d, m_param.run_to_zero_max_d);
GET_REG(kreg_motor_look_zero_edge_max_x_d, m_param.look_zero_edge_max_d);
GET_REG(kreg_motor_run_to_zero_speed, m_param.run_to_zero_speed);
GET_REG(kreg_motor_run_to_zero_dec, m_param.run_to_zero_dec);
GET_REG(kreg_motor_look_zero_edge_speed, m_param.look_zero_edge_speed);
GET_REG(kreg_motor_look_zero_edge_dec, m_param.look_zero_edge_dec);
GET_REG(kreg_stepmotor_ihold, m_param.ihold);
GET_REG(kreg_stepmotor_irun, m_param.irun);
GET_REG(kreg_stepmotor_iholddelay, m_param.iholddelay);
GET_REG(kreg_module_status, m_thread.isworking() ? 0x01 : 0x00);
GET_REG(kreg_module_errorcode, 0);
GET_REG(kreg_module_enableflag, m_enable);
GET_REG(kreg_robot_x_pos, nowpos);
GET_REG(kreg_module_last_cmd_exec_status, m_module_last_cmd_exec_status);
GET_REG(kreg_module_last_cmd_exec_val0, m_module_last_cmd_exec_val0);
GET_REG(kreg_module_last_cmd_exec_val1, m_module_last_cmd_exec_val1);
GET_REG(kreg_module_last_cmd_exec_val2, m_module_last_cmd_exec_val2);
GET_REG(kreg_module_last_cmd_exec_val3, m_module_last_cmd_exec_val3);
GET_REG(kreg_module_last_cmd_exec_val4, m_module_last_cmd_exec_val4);
GET_REG(kreg_module_last_cmd_exec_val5, m_module_last_cmd_exec_val5);
default:
return err::kmodule_not_find_config_index;
}
return 0;
} }
int32_t StepMotorCtrlModule::module_clear_error() { return 0; } int32_t StepMotorCtrlModule::module_clear_error() { return 0; }
int32_t StepMotorCtrlModule::module_readio(int32_t* io) { int32_t StepMotorCtrlModule::module_readio(int32_t* io) {
@ -714,14 +751,10 @@ int32_t StepMotorCtrlModule::module_active_cfg() {
return 0; return 0;
} }
int32_t StepMotorCtrlModule::motor_enable(int32_t enable) {
int32_t StepMotorCtrlModule::motor_enable(int32_t varenable) {
zlock_guard l(m_lock); zlock_guard l(m_lock);
ZLOGI(TAG, "m%d motor_enable %d", m_id, enable);
if (enable != 0) {
m_stepM1->enable(true);
} else {
m_stepM1->enable(false);
}
ZLOGI(TAG, "m%d motor_enable %ld", m_id, varenable);
enable(varenable);
return 0; return 0;
} }
int32_t StepMotorCtrlModule::motor_rotate(int32_t direction, int32_t motor_velocity, int32_t acc) { int32_t StepMotorCtrlModule::motor_rotate(int32_t direction, int32_t motor_velocity, int32_t acc) {
@ -804,3 +837,33 @@ int32_t StepMotorCtrlModule::motor_read_pos(int32_t* pos) {
*pos = xnow; *pos = xnow;
return 0; return 0;
} }
void StepMotorCtrlModule::set_last_exec_status(int32_t ecode, int32_t val0, int32_t val1, int32_t val2, int32_t val3, int32_t val4, int32_t val5) {
m_module_last_cmd_exec_status = ecode;
m_module_last_cmd_exec_val0 = val0;
m_module_last_cmd_exec_val1 = val1;
m_module_last_cmd_exec_val2 = val2;
m_module_last_cmd_exec_val3 = val3;
m_module_last_cmd_exec_val4 = val4;
m_module_last_cmd_exec_val5 = val5;
}
int32_t StepMotorCtrlModule::motor_calculated_pos_by_move_to_zero() {
zlock_guard lock(m_lock);
ZLOGI(TAG, "motor_calculated_pos_by_move_to_zero");
m_status_cb = nullptr;
m_thread.stop();
m_thread.start(
[this]() {
//
int32_t dx;
int32_t erro = exec_move_to_zero_task(dx);
if (erro != 0) {
set_last_exec_status(erro);
} else {
m_module_last_cmd_exec_status = erro;
set_last_exec_status(erro, dx + m_param.shift_x);
}
},
[this]() { _motor_stop(); });
return 0;
}

20
components/step_motor_ctrl_module/step_motor_ctrl_module.hpp

@ -22,8 +22,8 @@ class StepMotorCtrlModule : public I_StepMotorCtrlModule, public ZIModule, publi
flash_config_t m_flash_config; flash_config_t m_flash_config;
base_param_t& m_param = m_flash_config.base_param; base_param_t& m_param = m_flash_config.base_param;
// bool m_x_shaft = false; // bool m_x_shaft = false;
int32_t m_lastexecstatus = 0;
int32_t m_default_speed = 0;
// int32_t m_lastexecstatus = 0;
int32_t m_default_speed = 0;
ZGPIO* m_iotable; ZGPIO* m_iotable;
int m_nio; int m_nio;
@ -32,12 +32,22 @@ class StepMotorCtrlModule : public I_StepMotorCtrlModule, public ZIModule, publi
const char* m_flashmark = nullptr; const char* m_flashmark = nullptr;
action_cb_status_t m_status_cb; action_cb_status_t m_status_cb;
int32_t m_enable = 0;
int32_t m_module_last_cmd_exec_status = 0;
int32_t m_module_last_cmd_exec_val0 = 0;
int32_t m_module_last_cmd_exec_val1 = 0;
int32_t m_module_last_cmd_exec_val2 = 0;
int32_t m_module_last_cmd_exec_val3 = 0;
int32_t m_module_last_cmd_exec_val4 = 0;
int32_t m_module_last_cmd_exec_val5 = 0;
public: public:
void initialize(int moduleid, IStepperMotor* stepM, ZGPIO iotable[], int nio, const char* flashmark); void initialize(int moduleid, IStepperMotor* stepM, ZGPIO iotable[], int nio, const char* flashmark);
static void create_default_cfg(flash_config_t& cfg); static void create_default_cfg(flash_config_t& cfg);
virtual bool isbusy() override; virtual bool isbusy() override;
virtual int32_t get_last_exec_status() override { return m_lastexecstatus; };
virtual int32_t get_last_exec_status() override { return m_module_last_cmd_exec_status; };
virtual int32_t move_to(int32_t tox, action_cb_status_t status_cb) override; virtual int32_t move_to(int32_t tox, action_cb_status_t status_cb) override;
virtual int32_t move_by(int32_t dx, action_cb_status_t status_cb) override; virtual int32_t move_by(int32_t dx, action_cb_status_t status_cb) override;
@ -113,7 +123,6 @@ class StepMotorCtrlModule : public I_StepMotorCtrlModule, public ZIModule, publi
virtual int32_t module_set_param(int32_t param_id, int32_t param_value) override; virtual int32_t module_set_param(int32_t param_id, int32_t param_value) override;
virtual int32_t module_get_param(int32_t param_id, int32_t* param_value) override; virtual int32_t module_get_param(int32_t param_id, int32_t* param_value) override;
int32_t _module_set_or_get_param(bool set, int32_t param_id, int32_t& param_value);
virtual int32_t module_readio(int32_t* io) override; virtual int32_t module_readio(int32_t* io) override;
@ -144,6 +153,8 @@ class StepMotorCtrlModule : public I_StepMotorCtrlModule, public ZIModule, publi
virtual int32_t motor_move_to_zero_forward_and_calculated_shift(int32_t findzerospeed, int32_t findzeroedge_speed, int32_t acc, int32_t overtime) override; virtual int32_t motor_move_to_zero_forward_and_calculated_shift(int32_t findzerospeed, int32_t findzeroedge_speed, int32_t acc, int32_t overtime) override;
virtual int32_t motor_move_to_zero_backward_and_calculated_shift(int32_t findzerospeed, int32_t findzeroedge_speed, int32_t acc, int32_t overtime) override; virtual int32_t motor_move_to_zero_backward_and_calculated_shift(int32_t findzerospeed, int32_t findzeroedge_speed, int32_t acc, int32_t overtime) override;
virtual int32_t motor_calculated_pos_by_move_to_zero() override;
private: private:
void active_cfg(); void active_cfg();
@ -168,5 +179,6 @@ class StepMotorCtrlModule : public I_StepMotorCtrlModule, public ZIModule, publi
int32_t _move_by(int32_t dx, action_cb_status_t status_cb); int32_t _move_by(int32_t dx, action_cb_status_t status_cb);
void call_exec_status_cb(int32_t status, action_cb_status_t status_cb); void call_exec_status_cb(int32_t status, action_cb_status_t status_cb);
void set_last_exec_status(int32_t ecode, int32_t val0 = 0, int32_t val1 = 0, int32_t val2 = 0, int32_t val3 = 0, int32_t val4 = 0, int32_t val5 = 0);
}; };
} // namespace iflytop } // namespace iflytop

123
components/xy_robot_ctrl_module/xy_robot_ctrl_module.cpp

@ -630,47 +630,91 @@ int32_t XYRobotCtrlModule::module_get_error(int32_t* iserror) {
return 0; return 0;
} }
int32_t XYRobotCtrlModule::module_clear_error() { return 0; } int32_t XYRobotCtrlModule::module_clear_error() { return 0; }
int32_t XYRobotCtrlModule::module_set_param(int32_t param_id, int32_t param_value) { return _module_set_or_get_param(true, param_id, param_value); }
int32_t XYRobotCtrlModule::module_get_param(int32_t param_id, int32_t* param_value) { return _module_set_or_get_param(false, param_id, *param_value); }
#define SET_CONFIG(param_id, configval, param_value) \
case param_id: \
if (set) { \
configval = param_value; \
} else { \
param_value = configval; \
} \
#define SET_REG(param_id, modulereg) \
case param_id: \
modulereg = val; \
break;
#define GET_REG(param_id, modulereg) \
case param_id: \
*val = modulereg; \
break; break;
int32_t XYRobotCtrlModule::_module_set_or_get_param(bool set, int32_t param_id, int32_t& param_value) {
switch (param_id) {
SET_CONFIG(kcfg_motor_x_shift, m_basecfg.shift_x, param_value);
SET_CONFIG(kcfg_motor_y_shift, m_basecfg.shift_y, param_value);
SET_CONFIG(kcfg_motor_x_shaft, m_basecfg.x_shaft, param_value);
SET_CONFIG(kcfg_motor_y_shaft, m_basecfg.y_shaft, param_value);
SET_CONFIG(kcfg_motor_x_one_circle_pulse, m_basecfg.distance_scale, param_value);
SET_CONFIG(kcfg_motor_y_one_circle_pulse, m_basecfg.distance_scale, param_value);
SET_CONFIG(kcfg_motor_default_velocity, m_basecfg.maxspeed, param_value);
SET_CONFIG(kcfg_motor_default_acc, m_basecfg.acc, param_value);
SET_CONFIG(kcfg_motor_default_dec, m_basecfg.dec, param_value);
SET_CONFIG(kcfg_motor_default_break_dec, m_basecfg.breakdec, param_value);
SET_CONFIG(kcfg_motor_run_to_zero_max_x_d, m_basecfg.run_to_zero_max_d, param_value);
SET_CONFIG(kcfg_motor_run_to_zero_max_y_d, m_basecfg.run_to_zero_max_d, param_value);
SET_CONFIG(kcfg_motor_look_zero_edge_max_x_d, m_basecfg.look_zero_edge_max_d, param_value);
SET_CONFIG(kcfg_motor_look_zero_edge_max_y_d, m_basecfg.look_zero_edge_max_d, param_value);
SET_CONFIG(kcfg_motor_run_to_zero_speed, m_basecfg.run_to_zero_speed, param_value);
SET_CONFIG(kcfg_motor_run_to_zero_dec, m_basecfg.run_to_zero_dec, param_value);
SET_CONFIG(kcfg_motor_look_zero_edge_speed, m_basecfg.look_zero_edge_speed, param_value);
SET_CONFIG(kcfg_motor_look_zero_edge_dec, m_basecfg.look_zero_edge_dec, param_value);
SET_CONFIG(k_cfg_stepmotor_ihold, m_basecfg.ihold, param_value);
SET_CONFIG(k_cfg_stepmotor_irun, m_basecfg.irun, param_value);
SET_CONFIG(k_cfg_stepmotor_iholddelay, m_basecfg.iholddelay, param_value);
SET_CONFIG(k_cfg_xyrobot_robot_type, m_basecfg.robot_type, param_value);
int32_t XYRobotCtrlModule::module_set_param(int32_t param_id, int32_t val) {
switch (param_id) {
SET_REG(kreg_motor_x_shift, m_basecfg.shift_x);
SET_REG(kreg_motor_y_shift, m_basecfg.shift_y);
SET_REG(kreg_motor_x_shaft, m_basecfg.x_shaft);
SET_REG(kreg_motor_y_shaft, m_basecfg.y_shaft);
SET_REG(kreg_motor_x_one_circle_pulse, m_basecfg.distance_scale);
SET_REG(kreg_motor_y_one_circle_pulse, m_basecfg.distance_scale);
SET_REG(kreg_motor_default_velocity, m_basecfg.maxspeed);
SET_REG(kreg_motor_default_acc, m_basecfg.acc);
SET_REG(kreg_motor_default_dec, m_basecfg.dec);
SET_REG(kreg_motor_default_break_dec, m_basecfg.breakdec);
SET_REG(kreg_motor_run_to_zero_max_x_d, m_basecfg.run_to_zero_max_d);
SET_REG(kreg_motor_run_to_zero_max_y_d, m_basecfg.run_to_zero_max_d);
SET_REG(kreg_motor_look_zero_edge_max_x_d, m_basecfg.look_zero_edge_max_d);
SET_REG(kreg_motor_look_zero_edge_max_y_d, m_basecfg.look_zero_edge_max_d);
SET_REG(kreg_motor_run_to_zero_speed, m_basecfg.run_to_zero_speed);
SET_REG(kreg_motor_run_to_zero_dec, m_basecfg.run_to_zero_dec);
SET_REG(kreg_motor_look_zero_edge_speed, m_basecfg.look_zero_edge_speed);
SET_REG(kreg_motor_look_zero_edge_dec, m_basecfg.look_zero_edge_dec);
SET_REG(kreg_stepmotor_ihold, m_basecfg.ihold);
SET_REG(kreg_stepmotor_irun, m_basecfg.irun);
SET_REG(kreg_stepmotor_iholddelay, m_basecfg.iholddelay);
SET_REG(kreg_xyrobot_robot_type, m_basecfg.robot_type);
default: default:
return err::kmodule_not_find_config_index; return err::kmodule_not_find_config_index;
} }
return 0;
} }
int32_t XYRobotCtrlModule::module_get_param(int32_t param_id, int32_t* val) {
switch (param_id) {
GET_REG(kreg_motor_x_shift, m_basecfg.shift_x);
GET_REG(kreg_motor_y_shift, m_basecfg.shift_y);
GET_REG(kreg_motor_x_shaft, m_basecfg.x_shaft);
GET_REG(kreg_motor_y_shaft, m_basecfg.y_shaft);
GET_REG(kreg_motor_x_one_circle_pulse, m_basecfg.distance_scale);
GET_REG(kreg_motor_y_one_circle_pulse, m_basecfg.distance_scale);
GET_REG(kreg_motor_default_velocity, m_basecfg.maxspeed);
GET_REG(kreg_motor_default_acc, m_basecfg.acc);
GET_REG(kreg_motor_default_dec, m_basecfg.dec);
GET_REG(kreg_motor_default_break_dec, m_basecfg.breakdec);
GET_REG(kreg_motor_run_to_zero_max_x_d, m_basecfg.run_to_zero_max_d);
GET_REG(kreg_motor_run_to_zero_max_y_d, m_basecfg.run_to_zero_max_d);
GET_REG(kreg_motor_look_zero_edge_max_x_d, m_basecfg.look_zero_edge_max_d);
GET_REG(kreg_motor_look_zero_edge_max_y_d, m_basecfg.look_zero_edge_max_d);
GET_REG(kreg_motor_run_to_zero_speed, m_basecfg.run_to_zero_speed);
GET_REG(kreg_motor_run_to_zero_dec, m_basecfg.run_to_zero_dec);
GET_REG(kreg_motor_look_zero_edge_speed, m_basecfg.look_zero_edge_speed);
GET_REG(kreg_motor_look_zero_edge_dec, m_basecfg.look_zero_edge_dec);
GET_REG(kreg_stepmotor_ihold, m_basecfg.ihold);
GET_REG(kreg_stepmotor_irun, m_basecfg.irun);
GET_REG(kreg_stepmotor_iholddelay, m_basecfg.iholddelay);
GET_REG(kreg_xyrobot_robot_type, m_basecfg.robot_type);
GET_REG(kreg_module_status, m_thread.isworking() ? 0x01 : 0x00);
GET_REG(kreg_module_errorcode, 0);
GET_REG(kreg_module_enableflag, m_enable);
GET_REG(kreg_robot_x_pos, m_x);
GET_REG(kreg_robot_y_pos, m_y);
GET_REG(kreg_module_last_cmd_exec_status, m_module_last_cmd_exec_status);
GET_REG(kreg_module_last_cmd_exec_val0, m_module_last_cmd_exec_val0);
GET_REG(kreg_module_last_cmd_exec_val1, m_module_last_cmd_exec_val1);
GET_REG(kreg_module_last_cmd_exec_val2, m_module_last_cmd_exec_val2);
GET_REG(kreg_module_last_cmd_exec_val3, m_module_last_cmd_exec_val3);
GET_REG(kreg_module_last_cmd_exec_val4, m_module_last_cmd_exec_val4);
GET_REG(kreg_module_last_cmd_exec_val5, m_module_last_cmd_exec_val5);
// GET_REG(kreg_xyrobot_x_dpos, m_dx);
// GET_REG(kreg_xyrobot_y_dpos, m_dy);
default:
return err::kmodule_not_find_config_index;
}
}
#if 0
int32_t XYRobotCtrlModule::module_set_state(int32_t state_id, int32_t state_value) { return err::kmodule_not_find_state_index; } int32_t XYRobotCtrlModule::module_set_state(int32_t state_id, int32_t state_value) { return err::kmodule_not_find_state_index; }
int32_t XYRobotCtrlModule::module_get_state(int32_t state_id, int32_t* state_value) { int32_t XYRobotCtrlModule::module_get_state(int32_t state_id, int32_t* state_value) {
#if 0 #if 0
@ -706,7 +750,7 @@ kstate_xyrobot_y_dpos
return err::kmodule_not_find_state_index; return err::kmodule_not_find_state_index;
} }
} }
#endif
int32_t XYRobotCtrlModule::module_readio(int32_t* io) { int32_t XYRobotCtrlModule::module_readio(int32_t* io) {
*io = 0; *io = 0;
for (int i = 0; i < m_ngpio; i++) { for (int i = 0; i < m_ngpio; i++) {
@ -752,11 +796,18 @@ int32_t XYRobotCtrlModule::xymotor_calculated_pos_by_move_to_zero() {
if (erro != 0) { if (erro != 0) {
m_dx = 0; m_dx = 0;
m_dy = 0; m_dy = 0;
m_module_last_cmd_exec_status = err::kmodule_opeation_break_by_user;
m_module_last_cmd_exec_val0 = 0;
m_module_last_cmd_exec_val1 = 0;
_motor_stop(); _motor_stop();
return; return;
} }
m_dx = dx; m_dx = dx;
m_dy = dy; m_dy = dy;
m_module_last_cmd_exec_status = 0;
m_module_last_cmd_exec_val0 = m_dx;
m_module_last_cmd_exec_val1 = m_dy;
m_stepM1->setXACTUAL(0); m_stepM1->setXACTUAL(0);
m_stepM2->setXACTUAL(0); m_stepM2->setXACTUAL(0);
return; return;

11
components/xy_robot_ctrl_module/xy_robot_ctrl_module.hpp

@ -23,6 +23,14 @@ class XYRobotCtrlModule : public I_XYRobotCtrlModule, public ZIXYMotor, public Z
int32_t m_moduleId; int32_t m_moduleId;
int32_t m_module_last_cmd_exec_status = 0;
int32_t m_module_last_cmd_exec_val0 = 0;
int32_t m_module_last_cmd_exec_val1 = 0;
int32_t m_module_last_cmd_exec_val2 = 0;
int32_t m_module_last_cmd_exec_val3 = 0;
int32_t m_module_last_cmd_exec_val4 = 0;
int32_t m_module_last_cmd_exec_val5 = 0;
int m_x = 0; int m_x = 0;
int m_y = 0; int m_y = 0;
@ -88,8 +96,6 @@ class XYRobotCtrlModule : public I_XYRobotCtrlModule, public ZIXYMotor, public Z
virtual int32_t module_factory_reset(); virtual int32_t module_factory_reset();
virtual int32_t module_flush_cfg(); virtual int32_t module_flush_cfg();
virtual int32_t module_active_cfg(); virtual int32_t module_active_cfg();
virtual int32_t module_set_state(int32_t state_id, int32_t state_value);
virtual int32_t module_get_state(int32_t state_id, int32_t* state_value);
virtual int32_t xymotor_enable(int32_t enable); virtual int32_t xymotor_enable(int32_t enable);
virtual int32_t xymotor_move_by(int32_t dx, int32_t dy, int32_t motor_velocity); virtual int32_t xymotor_move_by(int32_t dx, int32_t dy, int32_t motor_velocity);
@ -100,7 +106,6 @@ class XYRobotCtrlModule : public I_XYRobotCtrlModule, public ZIXYMotor, public Z
virtual int32_t xymotor_calculated_pos_by_move_to_zero(); virtual int32_t xymotor_calculated_pos_by_move_to_zero();
private: private:
virtual int32_t _module_set_or_get_param(bool set, int32_t param_id, int32_t& param_value);
void active_cfg(); void active_cfg();
void computeTargetMotorPos(); void computeTargetMotorPos();

272
components/zprotocol_helper/micro_computer_module_device_script_cmder_paser.cpp

@ -5,21 +5,20 @@
#include <string.h> #include <string.h>
#include "sdk/os/zos.hpp" #include "sdk/os/zos.hpp"
#include "sdk\components\zprotocols\zcancmder_v2\api\state_index.hpp"
using namespace iflytop; using namespace iflytop;
using namespace std; using namespace std;
#define TAG "CMD" #define TAG "CMD"
void MicroComputerModuleDeviceScriptCmderPaser::do_dumpconfig(int32_t moduleId) {
void MicroComputerModuleDeviceScriptCmderPaser::do_dumpreg(int32_t moduleId) {
ICmdParserACK ack; ICmdParserACK ack;
const char paraV_cache[1][10] = {{0}}; const char paraV_cache[1][10] = {{0}};
sprintf((char*)paraV_cache[0], "%ld", moduleId); sprintf((char*)paraV_cache[0], "%ld", moduleId);
const char* paraV[1] = {paraV_cache[0]}; const char* paraV[1] = {paraV_cache[0]};
do_dumpconfig(1, (const char**)paraV, &ack);
do_dumpreg(1, (const char**)paraV, &ack);
} }
void MicroComputerModuleDeviceScriptCmderPaser::do_dumpconfig(int32_t paramN, const char* paraV[], ICmdParserACK* ack) {
void MicroComputerModuleDeviceScriptCmderPaser::do_dumpreg(int32_t paramN, const char* paraV[], ICmdParserACK* ack) {
// //
ack->ecode = 0; ack->ecode = 0;
@ -34,115 +33,159 @@ void MicroComputerModuleDeviceScriptCmderPaser::do_dumpconfig(int32_t paramN, co
ZLOGI(TAG, "%-30s :%d", tag, configval); \ ZLOGI(TAG, "%-30s :%d", tag, configval); \
} }
DUMP_CONFIG("motor_x_shift", kcfg_motor_x_shift);
DUMP_CONFIG("motor_y_shift", kcfg_motor_y_shift);
DUMP_CONFIG("motor_z_shift", kcfg_motor_z_shift);
DUMP_CONFIG("motor_x_shaft", kcfg_motor_x_shaft);
DUMP_CONFIG("motor_y_shaft", kcfg_motor_y_shaft);
DUMP_CONFIG("motor_z_shaft", kcfg_motor_z_shaft);
DUMP_CONFIG("motor_x_one_circle_pulse", kcfg_motor_x_one_circle_pulse);
DUMP_CONFIG("motor_y_one_circle_pulse", kcfg_motor_y_one_circle_pulse);
DUMP_CONFIG("motor_z_one_circle_pulse", kcfg_motor_z_one_circle_pulse);
DUMP_CONFIG("motor_default_velocity", kcfg_motor_default_velocity);
DUMP_CONFIG("motor_default_acc", kcfg_motor_default_acc);
DUMP_CONFIG("motor_default_dec", kcfg_motor_default_dec);
DUMP_CONFIG("motor_default_break_dec", kcfg_motor_default_break_dec);
DUMP_CONFIG("motor_run_to_zero_max_x_d", kcfg_motor_run_to_zero_max_x_d);
DUMP_CONFIG("motor_run_to_zero_max_y_d", kcfg_motor_run_to_zero_max_y_d);
DUMP_CONFIG("motor_run_to_zero_max_z_d", kcfg_motor_run_to_zero_max_z_d);
DUMP_CONFIG("motor_look_zero_edge_max_x_d", kcfg_motor_look_zero_edge_max_x_d);
DUMP_CONFIG("motor_look_zero_edge_max_y_d", kcfg_motor_look_zero_edge_max_y_d);
DUMP_CONFIG("motor_look_zero_edge_max_z_d", kcfg_motor_look_zero_edge_max_z_d);
DUMP_CONFIG("motor_run_to_zero_speed", kcfg_motor_run_to_zero_speed);
DUMP_CONFIG("motor_run_to_zero_dec", kcfg_motor_run_to_zero_dec);
DUMP_CONFIG("motor_look_zero_edge_speed", kcfg_motor_look_zero_edge_speed);
DUMP_CONFIG("motor_look_zero_edge_dec", kcfg_motor_look_zero_edge_dec);
DUMP_CONFIG("cfg_stepmotor_ihold", k_cfg_stepmotor_ihold);
DUMP_CONFIG("cfg_stepmotor_irun", k_cfg_stepmotor_irun);
DUMP_CONFIG("cfg_stepmotor_iholddelay", k_cfg_stepmotor_iholddelay);
DUMP_CONFIG("cfg_xyrobot_robot_type", k_cfg_xyrobot_robot_type);
}
void MicroComputerModuleDeviceScriptCmderPaser::do_dumpstate(int32_t paramN, const char* paraV[], ICmdParserACK* ack) {
#if 0
typedef enum {
kstate_module_status = STATE_INDEX(0, 0), // 0idle,1busy,2error
kstate_module_errorcode = STATE_INDEX(0, 1), //
kstate_motor1_move = STATE_INDEX(100, 0), //
kstate_motor1_enable = STATE_INDEX(100, 1), //
kstate_motor1_current = STATE_INDEX(100, 2), //
kstate_motor1_vel = STATE_INDEX(100, 3), //
kstate_motor1_pos = STATE_INDEX(100, 4), //
kstate_motor1_temperature = STATE_INDEX(100, 5), //
kstate_motor1_dpos = STATE_INDEX(100, 6), //
kstate_motor2_move = STATE_INDEX(110, 0), //
kstate_motor2_enable = STATE_INDEX(110, 1), //
kstate_motor2_current = STATE_INDEX(110, 2), //
kstate_motor2_vel = STATE_INDEX(110, 3), //
kstate_motor2_pos = STATE_INDEX(110, 4), //
kstate_motor2_temperature = STATE_INDEX(110, 5), //
kstate_motor2_dpos = STATE_INDEX(110, 6), //
kstate_xyrobot_move = STATE_INDEX(1000, 0), //
kstate_xyrobot_enable = STATE_INDEX(1000, 1), //
kstate_xyrobot_x_pos = STATE_INDEX(1000, 2), //
kstate_xyrobot_y_pos = STATE_INDEX(1000, 3), //
kstate_xyrobot_z_pos = STATE_INDEX(1000, 4), //
kstate_xyrobot_x_dpos = STATE_INDEX(1000, 5), //
kstate_xyrobot_y_dpos = STATE_INDEX(1000, 6), //
kstate_xyrobot_z_dpos = STATE_INDEX(1000, 7), //
} config_index_t;
#endif
ack->ecode = 0;
uint16_t moduleId = atoi(paraV[0]);
int32_t configval = 0;
int32_t ecode = 0;
ZLOGI(TAG, "dumpstate %s", paraV[0]);
#define DUMP_STATE(tag, configid) \
ecode = m_deviceManager->module_get_state(moduleId, configid, &configval); \
if (ecode == 0) { \
ZLOGI(TAG, "%-30s :%d", tag, configval); \
}
DUMP_STATE("kstate_module_status", kstate_module_status);
DUMP_STATE("kstate_module_errorcode", kstate_module_errorcode);
DUMP_STATE("kstate_motor1_move", kstate_motor1_move);
DUMP_STATE("kstate_motor1_enable", kstate_motor1_enable);
DUMP_STATE("kstate_motor1_current", kstate_motor1_current);
DUMP_STATE("kstate_motor1_vel", kstate_motor1_vel);
DUMP_STATE("kstate_motor1_pos", kstate_motor1_pos);
DUMP_STATE("kstate_motor1_temperature", kstate_motor1_temperature);
DUMP_STATE("kstate_motor1_dpos", kstate_motor1_dpos);
DUMP_STATE("kstate_motor2_move", kstate_motor2_move);
DUMP_STATE("kstate_motor2_enable", kstate_motor2_enable);
DUMP_STATE("kstate_motor2_current", kstate_motor2_current);
DUMP_STATE("kstate_motor2_vel", kstate_motor2_vel);
DUMP_STATE("kstate_motor2_pos", kstate_motor2_pos);
DUMP_STATE("kstate_motor2_temperature", kstate_motor2_temperature);
DUMP_STATE("kstate_motor2_dpos", kstate_motor2_dpos);
DUMP_STATE("kstate_xyrobot_move", kstate_xyrobot_move);
DUMP_STATE("kstate_xyrobot_enable", kstate_xyrobot_enable);
DUMP_STATE("kstate_xyrobot_x_pos", kstate_xyrobot_x_pos);
DUMP_STATE("kstate_xyrobot_y_pos", kstate_xyrobot_y_pos);
DUMP_STATE("kstate_xyrobot_z_pos", kstate_xyrobot_z_pos);
DUMP_STATE("kstate_xyrobot_x_dpos", kstate_xyrobot_x_dpos);
DUMP_STATE("kstate_xyrobot_y_dpos", kstate_xyrobot_y_dpos);
DUMP_STATE("kstate_xyrobot_z_dpos", kstate_xyrobot_z_dpos);
// module_get_state
}
void MicroComputerModuleDeviceScriptCmderPaser::do_dumpstate(int32_t moduleId) {
ICmdParserACK ack;
const char paraV_cache[1][10] = {{0}};
sprintf((char*)paraV_cache[0], "%ld", moduleId);
const char* paraV[1] = {paraV_cache[0]};
do_dumpstate(1, (const char**)paraV, &ack);
/*******************************************************************************
* (0->1000) *
*******************************************************************************/
DUMP_CONFIG("module_version", kreg_module_version);
DUMP_CONFIG("module_type", kreg_module_type);
DUMP_CONFIG("module_status", kreg_module_status);
DUMP_CONFIG("module_errorcode", kreg_module_errorcode);
DUMP_CONFIG("module_initflag", kreg_module_initflag);
DUMP_CONFIG("module_enableflag", kreg_module_enableflag);
DUMP_CONFIG("module_last_cmd_exec_status", kreg_module_last_cmd_exec_status);
DUMP_CONFIG("module_last_cmd_exec_val0", kreg_module_last_cmd_exec_val0);
DUMP_CONFIG("module_last_cmd_exec_val1", kreg_module_last_cmd_exec_val1);
DUMP_CONFIG("module_last_cmd_exec_val2", kreg_module_last_cmd_exec_val2);
DUMP_CONFIG("module_last_cmd_exec_val3", kreg_module_last_cmd_exec_val3);
DUMP_CONFIG("module_last_cmd_exec_val4", kreg_module_last_cmd_exec_val4);
DUMP_CONFIG("module_last_cmd_exec_val5", kreg_module_last_cmd_exec_val5);
DUMP_CONFIG("module_private0", kreg_module_private0);
DUMP_CONFIG("module_private1", kreg_module_private1);
DUMP_CONFIG("module_private2", kreg_module_private2);
DUMP_CONFIG("module_private3", kreg_module_private3);
DUMP_CONFIG("module_private4", kreg_module_private4);
DUMP_CONFIG("module_private5", kreg_module_private5);
DUMP_CONFIG("module_private6", kreg_module_private6);
DUMP_CONFIG("module_private7", kreg_module_private7);
DUMP_CONFIG("module_private8", kreg_module_private8);
DUMP_CONFIG("module_private9", kreg_module_private9);
/*******************************************************************************
* (1000->1999 *
*******************************************************************************/
DUMP_CONFIG("motor_x_shift", kreg_motor_x_shift);
DUMP_CONFIG("motor_y_shift", kreg_motor_y_shift);
DUMP_CONFIG("motor_z_shift", kreg_motor_z_shift);
DUMP_CONFIG("motor_x_shaft", kreg_motor_x_shaft);
DUMP_CONFIG("motor_y_shaft", kreg_motor_y_shaft);
DUMP_CONFIG("motor_z_shaft", kreg_motor_z_shaft);
DUMP_CONFIG("motor_x_one_circle_pulse", kreg_motor_x_one_circle_pulse);
DUMP_CONFIG("motor_y_one_circle_pulse", kreg_motor_y_one_circle_pulse);
DUMP_CONFIG("motor_z_one_circle_pulse", kreg_motor_z_one_circle_pulse);
DUMP_CONFIG("motor_default_velocity", kreg_motor_default_velocity);
DUMP_CONFIG("motor_default_acc", kreg_motor_default_acc);
DUMP_CONFIG("motor_default_dec", kreg_motor_default_dec);
DUMP_CONFIG("motor_default_break_dec", kreg_motor_default_break_dec);
DUMP_CONFIG("stepmotor_ihold", kreg_stepmotor_ihold);
DUMP_CONFIG("stepmotor_irun", kreg_stepmotor_irun);
DUMP_CONFIG("stepmotor_iholddelay", kreg_stepmotor_iholddelay);
DUMP_CONFIG("motor_run_to_zero_max_x_d", kreg_motor_run_to_zero_max_x_d);
DUMP_CONFIG("motor_run_to_zero_max_y_d", kreg_motor_run_to_zero_max_y_d);
DUMP_CONFIG("motor_run_to_zero_max_z_d", kreg_motor_run_to_zero_max_z_d);
DUMP_CONFIG("motor_look_zero_edge_max_x_d", kreg_motor_look_zero_edge_max_x_d);
DUMP_CONFIG("motor_look_zero_edge_max_y_d", kreg_motor_look_zero_edge_max_y_d);
DUMP_CONFIG("motor_look_zero_edge_max_z_d", kreg_motor_look_zero_edge_max_z_d);
DUMP_CONFIG("motor_run_to_zero_speed", kreg_motor_run_to_zero_speed);
DUMP_CONFIG("motor_run_to_zero_dec", kreg_motor_run_to_zero_dec);
DUMP_CONFIG("motor_look_zero_edge_speed", kreg_motor_look_zero_edge_speed);
DUMP_CONFIG("motor_look_zero_edge_dec", kreg_motor_look_zero_edge_dec);
DUMP_CONFIG("xyrobot_robot_type", kreg_xyrobot_robot_type);
DUMP_CONFIG("robot_move", kreg_robot_move);
DUMP_CONFIG("robot_x_pos", kreg_robot_x_pos);
DUMP_CONFIG("robot_y_pos", kreg_robot_y_pos);
DUMP_CONFIG("robot_z_pos", kreg_robot_z_pos);
DUMP_CONFIG("robot_x_velocity", kreg_robot_x_velocity);
DUMP_CONFIG("robot_y_velocity", kreg_robot_y_velocity);
DUMP_CONFIG("robot_z_velocity", kreg_robot_z_velocity);
DUMP_CONFIG("robot_x_torque", kreg_robot_x_torque);
DUMP_CONFIG("robot_y_torque", kreg_robot_y_torque);
DUMP_CONFIG("robot_z_torque", kreg_robot_z_torque);
/*******************************************************************************
* (2000->2999) *
*******************************************************************************/
DUMP_CONFIG("sensor_current", kreg_sensor_current);
DUMP_CONFIG("sensor_voltage", kreg_sensor_voltage);
DUMP_CONFIG("sensor_temperature", kreg_sensor_temperature);
DUMP_CONFIG("sensor_humidity", kreg_sensor_humidity);
DUMP_CONFIG("sensor_wind_speed", kreg_sensor_wind_speed);
DUMP_CONFIG("sensor_wind_dir", kreg_sensor_wind_dir);
DUMP_CONFIG("sensor_air_press", kreg_sensor_air_press);
DUMP_CONFIG("sensor_pm25", kreg_sensor_pm25);
DUMP_CONFIG("sensor_pm10", kreg_sensor_pm10);
DUMP_CONFIG("sensor_co", kreg_sensor_co);
DUMP_CONFIG("sensor_co2", kreg_sensor_co2);
DUMP_CONFIG("sensor_no2", kreg_sensor_no2);
DUMP_CONFIG("sensor_so2", kreg_sensor_so2);
DUMP_CONFIG("sensor_o3", kreg_sensor_o3);
DUMP_CONFIG("sensor_light_intensity", kreg_sensor_light_intensity);
DUMP_CONFIG("sensor_radiation", kreg_sensor_radiation);
DUMP_CONFIG("sensor_hydrogen_peroxide_volume", kreg_sensor_hydrogen_peroxide_volume);
DUMP_CONFIG("sensor_h2o_h2o2_rs", kreg_sensor_h2o_h2o2_rs);
DUMP_CONFIG("sensor_relative_humidity", kreg_sensor_relative_humidity);
DUMP_CONFIG("sensor_absolute_hydrogen_peroxide", kreg_sensor_absolute_hydrogen_peroxide);
DUMP_CONFIG("sensor_h2o_h2o2dew_point_temperature", kreg_sensor_h2o_h2o2dew_point_temperature);
DUMP_CONFIG("sensor_water_volume", kreg_sensor_water_volume);
DUMP_CONFIG("sensor_water_vapor_pressure", kreg_sensor_water_vapor_pressure);
DUMP_CONFIG("sensor_absolute_humidity", kreg_sensor_absolute_humidity);
DUMP_CONFIG("sensor_water_vapor_saturation_pressure_h2o", kreg_sensor_water_vapor_saturation_pressure_h2o);
DUMP_CONFIG("sensor_h2o2_vapor_pressure", kreg_sensor_h2o2_vapor_pressure);
DUMP_CONFIG("sensor_water_vapor_saturation_pressure_h2o_h2o2", kreg_sensor_water_vapor_saturation_pressure_h2o_h2o2);
DUMP_CONFIG("sensor_temperature0", kreg_sensor_temperature0);
DUMP_CONFIG("sensor_temperature1", kreg_sensor_temperature1);
DUMP_CONFIG("sensor_temperature2", kreg_sensor_temperature2);
DUMP_CONFIG("sensor_temperature3", kreg_sensor_temperature3);
DUMP_CONFIG("sensor_temperature4", kreg_sensor_temperature4);
DUMP_CONFIG("sensor_temperature5", kreg_sensor_temperature5);
DUMP_CONFIG("sensor_temperature6", kreg_sensor_temperature6);
DUMP_CONFIG("sensor_temperature7", kreg_sensor_temperature7);
DUMP_CONFIG("sensor_temperature8", kreg_sensor_temperature8);
DUMP_CONFIG("sensor_temperature9", kreg_sensor_temperature9);
DUMP_CONFIG("sensor_pressure0", kreg_sensor_pressure0);
DUMP_CONFIG("sensor_pressure1", kreg_sensor_pressure1);
DUMP_CONFIG("sensor_pressure2", kreg_sensor_pressure2);
DUMP_CONFIG("sensor_pressure3", kreg_sensor_pressure3);
DUMP_CONFIG("sensor_pressure4", kreg_sensor_pressure4);
DUMP_CONFIG("sensor_pressure5", kreg_sensor_pressure5);
DUMP_CONFIG("sensor_pressure6", kreg_sensor_pressure6);
DUMP_CONFIG("sensor_pressure7", kreg_sensor_pressure7);
DUMP_CONFIG("sensor_pressure8", kreg_sensor_pressure8);
DUMP_CONFIG("sensor_pressure9", kreg_sensor_pressure9);
DUMP_CONFIG("sensor_humidity0", kreg_sensor_humidity0);
DUMP_CONFIG("sensor_humidity1", kreg_sensor_humidity1);
DUMP_CONFIG("sensor_humidity2", kreg_sensor_humidity2);
DUMP_CONFIG("sensor_humidity3", kreg_sensor_humidity3);
DUMP_CONFIG("sensor_humidity4", kreg_sensor_humidity4);
DUMP_CONFIG("sensor_humidity5", kreg_sensor_humidity5);
DUMP_CONFIG("sensor_humidity6", kreg_sensor_humidity6);
DUMP_CONFIG("sensor_humidity7", kreg_sensor_humidity7);
DUMP_CONFIG("sensor_humidity8", kreg_sensor_humidity8);
DUMP_CONFIG("sensor_humidity9", kreg_sensor_humidity9);
/*******************************************************************************
* PID控制器(3000->4000) *
*******************************************************************************/
DUMP_CONFIG("pid_kp", kreg_pid_kp);
DUMP_CONFIG("pid_ki", kreg_pid_ki);
DUMP_CONFIG("pid_kd", kreg_pid_kd);
DUMP_CONFIG("pid_max_max_output", kreg_pid_max_max_output);
DUMP_CONFIG("pid_max_min_output", kreg_pid_max_min_output);
DUMP_CONFIG("pid_max_max_integral", kreg_pid_max_max_integral);
DUMP_CONFIG("pid_max_min_integral", kreg_pid_max_min_integral);
DUMP_CONFIG("error_limit", kreg_error_limit);
DUMP_CONFIG("compute_interval", kreg_compute_interval);
DUMP_CONFIG("pid_target", kreg_pid_target);
DUMP_CONFIG("pid_nowoutput", kreg_pid_nowoutput);
DUMP_CONFIG("pid_feedbackval", kreg_pid_feedbackval);
/*******************************************************************************
* *
*******************************************************************************/
DUMP_CONFIG("fan_cfg_speed_level", kreg_fan_cfg_speed_level);
} }
void MicroComputerModuleDeviceScriptCmderPaser::initialize(ICmdParser* cancmder, ZModuleDeviceManager* deviceManager) { void MicroComputerModuleDeviceScriptCmderPaser::initialize(ICmdParser* cancmder, ZModuleDeviceManager* deviceManager) {
@ -150,6 +193,5 @@ void MicroComputerModuleDeviceScriptCmderPaser::initialize(ICmdParser* cancmder,
m_cmdParser = cancmder; m_cmdParser = cancmder;
m_deviceManager = deviceManager; m_deviceManager = deviceManager;
cancmder->regCMD("dumpconfig", "dumpconfig (mid)", 1, [this](int32_t paramN, const char* paraV[], ICmdParserACK* ack) { do_dumpconfig(paramN, paraV, ack); });
cancmder->regCMD("dumpstate", "dumpstate (mid)", 1, [this](int32_t paramN, const char* paraV[], ICmdParserACK* ack) { do_dumpstate(paramN, paraV, ack); });
cancmder->regCMD("dumpreg", "dumpreg (mid)", 1, [this](int32_t paramN, const char* paraV[], ICmdParserACK* ack) { do_dumpreg(paramN, paraV, ack); });
} }

8
components/zprotocol_helper/micro_computer_module_device_script_cmder_paser.hpp

@ -10,11 +10,11 @@ class MicroComputerModuleDeviceScriptCmderPaser : public ZModuleDeviceScriptCmde
public: public:
void initialize(ICmdParser* cancmder, ZModuleDeviceManager* deviceManager); void initialize(ICmdParser* cancmder, ZModuleDeviceManager* deviceManager);
void do_dumpconfig(int32_t paramN, const char* paraV[], ICmdParserACK* ack);
void do_dumpconfig(int32_t moduleId);
void do_dumpreg(int32_t paramN, const char* paraV[], ICmdParserACK* ack);
void do_dumpreg(int32_t moduleId);
void do_dumpstate(int32_t paramN, const char* paraV[], ICmdParserACK* ack);
void do_dumpstate(int32_t moduleId);
void do_dumpstate(int32_t paramN, const char* paraV[], ICmdParserACK* ack) {}
void do_dumpstate(int32_t moduleId) {}
}; };
} // namespace iflytop } // namespace iflytop

2
components/zprotocols/zcancmder_v2

@ -1 +1 @@
Subproject commit 7f12da5d4065294badfb3f970ba6dc539eb6a7b8
Subproject commit 175ad9bb52d430d8eff96e3c9a88bf312181bbfa
Loading…
Cancel
Save