motionx-simulator-package-v2/index.js

all lib of simulator control

let CMDCounter = 0;

const CLIENT_COMMAND_SIM = {
	START_CALIBRATE: 0,
	RESTART_CALIBRATE: 1,
	MOVEMENT_POSITION: 2,
	MOTION_RUNNING: 3,
	MOTION_RESTING: 4,
	PAUSE: 5,
	RESUME: 6,
	EMERGENCY_STOP: 7,
	EMERGENCY_RESUME: 8,
	READ_STATE_DEFAULT: 9,
	READ_STATE_PAYMENT: 10,
	READ_STATE_BELT: 11,
	READ_STATE_SEAT: 12,
	READ_SERIAL_NUMBER: 13,
	READ_LOGGER_UPLOAD: 14,
	READ_STATE_MOTION: 19,
	START_GAME: 15,
	END_GAME: 16,
	MOTION_PARKING: 17,
	MOTION_PICKUP: 18,
	MOTOR_CALIBRATE: 20,
	READ_MACHINE_STATE: 21,
	READ_YAW_ABS: 22,
};

const CLIENT_ODRIVE_COMMAND = {
	MOTOR_OFF: 0,
	MOTOR_ON: 1,
	MOTOR_CALIBRATE: 3,
	ENCODER_CALIBRATE: 4,
	ENCODER_INDEX: 5,
	GET_ENDSTOP: 6,
	GET_GEAR_POS: 7,
	GET_RAW_ENCODER: 8,
	REBOOT: 9,
	STATUS_READ: 11,
	MOTOR_GET_PRE_CALIBATE: 12,
	MOTOR_GET_IS_CALIBRATE: 13,
	MOTOR_GET_TYPE: 14,
	MOTOR_GET_PHASH_INDUCTANCE: 15,
	MOTOR_GET_PHASE_RESISTANCE: 16,
	MOTOR_GET_PM_FLUK_LINKAGE: 17,
	MOTOR_GET_POPLE: 18,
	MOTOR_SET_PRE_CALIBATE: 19,
	MOTOR_SET_IS_CALIBRATE: 20,
	MOTOR_SET_TYPE: 21,
	MOTOR_SET_PHASH_INDUCTANCE: 22,
	MOTOR_SET_PHASE_RESISTANCE: 23,
	MOTOR_SET_PM_FLUK_LINKAGE: 24,
	MOTOR_SET_POPLE: 25,
	ENCODER_SET_PRE_CALIBRATE: 26,
	ENCODE_SET_IS_READY: 27,
	ENCODER_SET_CPR: 28,
	ENCODER_SET_MODE: 29,
	ENCODER_SET_OFFSET: 30,
	ENCODER_SET_OFFSET_FLOAT: 31,
	ENCODER_SET_USE_INDEX: 32,
	CONFIG_1_GET_CALIBRATION_CURRENT: 33,
	CONFIG_1_GET_CURRENT_LIMIT: 34,
	CONFIG_1_GET_VELOCITY_LIMIT: 35,
	CONFIG_1_GET_TRAJECTORY_VEL_LIMIT: 36,
	CONFIG_1_GET_TRAJECTORY_ACCEL_LIMIT: 37,
	CONFIG_1_GET_TRAJECTORY_DECEL_LIMIT: 38,
	CONFIG_1_GET_POS_GAIN: 39,
	CONFIG_1_GET_VEL_GAIN: 40,
	CONFIG_1_GET_CONTROL_MODE: 41,
	CONFIG_1_GET_CALIBRATION_MAX_VOLTAGE: 42,
	CONFIG_1_GET_CARLIBRATION_VEL: 43,
	CONFIG_1_GET_CALIRATION_ACCEL: 44,
	CONFIG_1_GET_CALIBRATION_RAMP: 45,
	CONFIG_1_GET_REQUEST_CURRENT_RANGE: 46,
	CONFIG_1_GET_CURRENT_CONTROL_BANDWIDTH: 47,
	CONFIG_1_GET_CURRENT_LIMIT_TOLERANCE: 48,
	CONFIG_1_GET_VELOCITY_LIMIT_TOLERANCE: 49,
	C_CMD: 51,
	ERR_CLEAR: 52,
	CONFIG_2_GET_GPIO_MODE: 53,
	CONFIG_2_GET_BRAKE_RESISTANCE: 54,
	CONFIG_2_GET_ENABLE_UART: 55,
	CONFIG_2_GET_ENABLE_ASCII_ON_USB: 56,
	CONFIG_2_GET_UNDER_VOLTAGE_TRIP_LEVEL: 57,
	CONFIG_2_GET_OVER_VOLTTAGE_TRIP_LEVEL: 58,
	CONFIG_2_GET_CARIBRATE_SCAN_DISTANT: 59,
	CONFIG_2_GET_INDEX_SEARCH_CURRENT: 60,
	CONFIG_2_GET_ENABLE_BRAKE_RESISTOR: 61,
	CONFIG_2_GET_ENABLE_BRAKE_RESISROT: 62,
	CONFIG_2_GET_DC_MAX_NEGATIVE_CURRENT: 63,
	CONFIG_2_GET_ENABLE_DC_BUS_OVER_VOLTAGE_RAMP: 64,
	CONFIG_2_GET_DC_BUS_OVER_VOLTAGE_RAMP_START: 65,
	CONFIG_2_GET_END_STOP_GPIO: 66,
	CONFIG_2_GET_END_STOP_ACTIVE_HIGHT: 67,
	CONFIG_2_GET_END_STOP_DEBOUNCE: 68,
	CONFIG_2_GET_END_STOP_OFFSET: 69,
	CONFIG_2_GET_END_STOP_ENABLE: 70,
	CONFIG_3_GET_END_STOP_STATE: 71,
	CONFIG_1_SET_CALIBRATION_CURRENT: 72,
	CONFIG_1_SET_CURRENT_LIMIT: 73,
	CONFIG_1_SET_VELOCITY_LIMIT: 74,
	CONFIG_1_SET_TRAJECTORY_VEL_LIMIT: 75,
	CONFIG_1_SET_TRAJECTORY_ACCEL_LIMIT: 76,
	CONFIG_1_SET_TRAJECTORY_DECEL_LIMIT: 77,
	CONFIG_1_SET_POS_GAIN: 78,
	CONFIG_1_SET_VEL_GAIN: 79,
	CONFIG_1_SET_CONTROL_MODE: 80,
	CONFIG_1_SET_CALIBRATION_MAX_VOLTAGE: 81,
	CONFIG_1_SET_CARLIBRATION_VEL: 82,
	CONFIG_1_SET_CALIRATION_ACCEL: 83,
	CONFIG_1_SET_CALIBRATION_RAMP: 84,
	CONFIG_1_SET_REQUEST_CURRENT_RANGE: 85,
	CONFIG_1_SET_CURRENT_CONTROL_BANDWIDTH: 86,
	CONFIG_1_SET_CURRENT_LIMIT_TOLERANCE: 87,
	CONFIG_1_SET_VELOCITY_LIMIT_TOLERANCE: 88,
	CONFIG_2_SET_GPIO_MODE: 89,
	CONFIG_2_SET_BRAKE_RESISTANCE: 90,
	CONFIG_2_SET_ENABLE_UART: 91,
	CONFIG_2_SET_ENABLE_ASCII_ON_USB: 92,
	CONFIG_2_SET_UNDER_VOLTAGE_TRIP_LEVEL: 93,
	CONFIG_2_SET_OVER_VOLTTAGE_TRIP_LEVEL: 94,
	CONFIG_2_SET_CARIBRATE_SCAN_DISTANT: 95,
	CONFIG_2_SET_INDEX_SEARCH_CURRENT: 96,
	CONFIG_2_SET_ENABLE_BRAKE_RESISTOR: 97,
	CONFIG_2_SET_ENABLE_BRAKE_RESISROT: 98,
	CONFIG_2_SET_DC_MAX_NEGATIVE_CURRENT: 99,
	CONFIG_2_SET_ENABLE_DC_BUS_OVER_VOLTAGE_RAMP: 100,
	CONFIG_2_SET_DC_BUS_OVER_VOLTAGE_RAMP_START: 101,
	CONFIG_2_SET_END_STOP_GPIO: 102,
	CONFIG_2_SET_END_STOP_ACTIVE_HIGHT: 103,
	CONFIG_2_SET_END_STOP_DEBOUNCE: 104,
	CONFIG_2_SET_END_STOP_OFFSET: 105,
	CONFIG_2_SET_END_STOP_ENABLE: 106,
	CONFIG_2_SET_HOMING_SPEED: 107,
	CONFIG_3_SET_END_STOP_STATE: 108,
	CONFIG_1_GET_CURRENT_LIMIT_MARGIN: 109,
	CONFIG_1_SET_CURRENT_LIMIT_MARGIN: 110,
	CONFIG_1_GET_VEL_INTEGRATOR_GAIN: 111,
	CONFIG_1_SET_VEL_INTEGRATOR_GAIN: 111,
	FACTORY_RESET: 112,
	ENCODER_GET_PRE_CALIBRATE: 113,
	ENCODE_GET_IS_READY: 114,
	ENCODER_GET_CPR: 115,
	ENCODER_GET_MODE: 116,
	ENCODER_GET_OFFSET: 117,
	ENCODER_GET_OFFSET_FLOAT: 118,
	ENCODER_GET_USE_INDEX: 119,
	GET_GENERAL_ERROR: 120,
	GET_MOTOR_ERROR: 121,
	GET_ENCODER_ERROR: 122,
	GET_CONTROLLER_ERROR: 123,
	GET_DRV_ERROR: 124,
	GET_CURRENT_STATE: 125,
	GET_VBUS_VOLTAGE: 126,
	GET_MEASURED_CURRENT: 127,
	GET_FET_TEMPERATURE: 128,
	CONFIG_2_GET_HOMING_SPEED: 129,
	SAVE: 130,
};

const ODRIVE_TAG = {
	BRAKE_RESISTANCE: 100,
	ENABLE_BRAKE_RESISTOR: 109,
	DC_MAX_NEGATIVE_CURRENT: 108,
	MAX_REGEN_CURRENT: 905,
	ENABLE_UART: 900,
	ENABLE_ASCII_ON_USB: 901,
	DC_BUS_UNDERVOLTAGE_TRIP: 902,
	DC_BUS_OVERVOLTAGE_TRIP: 903,
	POLE_PAIRS: 102,
	CALIBRATION_CURRENT: 103,
	CALIBRATION_SCAN_DISTANT: 906,

	ENCODER_CPR: 104,
	ENCODER_MODE: 105,
	ENCODER_USE_INDEX: 106,
	PM_FLUX_LINKAGE: 107,
	ENABLE_DC_BUS_OVERVOLTAGE_RAMP: 907,
	DC_BUS_OVERVOLTAGE_RAMP_START: 908,
	ENCODER_OFFSET: 110,
	ENCODER_OFFSET_FLOAT: 904,
	CONTROL_MODE: 111,
	GPIO1_MODE: 161,
	GPIO2_MODE: 162,
	GPIO3_MODE: 163,
	GPIO4_MODE: 164,
	GPIO5_MODE: 165,
	GPIO6_MODE: 166,
	GPIO7_MODE: 167,
	GPIO8_MODE: 168,
	MOTOR_PRE_CALIBRATED: 120,
	ENCODER_PRE_CALIBRATED: 121,
	CURRENT_LIM: 122,
	VEL_LIMIT: 123,
	POS_GAIN: 124,
	VEL_GAIN: 125,
	VEL_INTEGRATOR_GAIN: 126,
	TRAJ_VEL_LIMIT: 127,
	TRAJ_ACCEL_LIMIT: 128,
	TRAJ_DECEL_LIMIT: 129,
	VEL_LIMIT_TOLERANCE: 130,
	VEL_RAMP_RATE: 131,

	MOTOR_TYPE: 101,
	RESISTANCE_CALIB_MAX_VOLTAGE: 140,
	REQUESTED_CURRENT_RANGE: 141,
	CURRENT_CONTROL_BANDWIDTH: 142,
	CURRENT_LIMIT_TOLERANCE: 143,
	PHASE_INDUCTANCE: 144,
	PHASE_RESISTANCE: 145,
	CALIBRATION_VELOCITY: 146,
	CALIBRATION_ACCEL: 147,
	CALIBRATION_RAMP: 148,
	CALIBRATION_INDEX_CURRENT: 149,
	HOMING_SPEED: 150,
	MIN_ENDSTOP_GPIO_NUM: 151,
	MIN_ENDSTOP_IS_ACTIVE_HIGH: 152,
	MIN_ENDSTOP_DEBOUNCE: 153,
	MIN_ENDSTOP_OFFSET: 154,
	MIN_ENDSTOP_ENABLED: 155,
	MIN_ENDSTOP_STATE: 156,

	GENERAL_ERROR: 200,
	MOTOR_ERROR: 201,
	ENCODER_ERROR: 202,
	DRV_ERROR: 203,
	CONTROLLER_ERROR: 204,
	DRV_ERROR_FLAG: 205,
	MOTOR_IS_CALIBRATED: 210,
	ENCODER_IS_READY: 211,
	ENCODER_POS_ESTIMATE: 212,

	CURRENT_STATE: 301,
	REQUEST_STATE: 302,
	VBUS_VOLTAGE: 303,
	MEASURED_CURRENT: 304,
	COMMAND_CURRENT: 305,
	FET_TEMPERATURE: 306,

	CONTROL_FACTORY_RESET: 'se',
	SAVE_CONFIG: 'ss',
	ERROR_CLEAR: 'sc',
	ODRIVE_REBOOT: 'sr',

	AXIS_STATE_UNDEFINED: 0,
	AXIS_STATE_IDLE: 1,
	AXIS_STATE_STARTUP_SEQUENCE: 2,
	AXIS_STATE_FULL_CALIBRATION_SEQUENCE: 3,
	AXIS_STATE_MOTOR_CALIBRATION: 4,
	AXIS_STATE_ENCODER_INDEX_SEARCH: 6,
	AXIS_STATE_ENCODER_OFFSET_CALIBRATION: 7,
	AXIS_STATE_CLOSED_LOOP_CONTROL: 8,
	AXIS_STATE_LOCKIN_SPIN: 9,
	AXIS_STATE_ENCODER_DIR_FIND: 10,
	AXIS_STATE_HOMING: 11,
	AXIS_STATE_ENCODER_HALL_POLARITY_CALIBRATION: 12,
	AXIS_STATE_ENCODER_HALL_PHASE_CALIBRATION: 13,

	GPIO_MODE_DIGITAL: 0,
	GPIO_MODE_DIGITAL_PULL_UP: 1,
	GPIO_MODE_DIGITAL_PULL_DOWN: 2,
	GPIO_MODE_ANALOG_IN: 3,
	GPIO_MODE_UART_A: 4,
	GPIO_MODE_UART_B: 5,
	GPIO_MODE_UART_C: 6,
	GPIO_MODE_CAN_A: 7,
	GPIO_MODE_I2C_A: 8,
	GPIO_MODE_SPI_A: 9,
	GPIO_MODE_PWM: 10,
	GPIO_MODE_ENC0: 11,
	GPIO_MODE_ENC1: 12,
	GPIO_MODE_ENC2: 13,
	GPIO_MODE_MECH_BRAKE: 14,
	GPIO_MODE_STATUS: 15,

	CTRL_MODE_VOLTAGE_CONTROL: 0,
	CTRL_MODE_CURRENT_CONTROL: 1,
	CTRL_MODE_VELOCITY_CONTROL: 2,
	CTRL_MODE_POSITION_CONTROL: 3,
	CTRL_MODE_TRAJECTORY_CONTROL: 4,
	CTRL_MODE_UNDEFINED_NAME: '- NONE -',
	CTRL_MODE_VOLTAGE_NAME: 'VOLTAGE',
	CTRL_MODE_CURRENT_NAME: 'CURRENT',
	CTRL_MODE_VELOCITY_NAME: 'VELOCITY',
	CTRL_MODE_POSITION_NAME: 'POSITION',
	CTRL_MODE_TRAJECTORY_NAME: 'TRAJECTORY',
	ENCODER_MODE_INCREMENTAL: 0,
	ENCODER_MODE_HALL: 1,
	ENCODER_MODE_ABSOLUTE_CUI: 256,
	ENCODER_MODE_ABSOLUTE_AMS_AS5047P: 257,
	ENCODER_MODE_ABSOLUTE_AMS_AS5050P: 258,
	ENCODER_MODE_ABSOLUTE_AEAT_6012: 259,
	ENCODER_MODE_UNDEFINED_NAME: '- NONE -',
	ENCODER_MODE_INCREMENTAL_NAME: 'INCREMENTAL',
	ENCODER_MODE_HALL_NAME: 'HALL',
	ENCODER_MODE_ABSOLUTE_NAME_CUI: 'ABS CUI',
	ENCODER_MODE_ABSOLUTE_NAME_AMS_AS5047P: 'ABS AS5047P',
	ENCODER_MODE_ABSOLUTE_NAME_AMS_AS5050P: 'ABS AS5050P',
	ENCODER_MODE_ABSOLUTE_NAME_AEAT_6012: 'ABS AEAT',

	C_CMD: 112,
};

const CounterCMD = () => {
	CMDCounter += 1;
	if (CMDCounter > 99) CMDCounter = 1;
};

const GetCheckSum = (xStr) => {
	let res = '';
	let zXor = 0;

	for (let i = 0; i < xStr.length; i++) {
		zXor = zXor ^ xStr.charCodeAt(i);
	}
	res = xStr + '*' + zXor.toString();
	return res;
};

const COMMAND_TO_SIMULATOR = {
	START_CALIBRATE: () => {
		CounterCMD();
		return `[${CMDCounter}]sys.write(1109,1)`;
	},
	RESTART_CALIBRATE: () => {
		CounterCMD();
		return `[${CMDCounter}]sys.write(1109,2)`;
	},
	INIT_CONNECTION: (safeIp, safePort) => {
		CounterCMD();
		return `[${CMDCounter}]sys.use(${safeIp},${safePort})`;
	},
	MOVEMENT_POSITION: (roll, pitch, yaw, heave, surge, sway) => {
		CounterCMD();
		return `[${CMDCounter}]sys.pos(${roll},${pitch},${yaw},${heave},${surge},${sway})`;
	},
	MOTION_RUNNING: () => {
		return '[0]sys.write(100,2)';
	},
	MOTION_RESTING: () => {
		return '[0]sys.write(100,1)';
	},
	MOTION_PICKUP: () => {
		return '[0]sys.write(100,3)';
	},
	MOTION_PARKING: () => {
		return '[0]sys.write(100,0)';
	},
	PAUSE: () => `[${CMDCounter}]sys.write(111,1)`,
	RESUME: () => `[${CMDCounter}]sys.write(111,2)`,
	EMERGENCY_STOP: () => `[${CMDCounter}]sys.write(112,1)`,
	EMERGENCY_RESUME: () => `[${CMDCounter}]sys.write(112,2)`,
	GET_REG: (RegID) => {
		CounterCMD();
		return `[${CMDCounter}]sys.read(${RegID})`;
	},
	START_MOTOR_CALIBRATE: () => {
		CounterCMD();
		return `[${CMDCounter}]sys.write(1109,3)`;
	},
};

const STATE_MOTOR_STATUS = {
	OFFLINE: 0,
	ONLINE: 2,
	IDLE: 1,
	BUSY: 4,
	ERROR: 5,
};

const STATE_DRIVE_STATUS = {
	OFFLINE: 0,
	ONLINE: 1,
	ERROR: 2,
};

const CommandDriveString = (CMDSID, AxisID) => {
	let CMDS = '';

	switch (CMDSID) {
	case ODRIVE_TAG.MAX_REGEN_CURRENT:
		CMDS = 'config.max_regen_curren';
		break;
	case ODRIVE_TAG.BRAKE_RESISTANCE:
		CMDS = 'config.brake_resistance';
		break;
	case ODRIVE_TAG.DC_BUS_OVERVOLTAGE_TRIP:
		CMDS = 'config.dc_bus_overvoltage_trip_level';
		break;
	case ODRIVE_TAG.DC_BUS_UNDERVOLTAGE_TRIP:
		CMDS = 'config.dc_bus_undervoltage_trip_level';
		break;
	case ODRIVE_TAG.MOTOR_TYPE:
		CMDS = `axis${AxisID}.motor.config.motor_type`;
		break;
	case ODRIVE_TAG.MOTOR_PRE_CALIBRATED:
		CMDS = `axis${AxisID}.motor.config.pre_calibrated`;
		break;
	case ODRIVE_TAG.POLE_PAIRS:
		CMDS = `axis${AxisID}.motor.config.pole_pairs`;
		break;
	case ODRIVE_TAG.CALIBRATION_CURRENT:
		CMDS = `axis${AxisID}.motor.config.calibration_current`;
		break;
	case ODRIVE_TAG.CALIBRATION_SCAN_DISTANT:
		CMDS = `axis${AxisID}.encoder.config.calib_scan_distance`;
		break;
	case ODRIVE_TAG.ENCODER_CPR:
		CMDS = `axis${AxisID}.encoder.config.cpr`;
		break;
	case ODRIVE_TAG.ENCODER_MODE:
		CMDS = `axis${AxisID}.encoder.config.mode`;
		break;
	case ODRIVE_TAG.ENCODER_USE_INDEX:
		CMDS = `axis${AxisID}.encoder.config.use_index`;
		break;
	case ODRIVE_TAG.PM_FLUX_LINKAGE:
		CMDS = `axis${AxisID}.sensorless_estimator.config.pm_flux_linkage`;
		break;
	case ODRIVE_TAG.ENCODER_OFFSET:
		CMDS = `axis${AxisID}.encoder.config.phase_offset`;
		break;
	case ODRIVE_TAG.ENCODER_OFFSET_FLOAT:
		CMDS = `axis${AxisID}.encoder.config.phase_offset_float`;
		break;
	case ODRIVE_TAG.ENCODER_PRE_CALIBRATED:
		CMDS = `axis${AxisID}.encoder.config.pre_calibrated`;
		break;
	case ODRIVE_TAG.CURRENT_LIM:
		CMDS = `axis${AxisID}.motor.config.current_lim`;
		break;
	case ODRIVE_TAG.VEL_LIMIT:
		CMDS = `axis${AxisID}.controller.config.vel_limit`;
		break;
	case ODRIVE_TAG.VEL_LIMIT_TOLERANCE:
		CMDS = `axis${AxisID}.controller.config.vel_limit_tolerance`;
		break;
	case ODRIVE_TAG.POS_GAIN:
		CMDS = `axis${AxisID}.controller.config.pos_gain`;
		break;
	case ODRIVE_TAG.VEL_GAIN:
		CMDS = `axis${AxisID}.controller.config.vel_gain`;
		break;
	case ODRIVE_TAG.VEL_INTEGRATOR_GAIN:
		CMDS = `axis${AxisID}.controller.config.vel_integrator_gain`;
		break;
	case ODRIVE_TAG.CONTROL_MODE:
		CMDS = `axis${AxisID}.controller.config.control_mode`;
		break;
	case ODRIVE_TAG.MEASURED_CURRENT:
		CMDS = `axis${AxisID}.motor.current_control.Iq_measured`;
		break;
	case ODRIVE_TAG.COMMAND_CURRENT:
		CMDS = `axis${AxisID}.motor.current_control.Iq_setpoint`;
		break;
	case ODRIVE_TAG.FET_TEMPERATURE:
		CMDS = `axis${AxisID}.motor.fet_thermistor.temperature`;
		break;
	case ODRIVE_TAG.ENABLE_DC_BUS_OVERVOLTAGE_RAMP:
		CMDS = 'config.enable_dc_bus_overvoltage_ramp';
		break;
	case ODRIVE_TAG.DC_BUS_OVERVOLTAGE_RAMP_START:
		CMDS = 'config.dc_bus_overvoltage_ramp_start';
		break;
	case ODRIVE_TAG.GPIO1_MODE:
		CMDS = 'config.gpio1_mode';
		break;
	case ODRIVE_TAG.GPIO2_MODE:
		CMDS = 'config.gpio2_mode';
		break;
	case ODRIVE_TAG.GPIO3_MODE:
		CMDS = 'config.gpio3_mode';
		break;
	case ODRIVE_TAG.GPIO4_MODE:
		CMDS = 'config.gpio4_mode';
		break;
	case ODRIVE_TAG.GPIO5_MODE:
		CMDS = 'config.gpio5_mode';
		break;
	case ODRIVE_TAG.GPIO6_MODE:
		CMDS = 'config.gpio6_mode';
		break;
	case ODRIVE_TAG.GPIO7_MODE:
		CMDS = 'config.gpio7_mode';
		break;
	case ODRIVE_TAG.GPIO8_MODE:
		CMDS = 'config.gpio8_mode';
		break;
	case ODRIVE_TAG.HOMING_SPEED:
		CMDS = `axis${AxisID}.controller.config.homing_speed`;
		break;
	case ODRIVE_TAG.MIN_ENDSTOP_GPIO_NUM:
		CMDS = `axis${AxisID}.min_endstop.config.gpio_num`;
		break;
	case ODRIVE_TAG.MIN_ENDSTOP_IS_ACTIVE_HIGH:
		CMDS = `axis${AxisID}.min_endstop.config.is_active_high`;
		break;
	case ODRIVE_TAG.MIN_ENDSTOP_DEBOUNCE:
		CMDS = `axis${AxisID}.min_endstop.config.debounce_ms`;
		break;
	case ODRIVE_TAG.MIN_ENDSTOP_OFFSET:
		CMDS = `axis${AxisID}.min_endstop.config.offset`;
		break;
	case ODRIVE_TAG.MIN_ENDSTOP_ENABLED:
		CMDS = `axis${AxisID}.min_endstop.config.enabled`;
		break;
	case ODRIVE_TAG.MIN_ENDSTOP_STATE:
		CMDS = `axis${AxisID}.min_endstop.endstop_state`;
		break;
	case ODRIVE_TAG.TRAJ_VEL_LIMIT:
		CMDS = `axis${AxisID}.trap_traj.config.vel_limit`;
		break;
	case ODRIVE_TAG.TRAJ_ACCEL_LIMIT:
		CMDS = `axis${AxisID}.trap_traj.config.accel_limit`;
		break;
	case ODRIVE_TAG.TRAJ_DECEL_LIMIT:
		CMDS = `axis${AxisID}.trap_traj.config.decel_limit`;
		break;
	case ODRIVE_TAG.RESISTANCE_CALIB_MAX_VOLTAGE:
		CMDS = `axis${AxisID}.motor.config.resistance_calib_max_voltage`;
		break;
	case ODRIVE_TAG.REQUESTED_CURRENT_RANGE:
		CMDS = `axis${AxisID}.motor.config.requested_current_range`;
		break;
	case ODRIVE_TAG.CURRENT_CONTROL_BANDWIDTH:
		CMDS = `axis${AxisID}.motor.config.current_control_bandwidth`;
		break;
	case ODRIVE_TAG.CURRENT_LIMIT_TOLERANCE:
		CMDS = `axis${AxisID}.motor.config.current_lim_tolerance`;
		break;
	case ODRIVE_TAG.DC_MAX_NEGATIVE_CURRENT:
		CMDS = 'config.dc_max_negative_current';
		break;
	case ODRIVE_TAG.ENABLE_BRAKE_RESISTOR:
		CMDS = 'config.enable_brake_resistor';
		break;
	case ODRIVE_TAG.PHASE_INDUCTANCE:
		CMDS = `axis${AxisID}.motor.config.phase_inductance`;
		break;
	case ODRIVE_TAG.PHASE_RESISTANCE:
		CMDS = `axis${AxisID}.motor.config.phase_resistance`;
		break;
	case ODRIVE_TAG.CALIBRATION_VELOCITY:
		CMDS = `axis${AxisID}.config.calibration_lockin.vel`;
		break;
	case ODRIVE_TAG.CALIBRATION_ACCEL:
		CMDS = `axis${AxisID}.config.calibration_lockin.accel`;
		break;
	case ODRIVE_TAG.CALIBRATION_RAMP:
		CMDS = `axis${AxisID}.config.calibration_lockin.ramp_distance`;
		break;
	case ODRIVE_TAG.CALIBRATION_INDEX_CURRENT:
		CMDS = `axis${AxisID}.config.calibration_lockin.current`;
		break;
	case ODRIVE_TAG.GENERAL_ERROR:
		CMDS = `axis${AxisID}.error`;
		break;
	case ODRIVE_TAG.MOTOR_ERROR:
		CMDS = `axis${AxisID}.motor.error`;
		break;
	case ODRIVE_TAG.ENCODER_ERROR:
		CMDS = `axis${AxisID}.encoder.error`;
		break;
	case ODRIVE_TAG.DRV_ERROR:
		CMDS = `axis${AxisID}.motor.gate_driver.drv_fault`;
		break;
	case ODRIVE_TAG.CONTROLLER_ERROR:
		CMDS = `axis${AxisID}.controller.error`;
		break;
	case ODRIVE_TAG.DRV_ERROR_FLAG:
		CMDS = `axis${AxisID}.last_drv_fault`;
		break;
	case ODRIVE_TAG.MOTOR_IS_CALIBRATED:
		CMDS = `axis${AxisID}.motor.is_calibrated`;
		break;
	case ODRIVE_TAG.ENCODER_IS_READY:
		CMDS = `axis${AxisID}.encoder.is_ready`;
		break;
	case ODRIVE_TAG.ENCODER_POS_ESTIMATE:
		CMDS = `axis${AxisID}.encoder.pos_estimate`;
		break;
	case ODRIVE_TAG.CURRENT_STATE:
		CMDS = `axis${AxisID}.current_state`;
		break;
	case ODRIVE_TAG.REQUEST_STATE:
		CMDS = `axis${AxisID}.requested_state`;
		break;
	case ODRIVE_TAG.VBUS_VOLTAGE:
		CMDS = 'vbus_voltage';
		break;
	case ODRIVE_TAG.C_CMD:
		CMDS = `axis${AxisID}.set.conf`;
		break;
	}
	
	return CMDS;
};

const GenerateWriteDriveSimCommand = (
	TargetDrive = 0,
	TargetAxis = 0,
	ODRIVE_TAG,
	Value = ''
) => {
	CounterCMD();
	const commandStr = CommandDriveString(ODRIVE_TAG, TargetAxis);
	const checkSum = GetCheckSum(`w ${commandStr} ${Value}`);
	return `[${CMDCounter}]drive(${TargetDrive}).write(${checkSum})`;
};

const GenerateReadDriveSimCommand = (
	TargetDrive = 0,
	TargetAxis = 0,
	ODRIVE_TAG,
	Value = ''
) => {
	CounterCMD();
	const commandStr = CommandDriveString(ODRIVE_TAG, TargetAxis);
	const checkSum = GetCheckSum(`r ${commandStr} ${Value}`);
	return `[${CMDCounter}]drive(${TargetDrive}).write(${checkSum})`;
};

const GenerateWriteT = (TargetDrive = 0, TargetAxis = 0, Taxt) => {
	CounterCMD();
	return `[${CMDCounter}]drive(${TargetDrive}).write(t ${TargetAxis} ${Taxt})`;
};

const GenerateDriveOtherCommand = (TargetDrive, ODRIVE_TAG) => {
	CounterCMD();
	return `[${CMDCounter}]drive(${TargetDrive}).write(${ODRIVE_TAG})`;
};

const GetCurrentCMDID = () => CMDCounter;

const GeneralError = (ErrID) => {
	const ErrList = {
		0: 'NONE',
		1: 'INVALID_STATE',
		2: 'DC_BUS_UNDER_VOLTAGE',
		4: 'DC_BUS_OVER_VOLTAGE',
		8: 'CURRENT_MEASUREMENT_TIMEOUT',
		16: 'BRAKE_RESISTOR_DISARMED',
		32: 'MOTOR_DISARMED',
		64: 'MOTOR_FAILED',
		128: 'SENSORLESS_ESTIMATOR_FAILED',
		256: 'ENCODER_FAILED',
		512: 'CONTROLLER_FAILED',
		1024: 'POS_CTRL_DURING_SENSORLESS',
		2048: 'WATCHDOG_TIMER_EXPIRED',
	};
	return ErrList[ErrID] ? ErrList[ErrID] : 'UNKNOW';
};

const CHANEL_FONTEND_RECIEVED = {
	KEY_EMIT_TERMINAL_T_CLIENT: 'KEY_EMIT_TERMINAL_T_CLIENT',
	KEY_EMIT_DRIVE_STATE_T_CLIENT: 'KEY_EMIT_DRIVE_STATE_T_CLIENT',
	KEY_EMIT_MOTOR_STATE_T_CLENT: 'KEY_EMIT_MOTOR_STATE_T_CLENT',
	KEY_EMIT_LAST_AXIS_POSITION_T_CLENT: 'KEY_EMIT_LAST_AXIS_POSITION_T_CLENT',
	KEY_EMIT_ODRIVE_T_TBL_T_CLENT: 'KEY_EMIT_ODRIVE_T_TBL_T_CLENT',
	KEY_EMIT_GET_RAW_ENCODER_T_TBL_T_CLENT:
    'KEY_EMIT_GET_RAW_ENCODER_T_TBL_T_CLENT',
	SYS_CONTOLL_ERROR_LIST: 'SYS_CONTOLL_ERROR_LIST',
	SYS_CONTOLL_STATUS_LIST: 'SYS_CONTOLL_STATUS_LIST',
	KEY_EMIT_TOOLBAR: 'KEY_EMIT_TOOLBAR',
	KEY_EMIT_MOTION_STATE_T_CLENT: 'KEY_EMIT_MOTION_STATE_T_CLENT',
};

const CHANEL_BACKEND_RECIEVED = {
	KEY_RECIEVE_AXIS_MOVE_COMMAND_F_CLIENT:
    'KEY_RECIEVE_AXIS_MOVE_COMMAND_F_CLIENT',
	KEY_RECIEVE_ODRIVE_COMMAND_F_CLIENT: 'KEY_RECIEVE_ODRIVE_COMMAND_F_CLIENT',
	KEY_RECIEVE_SIM_COMMAND_F_CLIENT: 'KEY_RECIEVE_SIM_COMMAND_F_CLIENT',
	KEY_RECIEVE_ODRIVE_COMMAND_READ_ALL_F_CLIENT:
    'KEY_RECIEVE_ODRIVE_COMMAND_READ_ALL_F_CLIENT',
	KEY_RECIEVED_RATIO: 'KEY_RECIEVED_RATIO',
	NEED_CONTROL: 'NEED_CONTROL',
};

class PayloadOdriveWriteRatio {
	constructor(
		TargetDrive = 0,
		TargetAxis = 0,
		xPOS = 0.0,
		xCPR = 1,
		xRaito = 0.0,
		MoveScale = 0,
		isExtar = false
	) {
		this.TargetDrive = TargetDrive;
		this.TargetAxis = TargetAxis;
		this.xPOS = xPOS;
		this.xRaito = xRaito;
		this.xCPR = xCPR;
		this.MoveScale = MoveScale;
		this.isExtar = isExtar;
		this.EmitKey = CHANEL_BACKEND_RECIEVED.KEY_RECIEVED_RATIO;
		this.ValidDateConstructor();
	}

	ValidDateConstructor() {
		if (
			this.TargetDrive === null ||
      this.TargetDrive === undefined ||
      this.TargetDrive === ''
		) {
			throw Error('TargetDrive is require!');
		}

		if (
			this.TargetAxis === null ||
      this.TargetAxis === undefined ||
      this.TargetAxis === ''
		) {
			throw Error('TargetAxis is require!');
		}

		if (
			this.xCPR === null ||
      this.xCPR === undefined ||
      typeof this.xCPR !== 'number'
		) {
			throw Error('xCPR is require and Number!');
		}

		if (
			this.xPOS === null ||
      this.xPOS === undefined ||
      typeof this.xPOS !== 'number'
		) {
			throw Error('xPOS is require and Number!');
		}

		if (
			this.xRaito === null ||
      this.xRaito === undefined ||
      typeof this.xRaito !== 'number'
		) {
			throw Error('xRaito is require and Number!');
		}

		if (
			this.MoveScale === null ||
      this.MoveScale === undefined ||
      typeof this.MoveScale !== 'number'
		) {
			throw Error('MoveScale is require and Number!');
		}
	}

	CalculateXValue() {
		let value = 0.0;
		if (this.xRaito > 0.0 && this.MoveScale > 0) {
			value = ((this.xCPR * this.xRaito) / 360) * this.MoveScale;
		}
		return this.isExtar ? this.xPOS + value : this.xPOS - value;
	}

	GetPayloadObj() {
		return {
			key: this.EmitKey,
			value: {
				DriveNo: this.TargetDrive,
				AxisNo: this.TargetAxis,
				Value: this.CalculateXValue(),
			},
		};
	}
}

class PayloadReadWriteOdriveSingle {
	constructor(
		ClientOdriveCommand,
		DriveNo,
		AxisNo,
		KeyMaster,
		KeySub,
		Value = ''
	) {
		this.ClientOdriveCommand = ClientOdriveCommand;
		this.DriveNo = DriveNo;
		this.AxisNo = AxisNo;
		this.KeyMaster = KeyMaster;
		this.KeySub = KeySub;
		this.Value = Value;
		this.IsError = false;
		this.ErrorMessage = '';
		this.KeyEmit = CHANEL_BACKEND_RECIEVED.KEY_RECIEVE_ODRIVE_COMMAND_F_CLIENT;
		this.ValidDateConstructor();
	}

	ValidDateConstructor() {
		if (
			this.ClientOdriveCommand === null ||
      this.ClientOdriveCommand === undefined ||
      this.ClientOdriveCommand === ''
		) {
			this.IsError = true;
			this.ErrorMessage = 'ClientOdriveCommand is require!';
			return;
		}

		if (
			this.DriveNo === null ||
      this.DriveNo === undefined ||
      this.DriveNo === ''
		) {
			this.IsError = true;
			this.ErrorMessage = 'DriveNo is require!';
			return;
		}

		if (
			this.AxisNo === null ||
      this.AxisNo === undefined ||
      this.AxisNo === ''
		) {
			this.IsError = true;
			this.ErrorMessage = 'AxisNo is require!';
			return;
		}
	}

	GeneratePayloadObj() {
		if (this.IsError) throw Error(this.ErrorMessage);
		return {
			key: this.KeyEmit,
			value: {
				CommandNumber: this.ClientOdriveCommand,
				Payload: {
					KeyMaster: this.KeyMaster,
					KeySub: this.KeySub,
					DriveNo: this.DriveNo,
					AxisNo: this.AxisNo,
					Value: this.Value,
				},
			},
		};
	}

	GetKeyMitToServer() {
		return this.KeyEmit;
	}
}

class PayloadReadWriteOdriveMulti {
	constructor() {
		this.arrayOfPayload = [];
		this.KeyEmit =
      CHANEL_BACKEND_RECIEVED.KEY_RECIEVE_ODRIVE_COMMAND_READ_ALL_F_CLIENT;
	}

	AddPayloadObj(
		ClientOdriveCommand,
		DriveNo,
		AxisNo,
		KeyMaster,
		KeySub,
		Value = ''
	) {
		const instance = new PayloadReadWriteOdriveSingle(
			ClientOdriveCommand,
			DriveNo,
			AxisNo,
			KeyMaster,
			KeySub,
			Value
		);
		const data = instance.GeneratePayloadObj();
		if (data) this.arrayOfPayload.push(data.value);
	}

	GeneratePayloadObj() {
		if (this.arrayOfPayload.length === 0)
			throw Error(
				'This function need resouce before generate, Please call AddPayloadObj!'
			);
		return {
			key: this.KeyEmit,
			value: this.arrayOfPayload,
		};
	}
}

class PayloadMotionControl {
	constructor(ClientOdriveCommand) {
		this.ClientOdriveCommand = ClientOdriveCommand;
		this.IsError = false;
		this.ErrorMessage = '';
		this.KeyEmit = CHANEL_BACKEND_RECIEVED.KEY_RECIEVE_SIM_COMMAND_F_CLIENT;
		this.ValidDateConstructor();
	}

	ValidDateConstructor() {
		if (
			this.ClientOdriveCommand === null ||
      this.ClientOdriveCommand === undefined ||
      this.ClientOdriveCommand === ''
		) {
			this.IsError = true;
			this.ErrorMessage = 'ClientOdriveCommand is require!';
			return;
		}
	}

	GeneratePayloadObj() {
		if (this.IsError) throw Error(this.ErrorMessage);
		return {
			key: this.KeyEmit,
			value: this.ClientOdriveCommand,
		};
	}

	GetKeyMitToServer() {
		return this.KeyEmit;
	}
}

const GenratePayloadOdriveSingle = (
	_Code,
	_DriveNo,
	_AxisNo,
	_Value,
	_MasterKey,
	_SubKey
) => {
	const instance = new PayloadReadWriteOdriveSingle(
		_Code,
		_DriveNo,
		_AxisNo,
		_MasterKey,
		_SubKey,
		_Value
	);
	return instance.GeneratePayloadObj();
};

const GenratePayloadOdriveArrayCodeAll = (_Code = [], _DriveNo, _AxisNo) => {
	const instance = new PayloadReadWriteOdriveMulti();
	_Code.forEach((el) => {
		instance.AddPayloadObj(el, _DriveNo, _AxisNo);
	});
	return instance.GeneratePayloadObj();
};

const GenratePayloadMotionControl = (_Code) => {
	const instance = new PayloadMotionControl(_Code);
	return instance.GeneratePayloadObj();
};

const GenratePaylaodMoveAxis = (_Roll, _Pitch, _Yaw, _Heave, _Surge, _Sway) => {
	return {
		key: CHANEL_BACKEND_RECIEVED.KEY_RECIEVE_AXIS_MOVE_COMMAND_F_CLIENT,
		value: { _Roll, _Pitch, _Yaw, _Heave, _Surge, _Sway },
	};
};

const GenratePaylaodSetRatio = (
	TargetDrive = 0,
	TargetAxis = 0,
	xPOS = 0.0,
	xRaito = 0.0,
	MoveScale = 0,
	isExtar = false
) => {
	const xCPR = 1;

	const instance = new PayloadOdriveWriteRatio(
		TargetDrive,
		TargetAxis,
		xPOS,
		xCPR,
		xRaito,
		MoveScale,
		isExtar
	);
	return instance.GetPayloadObj();
};

module.exports = {
	CLIENT_COMMAND_SIM,
	CLIENT_ODRIVE_COMMAND,
	GenerateWriteDriveSimCommand,
	GenerateReadDriveSimCommand,
	COMMAND_TO_SIMULATOR,
	GenerateDriveOtherCommand,
	ODRIVE_TAG,
	GetCurrentCMDID,
	GeneralError,
	CHANEL_FONTEND_RECIEVED,
	CHANEL_BACKEND_RECIEVED,
	GenratePayloadOdriveSingle,
	GenratePayloadOdriveArrayCodeAll,
	GenratePayloadMotionControl,
	GenratePaylaodMoveAxis,
	GenerateWriteT,
	GenratePaylaodSetRatio,
	STATE_MOTOR_STATUS,
	STATE_DRIVE_STATUS,
};