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

update

change_pipette_api
zhaohe 1 year ago
parent
a71358065a
commit
9e37e00dea
6 changed files with 373 additions and 88 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 88
      api/apibasic/cmdid.cpp
  2. 10
      api/apibasic/cmdid.hpp
  3. 188
      api/apibasic/errorcode.cpp
  4. 8
      api/apibasic/errorcode.hpp
  5. 158
      api/apibasic/reg_index.cpp
  6. 9
      api/apibasic/reg_index.hpp

88
api/apibasic/cmdid.cpp
View File

@ -0,0 +1,88 @@
#include "cmdid.hpp"
#include <stdint.h>
namespace iflytop {
namespace zcr {
#define CMD_ITERM(enum) \
{ enum, #enum }
static cmdinfo_t table[] = {
CMD_ITERM(kboard_reset),
CMD_ITERM(kevent_bus_reg_change_report),
CMD_ITERM(kmodule_ping),
CMD_ITERM(kmodule_get_status),
CMD_ITERM(kmodule_stop),
CMD_ITERM(kmodule_set_reg),
CMD_ITERM(kmodule_get_reg),
CMD_ITERM(kmodule_get_error),
CMD_ITERM(kmodule_clear_error),
CMD_ITERM(kmodule_active_cfg),
CMD_ITERM(kxymotor_enable),
CMD_ITERM(kxymotor_move_by),
CMD_ITERM(kxymotor_move_to),
CMD_ITERM(kxymotor_move_to_zero),
CMD_ITERM(kxymotor_move_to_zero_and_calculated_shift),
CMD_ITERM(kxymotor_read_pos),
CMD_ITERM(kxymotor_calculated_pos_by_move_to_zero),
CMD_ITERM(kcode_scaner_start_scan),
CMD_ITERM(kcode_scaner_stop_scan),
CMD_ITERM(kcode_scaner_read_scaner_result),
CMD_ITERM(kpipette_ctrl_init_device),
CMD_ITERM(kpipette_ctrl_put_tip),
CMD_ITERM(kpipette_ctrl_move_to_ul),
CMD_ITERM(ka8000_optical_module_power_ctrl),
CMD_ITERM(ka8000_optical_open_laser),
CMD_ITERM(ka8000_optical_close_laser),
CMD_ITERM(ka8000_optical_set_laster_gain),
CMD_ITERM(ka8000_optical_set_scan_amp_gain),
CMD_ITERM(ka8000_optical_read_scanner_adc_val),
CMD_ITERM(ka8000_optical_read_laster_adc_val),
CMD_ITERM(ka8000_optical_scan_current_point_amp_adc_val),
CMD_ITERM(kstep_motor_enable),
CMD_ITERM(kstep_motor_read_pos),
CMD_ITERM(kstep_motor_easy_rotate),
CMD_ITERM(kstep_motor_easy_move_by),
CMD_ITERM(kstep_motor_easy_move_to),
CMD_ITERM(kstep_motor_easy_move_to_zero),
CMD_ITERM(kstep_motor_easy_set_current_pos),
CMD_ITERM(kstep_motor_easy_move_to_io),
CMD_ITERM(kstep_motor_active_cfg),
CMD_ITERM(kstep_motor_stop),
CMD_ITERM(kstep_motor_read_io_state),
CMD_ITERM(kmini_servo_enable),
CMD_ITERM(kmini_servo_read_pos),
CMD_ITERM(kmini_servo_active_cfg),
CMD_ITERM(kmini_servo_stop),
CMD_ITERM(kmini_servo_set_mid_point),
CMD_ITERM(kmini_servo_read_io_state),
CMD_ITERM(kmini_servo_move_to),
CMD_ITERM(kmini_servo_rotate),
CMD_ITERM(kmini_servo_rotate_with_torque),
CMD_ITERM(kboard_read_ext_io),
CMD_ITERM(kboard_write_ext_io),
};
const char* cmdid2str(int32_t code) {
for (size_t i = 0; i < sizeof(table) / sizeof(table[0]); i++) {
if (table[i].index == code) {
return table[i].fnname;
}
}
return "unknown_cmd";
}
cmdinfo_t* cmdid_get_table() { return table; }
int cmdid_get_table_size() { return sizeof(table) / sizeof(table[0]); }
} // namespace zcr
} // namespace iflytop

10
api/apibasic/cmdid.hpp
View File

@ -1,4 +1,5 @@
#pragma once
#include <stdint.h>
#define CMDID(cmdid, cmdSubId) ((cmdid << 8) + cmdSubId)
@ -95,5 +96,14 @@ typedef enum {
} cmdid_t;
typedef struct {
int index;
const char* fnname;
} cmdinfo_t;
const char* cmdid2str(int32_t code);
cmdinfo_t* cmdid_get_table();
int cmdid_get_table_size();
} // namespace zcr
} // namespace iflytop

188
api/apibasic/errorcode.cpp
View File

@ -6,96 +6,108 @@
namespace iflytop {
namespace err {
#define ERR_ITERM(enum) \
{ enum, #enum }
static ecode_table_item_t table[] = {
ERR_ITERM(ksucc),
ERR_ITERM(kfail),
ERR_ITERM(kparam_out_of_range),
ERR_ITERM(koperation_not_support),
ERR_ITERM(kdevice_is_busy),
ERR_ITERM(kdevice_is_offline),
ERR_ITERM(kovertime),
ERR_ITERM(knoack),
ERR_ITERM(kerrorack),
ERR_ITERM(kdevice_offline),
ERR_ITERM(kparse_json_err),
ERR_ITERM(ksubdevice_overtime),
ERR_ITERM(kbuffer_not_enough),
ERR_ITERM(kcmd_not_found),
ERR_ITERM(kcmd_param_num_error),
ERR_ITERM(kcheckcode_is_error),
ERR_ITERM(kcatch_exception),
ERR_ITERM(khwardware_error_fan_error),
ERR_ITERM(khwardware_error),
ERR_ITERM(ksys_error),
ERR_ITERM(ksys_create_file_error),
ERR_ITERM(ksys_create_dir_error),
ERR_ITERM(ksys_open_file_error),
ERR_ITERM(ksys_open_dir_error),
ERR_ITERM(ksys_read_file_error),
ERR_ITERM(ksys_write_file_error),
ERR_ITERM(ksys_close_file_error),
ERR_ITERM(ksys_close_dir_error),
ERR_ITERM(ksys_delete_file_error),
ERR_ITERM(ksys_delete_dir_error),
ERR_ITERM(ksys_copy_file_error),
ERR_ITERM(kmodule_not_inited),
ERR_ITERM(kmodule_not_found),
ERR_ITERM(kmodule_opeation_break_by_user),
ERR_ITERM(kmodule_error),
ERR_ITERM(kmodule_not_find_config_index),
ERR_ITERM(kmodule_not_find_state_index),
ERR_ITERM(kmodule_not_support_action),
ERR_ITERM(kmodule_not_find_reg),
ERR_ITERM(kmotor_not_found_zero_point),
ERR_ITERM(kmotor_did_not_go_zero),
ERR_ITERM(kmotor_over_temperature),
ERR_ITERM(kmotor_over_voltage),
ERR_ITERM(kxymotor_not_found_x_zero_point),
ERR_ITERM(kxymotor_not_found_y_zero_point),
ERR_ITERM(kxymotor_x_find_zero_edge_fail),
ERR_ITERM(kxymotor_y_find_zero_edge_fail),
ERR_ITERM(kmotor_run_overtime),
ERR_ITERM(kmotor_not_enable),
ERR_ITERM(kSMTP2_NoError),
ERR_ITERM(kSMTP2_InitFail),
ERR_ITERM(kSMTP2_InvalidCmd),
ERR_ITERM(kSMTP2_InvalidArg),
ERR_ITERM(kSMTP2_PressureSensorError),
ERR_ITERM(kSMTP2_OverPressure),
ERR_ITERM(kSMTP2_LLDError),
ERR_ITERM(kSMTP2_DeviceNotInit),
ERR_ITERM(kSMTP2_TipPopError),
ERR_ITERM(kSMTP2_PumpOverload),
ERR_ITERM(kSMTP2_TipDrop),
ERR_ITERM(kSMTP2_CanBusError),
ERR_ITERM(kSMTP2_InvalidChecksum),
ERR_ITERM(kSMTP2_EEPROMError),
ERR_ITERM(kSMTP2_CmdBufferEmpty),
ERR_ITERM(kSMTP2_CmdBufferOverflow),
ERR_ITERM(kSMTP2_TipBlock),
ERR_ITERM(kSMTP2_AirSuction),
ERR_ITERM(kSMTP2_Bubble),
ERR_ITERM(kSMTP2_VolumeError),
ERR_ITERM(kSMTP2_TipAlreadyLoad),
ERR_ITERM(kSMTP2_TipLoadFail),
ERR_ITERM(kmicro_noErr),
ERR_ITERM(kmicro_uartSendFail),
ERR_ITERM(kmicro_uartRecvFail),
ERR_ITERM(kmicro_adcRecvFail),
ERR_ITERM(kstep_motor_not_found_zero_point),
ERR_ITERM(kstep_motor_not_go_zero),
ERR_ITERM(kstep_motor_over_temperature),
ERR_ITERM(kstep_motor_over_voltage),
ERR_ITERM(kstep_motor_run_overtime),
ERR_ITERM(kstep_motor_not_enable),
ERR_ITERM(kstep_motor_ioindex_out_of_range),
ERR_ITERM(kmini_servo_not_enable),
ERR_ITERM(kmini_servo_mode_not_support),
};
const char* error2str(int32_t code) {
switch (code) {
ERR2STR(ksucc);
ERR2STR(kfail);
ERR2STR(kparam_out_of_range);
ERR2STR(koperation_not_support);
ERR2STR(kdevice_is_busy);
ERR2STR(kdevice_is_offline);
ERR2STR(kovertime);
ERR2STR(knoack);
ERR2STR(kerrorack);
ERR2STR(kdevice_offline);
ERR2STR(kparse_json_err);
ERR2STR(ksubdevice_overtime);
ERR2STR(kbuffer_not_enough);
ERR2STR(kcmd_not_found);
ERR2STR(kcmd_param_num_error);
ERR2STR(kcheckcode_is_error);
ERR2STR(kcatch_exception);
ERR2STR(khwardware_error_fan_error);
ERR2STR(khwardware_error);
ERR2STR(ksys_error);
ERR2STR(ksys_create_file_error);
ERR2STR(ksys_create_dir_error);
ERR2STR(ksys_open_file_error);
ERR2STR(ksys_open_dir_error);
ERR2STR(ksys_read_file_error);
ERR2STR(ksys_write_file_error);
ERR2STR(ksys_close_file_error);
ERR2STR(ksys_close_dir_error);
ERR2STR(ksys_delete_file_error);
ERR2STR(ksys_delete_dir_error);
ERR2STR(ksys_copy_file_error);
ERR2STR(kmodule_not_inited);
ERR2STR(kmodule_not_found);
ERR2STR(kmodule_opeation_break_by_user);
ERR2STR(kmodule_error);
ERR2STR(kmodule_not_find_config_index);
ERR2STR(kmodule_not_find_state_index);
ERR2STR(kmodule_not_support_action);
ERR2STR(kmodule_not_find_reg);
ERR2STR(kmotor_not_found_zero_point);
ERR2STR(kmotor_did_not_go_zero);
ERR2STR(kmotor_over_temperature);
ERR2STR(kmotor_over_voltage);
ERR2STR(kxymotor_not_found_x_zero_point);
ERR2STR(kxymotor_not_found_y_zero_point);
ERR2STR(kxymotor_x_find_zero_edge_fail);
ERR2STR(kxymotor_y_find_zero_edge_fail);
ERR2STR(kmotor_run_overtime);
ERR2STR(kmotor_not_enable);
ERR2STR(kSMTP2_NoError);
ERR2STR(kSMTP2_InitFail);
ERR2STR(kSMTP2_InvalidCmd);
ERR2STR(kSMTP2_InvalidArg);
ERR2STR(kSMTP2_PressureSensorError);
ERR2STR(kSMTP2_OverPressure);
ERR2STR(kSMTP2_LLDError);
ERR2STR(kSMTP2_DeviceNotInit);
ERR2STR(kSMTP2_TipPopError);
ERR2STR(kSMTP2_PumpOverload);
ERR2STR(kSMTP2_TipDrop);
ERR2STR(kSMTP2_CanBusError);
ERR2STR(kSMTP2_InvalidChecksum);
ERR2STR(kSMTP2_EEPROMError);
ERR2STR(kSMTP2_CmdBufferEmpty);
ERR2STR(kSMTP2_CmdBufferOverflow);
ERR2STR(kSMTP2_TipBlock);
ERR2STR(kSMTP2_AirSuction);
ERR2STR(kSMTP2_Bubble);
ERR2STR(kSMTP2_VolumeError);
ERR2STR(kSMTP2_TipAlreadyLoad);
ERR2STR(kSMTP2_TipLoadFail);
ERR2STR(kmicro_noErr);
ERR2STR(kmicro_uartSendFail);
ERR2STR(kmicro_uartRecvFail);
ERR2STR(kmicro_adcRecvFail);
ERR2STR(kstep_motor_not_found_zero_point);
ERR2STR(kstep_motor_not_go_zero);
ERR2STR(kstep_motor_over_temperature);
ERR2STR(kstep_motor_over_voltage);
ERR2STR(kstep_motor_run_overtime);
ERR2STR(kstep_motor_not_enable);
ERR2STR(kstep_motor_ioindex_out_of_range);
ERR2STR(kmini_servo_not_enable);
ERR2STR(kmini_servo_mode_not_support);
default:
return "uknown";
break;
for (size_t i = 0; i < sizeof(table) / sizeof(table[0]); i++) {
if (table[i].index == code) {
return table[i].info;
}
}
return "unknown error";
}
ecode_table_item_t* error_get_table() { return table; }
int error_get_table_size() { return sizeof(table) / sizeof(table[0]); }
} // namespace err
} // namespace iflytop

8
api/apibasic/errorcode.hpp
View File

@ -123,7 +123,15 @@ typedef enum {
} error_t;
typedef struct {
int index;
const char* info;
} ecode_table_item_t;
const char* error2str(int32_t code);
ecode_table_item_t* error_get_table();
int error_get_table_size();
} // namespace err
} // namespace iflytop

158
api/apibasic/reg_index.cpp
View File

@ -0,0 +1,158 @@
#pragma once
#include "reg_index.hpp"
#include <stdint.h>
namespace iflytop {
#define REG_ITERM(enum) \
{ enum, #enum }
static reginfo_t table[] = {
REG_ITERM(kreg_module_version),
REG_ITERM(kreg_module_type),
REG_ITERM(kreg_module_status),
REG_ITERM(kreg_module_errorcode),
REG_ITERM(kreg_sensor_temperature0),
REG_ITERM(kreg_sensor_temperature1),
REG_ITERM(kreg_sensor_temperature2),
REG_ITERM(kreg_sensor_temperature3),
REG_ITERM(kreg_pid_target),
REG_ITERM(kreg_pid_nowoutput),
REG_ITERM(kreg_pid_feedbackval),
REG_ITERM(kreg_pid_kp),
REG_ITERM(kreg_pid_ki),
REG_ITERM(kreg_pid_kd),
REG_ITERM(kreg_pid_max_output),
REG_ITERM(kreg_pid_min_output),
REG_ITERM(kreg_pid_max_integral),
REG_ITERM(kreg_pid_min_integral),
REG_ITERM(kreg_error_limit),
REG_ITERM(kreg_compute_interval),
REG_ITERM(kreg_fan0_ctrl_speed_level),
REG_ITERM(kreg_fan1_ctrl_speed_level),
REG_ITERM(kreg_fan2_ctrl_speed_level),
REG_ITERM(kreg_fan3_ctrl_speed_level),
REG_ITERM(kreg_fan4_ctrl_speed_level),
REG_ITERM(kreg_fan0_speed_level),
REG_ITERM(kreg_fan1_speed_level),
REG_ITERM(kreg_fan2_speed_level),
REG_ITERM(kreg_fan3_speed_level),
REG_ITERM(kreg_fan4_speed_level),
REG_ITERM(kreg_pwm_pump0_ctrl_speed_level),
REG_ITERM(kreg_pwm_pump1_ctrl_speed_level),
REG_ITERM(kreg_pwm_pump2_ctrl_speed_level),
REG_ITERM(kreg_pwm_pump3_ctrl_speed_level),
REG_ITERM(kreg_pwm_pump4_ctrl_speed_level),
REG_ITERM(kreg_pwm_pump0_speed_level),
REG_ITERM(kreg_pwm_pump1_speed_level),
REG_ITERM(kreg_pwm_pump2_speed_level),
REG_ITERM(kreg_pwm_pump3_speed_level),
REG_ITERM(kreg_pwm_pump4_speed_level),
REG_ITERM(kreg_pipette_pos_ul),
REG_ITERM(kreg_pipette_capactitance_val),
REG_ITERM(kreg_pipette_tip_state),
REG_ITERM(kreg_pipette_limit_ul),
REG_ITERM(kreg_self_reflecting_laser_sensor_transmitting_power),
REG_ITERM(kreg_self_reflecting_laser_sensor_receiving_tube_gain),
REG_ITERM(kreg_self_reflecting_laser_sensor_sample_interval_ms),
REG_ITERM(kreg_self_reflecting_laser_sensor_num_samples),
REG_ITERM(kreg_boditech_optical_scan_type),
REG_ITERM(kreg_boditech_optical_scan_start_pos),
REG_ITERM(kreg_boditech_optical_scan_direction),
REG_ITERM(kreg_boditech_optical_scan_step_interval),
REG_ITERM(kreg_boditech_optical_scan_pointnum),
REG_ITERM(kreg_boditech_optical_channel_select_num),
REG_ITERM(kreg_boditech_optical_laster_gain),
REG_ITERM(kreg_boditech_optical_scan_gain),
REG_ITERM(kreg_boditech_optical_trf_uvled_on_duration_us),
REG_ITERM(kreg_boditech_optical_trf_uvled_off_duration_us),
REG_ITERM(kreg_boditech_optical_trf_scan_delay_us),
REG_ITERM(kreg_boditech_optical_trf_scan_duration_us),
REG_ITERM(kreg_boditech_optical_scan_gain_adjust_suggestion),
REG_ITERM(kreg_boditech_optical_adc_result_overflow),
REG_ITERM(kreg_boditech_optical_laster_intensity),
REG_ITERM(kreg_laster_scaner_scan_type),
REG_ITERM(kreg_laster_scaner_scan_start_pos),
REG_ITERM(kreg_laster_scaner_scan_direction),
REG_ITERM(kreg_laster_scaner_scan_step_interval),
REG_ITERM(kreg_laster_scaner_scan_pointnum),
REG_ITERM(kreg_laster_scaner_laster_gain),
REG_ITERM(kreg_laster_scaner_scan_gain),
REG_ITERM(kreg_laster_scaner_scan_gain_adjust_suggestion),
REG_ITERM(kreg_laster_scaner_adc_result_overflow),
REG_ITERM(kreg_laster_scaner_laster_intensity),
REG_ITERM(kreg_xyrobot_default_velocity),
REG_ITERM(kreg_xyrobot_default_acc),
REG_ITERM(kreg_xyrobot_default_dec),
REG_ITERM(kreg_xyrobot_default_break_dec),
REG_ITERM(kreg_xyrobot_run_to_zero_speed),
REG_ITERM(kreg_xyrobot_run_to_zero_dec),
REG_ITERM(kreg_xyrobot_look_zero_edge_speed),
REG_ITERM(kreg_xyrobot_look_zero_edge_dec),
REG_ITERM(kreg_xyrobot_ihold),
REG_ITERM(kreg_xyrobot_irun),
REG_ITERM(kreg_xyrobot_iholddelay),
REG_ITERM(kreg_xyrobot_robot_type),
REG_ITERM(kreg_xyrobot_x_shift),
REG_ITERM(kreg_xyrobot_y_shift),
REG_ITERM(kreg_xyrobot_x_shaft),
REG_ITERM(kreg_xyrobot_y_shaft),
REG_ITERM(kreg_xyrobot_x_one_circle_pulse),
REG_ITERM(kreg_xyrobot_y_one_circle_pulse),
REG_ITERM(kreg_xyrobot_run_to_zero_max_x_d),
REG_ITERM(kreg_xyrobot_run_to_zero_max_y_d),
REG_ITERM(kreg_xyrobot_look_zero_edge_max_x_d),
REG_ITERM(kreg_xyrobot_look_zero_edge_max_y_d),
REG_ITERM(kreg_xyrobot_io_state0),
REG_ITERM(kreg_xyrobot_io_state1),
REG_ITERM(kreg_step_motor_pos),
REG_ITERM(kreg_step_motor_dpos),
REG_ITERM(kreg_step_motor_shift),
REG_ITERM(kreg_step_motor_shaft),
REG_ITERM(kreg_step_motor_one_circle_pulse),
REG_ITERM(kreg_step_motor_one_circle_pulse_denominator),
REG_ITERM(kreg_step_motor_default_velocity),
REG_ITERM(kreg_step_motor_default_acc),
REG_ITERM(kreg_step_motor_default_dec),
REG_ITERM(kreg_step_motor_default_break_dec),
REG_ITERM(kreg_step_motor_ihold),
REG_ITERM(kreg_step_motor_irun),
REG_ITERM(kreg_step_motor_iholddelay),
REG_ITERM(kreg_step_motor_iglobalscaler),
REG_ITERM(kreg_step_motor_run_to_zero_max_d),
REG_ITERM(kreg_step_motor_look_zero_edge_max_d),
REG_ITERM(kreg_step_motor_run_to_zero_speed),
REG_ITERM(kreg_step_motor_run_to_zero_dec),
REG_ITERM(kreg_step_motor_look_zero_edge_speed),
REG_ITERM(kreg_step_motor_look_zero_edge_dec),
REG_ITERM(kreg_step_motor_max_d),
REG_ITERM(kreg_step_motor_min_d),
REG_ITERM(kreg_mini_servo_pos),
REG_ITERM(kreg_mini_servo_limit_velocity),
REG_ITERM(kreg_mini_servo_limit_torque),
REG_ITERM(kreg_mini_servo_protective_torque),
};
reginfo_t *get_reginfo_by_index(uint32_t index) {
for (size_t i = 0; i < sizeof(table) / sizeof(table[0]); i++) {
if (table[i].index == index) {
return &table[i];
}
}
return nullptr;
}
const char *regindex2str(uint32_t index) {
for (size_t i = 0; i < sizeof(table) / sizeof(table[0]); i++) {
if (table[i].index == index) {
return table[i].regname;
}
}
return "unknown reg";
}
reginfo_t *reg_get_table() { return table; }
int reg_get_table_size() { return sizeof(table) / sizeof(table[0]); }
} // namespace iflytop

9
api/apibasic/reg_index.hpp
View File

@ -190,4 +190,13 @@ typedef enum {
***********************************************************************************************************************/
} reg_index_t;
typedef struct {
int index;
const char* regname;
} reginfo_t;
const char* regindex2str(int32_t code);
reginfo_t* reg_get_table();
int reg_get_table_size();
} // namespace iflytop
Write Preview
Loading…
Cancel
Save