libjaka_rs/types/
robot_type.rs

1use std::marker::ConstParamTy;
2
3use robot_behavior::{RobotException, RobotResult};
4use serde::{Deserialize, Serialize, de::DeserializeOwned};
5use serde_json::Value;
6use serde_with::serde_as;
7
8pub trait CommandSerde: Sized {
9    fn serialize(&self) -> String;
10    fn deserialize(data: &str) -> RobotResult<Self>;
11}
12
13#[derive(ConstParamTy, PartialEq, Eq, Serialize, Deserialize, Debug)]
14pub enum Command {
15    #[serde(rename = "power_on")]
16    PowerOn,
17    #[serde(rename = "power_off")]
18    PowerOff,
19    #[serde(rename = "enable_robot")]
20    EnableRobot,
21    #[serde(rename = "joint_move")]
22    JointMove,
23    #[serde(rename = "end_move")]
24    EndMove,
25    #[serde(rename = "shutdown")]
26    Shutdown,
27    #[serde(rename = "quit")]
28    Quit,
29    #[serde(rename = "get_robot_state")]
30    GetRobotState,
31    #[serde(rename = "disable_robot")]
32    DisableRobot,
33    #[serde(rename = "torque_control_enable")]
34    TorqueControlEnable,
35    #[serde(rename = "torque_feedforward")]
36    TorqueFeedforward,
37    #[serde(rename = "servo_move")]
38    ServoMove,
39    #[serde(rename = "servo_j")]
40    ServoJ,
41    #[serde(rename = "servo_p")]
42    ServoP,
43    #[serde(rename = "get_data")]
44    GetData,
45    #[serde(rename = "rapid_rate")]
46    RapidRate,
47    #[serde(rename = "load_program")]
48    LoadProgram,
49    #[serde(rename = "get_loaded_program")]
50    GetLoadedProgram,
51    #[serde(rename = "play_program")]
52    PlayProgram,
53    #[serde(rename = "pause_program")]
54    PauseProgram,
55    #[serde(rename = "resume_program")]
56    ResumeProgram,
57    #[serde(rename = "stop_program")]
58    StopProgram,
59    #[serde(rename = "get_program_state")]
60    GetProgramState,
61    #[serde(rename = "set_digital_output")]
62    SetDigitalOutput,
63    #[serde(rename = "get_digital_input_status")]
64    GetDigitalInputStatus,
65    #[serde(rename = "set_analog_output")]
66    SetAnalogOutput,
67    #[serde(rename = "set_tool_offsets")]
68    SetToolOffsets,
69    #[serde(rename = "set_tool_id")]
70    SetToolId,
71    #[serde(rename = "set_user_offsets")]
72    SetUserOffsets,
73    #[serde(rename = "set_user_id")]
74    SetUserId,
75    #[serde(rename = "get_extio_status")]
76    GetExtioStatus,
77    #[serde(rename = "get_funcdi_status")]
78    GetFuncdiStatus,
79    #[serde(rename = "drag_status")]
80    DragStatus,
81    #[serde(rename = "query_user_defined_variable")]
82    QueryUserDefinedVariable,
83    #[serde(rename = "modify_user_defined_variable")]
84    ModifyUserDefinedVariable,
85    #[serde(rename = "protective_stop_status")]
86    ProtectiveStopStatus,
87    #[serde(rename = "jog")]
88    Jog,
89    #[serde(rename = "moveL")]
90    MoveL,
91    #[serde(rename = "wait_complete")] //DEPRECATED
92    WaitComplete, //DEPRECATED
93    #[serde(rename = "set_payload")]
94    SetPayload,
95    #[serde(rename = "get_payload")]
96    GetPayload,
97    #[serde(rename = "set_clsn_sensitivity")]
98    SetClsnSensitivity,
99    #[serde(rename = "get_clsn_sensitivity")]
100    GetClsnSensitivity,
101    #[serde(rename = "kine_forward")]
102    KineForward,
103    #[serde(rename = "kine_inverse")]
104    KineInverse,
105    #[serde(rename = "clear_error")]
106    ClearError,
107    #[serde(rename = "get_joint_pos")]
108    GetJointPos,
109    #[serde(rename = "get_tcp_pos")]
110    GetTcpPos,
111}
112pub struct Request<const C: Command, D> {
113    pub data: D,
114}
115
116pub struct Response<const C: Command, S> {
117    pub state: S,
118}
119
120pub enum ErrorCode {
121    Success,
122    Exception,
123    Error,
124}
125
126#[derive(Serialize, Deserialize)]
127pub struct DefaultState {
128    #[serde(rename = "errorCode")]
129    pub error_code: String,
130    #[serde(rename = "errorMsg")]
131    pub error_msg: String,
132}
133
134// power on
135pub type PowerOnRequest = Request<{ Command::PowerOn }, ()>;
136pub type PowerOnResponse = Response<{ Command::PowerOn }, PowerOnState>;
137pub type PowerOnState = DefaultState;
138
139// power off
140pub type PowerOffRequest = Request<{ Command::PowerOff }, ()>;
141pub type PowerOffResponse = Response<{ Command::PowerOff }, PowerOffState>;
142pub type PowerOffState = DefaultState;
143
144// enable robot
145pub type EnableRobotRequest = Request<{ Command::EnableRobot }, ()>;
146pub type EnableRobotResponse = Response<{ Command::EnableRobot }, EnableRobotState>;
147pub type EnableRobotState = DefaultState;
148
149// joint move
150pub type JointMoveRequest = Request<{ Command::JointMove }, JointMoveData>;
151pub type JointMoveResponse = Response<{ Command::JointMove }, JointMoveState>;
152pub type JointMoveState = DefaultState;
153#[derive(Serialize, Deserialize)]
154pub struct JointMoveData {
155    #[serde(rename = "jointPosition")]
156    pub joint_position: [f64; 6],
157    pub speed: f64,
158    pub accel: f64,
159    #[serde(rename = "relFlag")]
160    pub relflag: u8,
161}
162
163// end move
164pub type EndMoveRequest = Request<{ Command::EndMove }, EndMoveData>;
165pub type EndMoveResponse = Response<{ Command::EndMove }, EndMoveState>;
166pub type EndMoveState = DefaultState;
167#[derive(Serialize, Deserialize)]
168pub struct EndMoveData {
169    #[serde(rename = "endPosition")]
170    pub end_position: [f64; 6],
171    pub speed: f64,
172    pub accel: f64,
173}
174
175// shutdown
176pub type ShutdownRequest = Request<{ Command::Shutdown }, ()>;
177pub type ShutdownResponse = Response<{ Command::Shutdown }, ShutdownState>;
178pub type ShutdownState = DefaultState;
179
180// quit
181pub type QuitRequest = Request<{ Command::Quit }, ()>;
182pub type QuitResponse = Response<{ Command::Quit }, QuitState>;
183pub type QuitState = DefaultState;
184
185// get robot state
186pub type GetRobotStateRequest = Request<{ Command::GetRobotState }, ()>;
187pub type GetRobotStateResponse = Response<{ Command::GetRobotState }, GetRobotStateState>;
188#[derive(Serialize, Deserialize)]
189pub struct GetRobotStateState {
190    #[serde(rename = "errorCode")]
191    pub error_code: String,
192    #[serde(rename = "errorMsg")]
193    pub error_msg: String,
194    pub enable: String,
195    pub power: String,
196}
197
198// disable robot
199pub type DisableRobotRequest = Request<{ Command::DisableRobot }, ()>;
200pub type DisableRobotResponse = Response<{ Command::DisableRobot }, DisableRobotState>;
201pub type DisableRobotState = DefaultState;
202
203// torque control enable
204pub type TorqueControlEnableRequest =
205    Request<{ Command::TorqueControlEnable }, TorqueControlEnableData>;
206pub type TorqueControlEnableResponse =
207    Response<{ Command::TorqueControlEnable }, TorqueControlEnableState>;
208pub type TorqueControlEnableState = DefaultState;
209#[derive(Serialize, Deserialize)]
210pub struct TorqueControlEnableData {
211    pub enable_flag: u8,
212}
213
214// torque feedforward
215pub type TorqueFeedforwardRequest = Request<{ Command::TorqueFeedforward }, TorqueFeedforwardData>;
216pub type TorqueFeedforwardResponse =
217    Response<{ Command::TorqueFeedforward }, TorqueFeedforwardState>;
218pub type TorqueFeedforwardState = DefaultState;
219#[derive(Serialize, Deserialize)]
220pub struct TorqueFeedforwardData {
221    #[serde(rename = "grvCurrent")]
222    pub grv_current: [f64; 6],
223    #[serde(rename = "includeGrvFlag")]
224    pub includegrvflag: u8,
225}
226
227// servo move
228pub type ServoMoveRequest = Request<{ Command::ServoMove }, ServoMoveData>;
229pub type ServoMoveResponse = Response<{ Command::ServoMove }, ServoMoveState>;
230pub type ServoMoveState = DefaultState;
231#[derive(Serialize, Deserialize)]
232pub struct ServoMoveData {
233    #[serde(rename = "relFlag")]
234    pub relflag: u8,
235}
236
237// servo j
238pub type ServoJRequest = Request<{ Command::ServoJ }, ServoJData>;
239pub type ServoJResponse = Response<{ Command::ServoJ }, ServoJState>;
240pub type ServoJState = DefaultState;
241#[derive(Serialize, Deserialize)]
242pub struct ServoJData {
243    #[serde(rename = "jointAngles")]
244    pub joint_angles: [f64; 6],
245    #[serde(rename = "relFlag")]
246    pub relflag: u8,
247}
248
249// servo p
250pub type ServoPRequest = Request<{ Command::ServoP }, ServoPData>;
251pub type ServoPResponse = Response<{ Command::ServoP }, ServoPState>;
252pub type ServoPState = DefaultState;
253#[derive(Serialize, Deserialize)]
254pub struct ServoPData {
255    #[serde(rename = "catPosition")]
256    pub cat_position: [f64; 6],
257    #[serde(rename = "relFlag")]
258    pub relflag: u8,
259}
260
261// get data
262pub type GetDataRequest = Request<{ Command::GetData }, ()>;
263pub type GetDataResponse = Response<{ Command::GetData }, GetDataState>;
264
265#[serde_as]
266#[derive(Serialize, Deserialize)]
267pub struct GetDataState {
268    pub len: u16,
269    pub joint_actual_position: [f64; 6],
270    pub drag_status: bool,
271    pub actual_position: [f64; 6],
272    #[serde_as(as = "[_; 199]")]
273    pub din: [u8; 199],
274    #[serde_as(as = "[_; 199]")]
275    pub dout: [u8; 199],
276    #[serde_as(as = "[_; 128]")]
277    pub ain: [f64; 128],
278    #[serde_as(as = "[_; 128]")]
279    pub aout: [f64; 128],
280    pub tio_din: [u8; 8],
281    #[serde_as(as = "[_; 8]")]
282    pub tio_dout: [u8; 8],
283    #[serde_as(as = "[_; 2]")]
284    pub tio_ain: [f64; 2],
285    #[serde_as(as = "[_; 2]")]
286    pub relay_io: [u8; 2],
287    #[serde_as(as = "[_; 128]")]
288    pub mb_slave_din: [u8; 128],
289    #[serde_as(as = "[_; 128]")]
290    pub mb_slave_dout: [u8; 128],
291    #[serde_as(as = "[_; 64]")]
292    pub mb_slave_ain: [f64; 64],
293    #[serde_as(as = "[_; 64]")]
294    pub mb_slave_aout: [f64; 64],
295    #[serde_as(as = "[_; 64]")]
296    pub pn_dev_din: [u8; 64],
297    #[serde_as(as = "[_; 64]")]
298    pub pn_dev_dout: [u8; 64],
299    #[serde_as(as = "[_; 64]")]
300    pub pn_dev_ain: [f64; 64],
301    #[serde_as(as = "[_; 64]")]
302    pub pn_dev_aout: [f64; 64],
303    #[serde_as(as = "[_; 64]")]
304    pub eip_adpt_din: [u8; 64],
305    #[serde_as(as = "[_; 64]")]
306    pub eip_adpt_dout: [u8; 64],
307    #[serde_as(as = "[_; 48]")]
308    pub eip_adpt_ain: [f64; 48],
309    #[serde_as(as = "[_; 48]")]
310    pub eip_adpt_aout: [f64; 48],
311    pub task_state: u8,
312    pub homed: [u8; 9],
313    pub task_mode: u8,
314    pub interp_state: u8,
315    pub enabled: bool,
316    pub paused: bool,
317    pub rapidrate: f64,
318    pub current_tool_id: u8,
319    pub current_user_id: u8,
320    pub protective_stop: u8,
321    pub on_soft_limit: u8,
322    pub emergency_stop: u8,
323    pub drag_near_limit: [u8; 6],
324    pub powered_on: u8,
325    pub inpos: bool,
326    pub executing_line: u8,
327    pub curr_tcp_trans_vel: f64,
328
329    // #[serde(rename = "cmdName")]
330    // pub cmd_name: String,
331    #[serde(rename = "errorCode")]
332    pub error_code: String,
333    #[serde(rename = "errorMsg")]
334    pub error_msg: String,
335}
336
337// rapid rate
338pub type RapidRateRequest = Request<{ Command::RapidRate }, RapidRateData>;
339pub type RapidRateResponse = Response<{ Command::RapidRate }, RapidRateState>;
340pub type RapidRateState = DefaultState;
341#[derive(Serialize, Deserialize)]
342pub struct RapidRateData {
343    pub rate_value: f64,
344}
345
346// load program
347pub type LoadProgramRequest = Request<{ Command::LoadProgram }, LoadProgramData>;
348pub type LoadProgramResponse = Response<{ Command::LoadProgram }, LoadProgramState>;
349pub type LoadProgramState = DefaultState;
350#[derive(Serialize, Deserialize)]
351pub struct LoadProgramData {
352    #[serde(rename = "programName")]
353    pub program_name: String,
354}
355
356// get loaded program
357pub type GetLoadedProgramRequest = Request<{ Command::GetLoadedProgram }, ()>;
358pub type GetLoadedProgramResponse = Response<{ Command::GetLoadedProgram }, GetLoadedProgramState>;
359#[derive(Serialize, Deserialize)]
360pub struct GetLoadedProgramState {
361    #[serde(rename = "errorCode")]
362    pub error_code: String,
363    #[serde(rename = "errorMsg")]
364    pub error_msg: String,
365    #[serde(rename = "programName")]
366    pub program_name: String,
367}
368
369// play program
370pub type PlayProgramRequest = Request<{ Command::PlayProgram }, ()>;
371pub type PlayProgramResponse = Response<{ Command::PlayProgram }, PlayProgramState>;
372pub type PlayProgramState = DefaultState;
373
374// pause program
375pub type PauseProgramRequest = Request<{ Command::PauseProgram }, ()>;
376pub type PauseProgramResponse = Response<{ Command::PauseProgram }, PauseProgramState>;
377pub type PauseProgramState = DefaultState;
378
379// resume program
380pub type ResumeProgramRequest = Request<{ Command::ResumeProgram }, ()>;
381pub type ResumeProgramResponse = Response<{ Command::ResumeProgram }, ResumeProgramState>;
382pub type ResumeProgramState = DefaultState;
383
384// stop program
385pub type StopProgramRequest = Request<{ Command::StopProgram }, ()>;
386pub type StopProgramResponse = Response<{ Command::StopProgram }, StopProgramState>;
387pub type StopProgramState = DefaultState;
388
389// get program state
390pub type GetProgramStateRequest = Request<{ Command::GetProgramState }, ()>;
391pub type GetProgramStateResponse = Response<{ Command::GetProgramState }, GetProgramStateState>;
392#[derive(Serialize, Deserialize)]
393pub struct GetProgramStateState {
394    #[serde(rename = "errorCode")]
395    pub error_code: String,
396    #[serde(rename = "errorMsg")]
397    pub error_msg: String,
398    #[serde(rename = "programName")]
399    pub program_state: String,
400}
401
402// set digital output
403pub type SetDigitalOutputRequest = Request<{ Command::SetDigitalOutput }, SetDigitalOutputData>;
404pub type SetDigitalOutputResponse = Response<{ Command::SetDigitalOutput }, SetDigitalOutputState>;
405pub type SetDigitalOutputState = DefaultState;
406#[derive(Serialize, Deserialize)]
407pub struct SetDigitalOutputData {
408    #[serde(rename = "type")]
409    pub type_number: u8,
410    pub index: u8,
411    pub value: u8,
412}
413
414// get digital input status
415pub type GetDigitalInputStatusRequest = Request<{ Command::GetDigitalInputStatus }, ()>;
416pub type GetDigitalInputStatusResponse =
417    Response<{ Command::GetDigitalInputStatus }, GetDigitalInputStatusState>;
418#[serde_as]
419#[derive(Serialize, Deserialize)]
420pub struct GetDigitalInputStatusState {
421    #[serde(rename = "errorCode")]
422    pub error_code: String,
423    #[serde(rename = "errorMsg")]
424    pub error_msg: String,
425    #[serde_as(as = "[_; 64]")]
426    pub din_status: [u8; 64],
427}
428
429// set analog output
430pub type SetAnalogOutputRequest = Request<{ Command::SetAnalogOutput }, SetAnalogOutputData>;
431pub type SetAnalogOutputResponse = Response<{ Command::SetAnalogOutput }, SetAnalogOutputState>;
432pub type SetAnalogOutputState = DefaultState;
433#[derive(Serialize, Deserialize)]
434pub struct SetAnalogOutputData {
435    #[serde(rename = "type")]
436    pub type_number: u8,
437    pub index: u8,
438    pub value: f64,
439}
440
441// set tool offsets
442pub type SetToolOffsetsRequest = Request<{ Command::SetToolOffsets }, SetToolOffsetsData>;
443pub type SetToolOffsetsResponse = Response<{ Command::SetToolOffsets }, SetToolOffsetsState>;
444pub type SetToolOffsetsState = DefaultState;
445#[derive(Serialize, Deserialize)]
446pub struct SetToolOffsetsData {
447    pub tooloffset: [f64; 6],
448    pub id: u8,
449    pub name: String,
450}
451
452// set tool id
453pub type SetToolIdRequest = Request<{ Command::SetToolId }, SetToolIdData>;
454pub type SetToolIdResponse = Response<{ Command::SetToolId }, SetToolIdState>;
455pub type SetToolIdState = DefaultState;
456#[derive(Serialize, Deserialize)]
457pub struct SetToolIdData {
458    pub tool_id: u8,
459}
460
461// pub set user offsets
462pub type SetUserOffsetsRequest = Request<{ Command::SetUserOffsets }, SetUserOffsetsData>;
463pub type SetUserOffsetsResponse = Response<{ Command::SetUserOffsets }, SetUserOffsetsState>;
464pub type SetUserOffsetsState = DefaultState;
465#[derive(Serialize, Deserialize)]
466pub struct SetUserOffsetsData {
467    pub useroffset: [f64; 6], //文档中的变量名有拼写错误
468    pub id: u8,
469    pub name: String,
470}
471
472// set user id
473pub type SetUserIdRequest = Request<{ Command::SetUserId }, SetUserIdData>;
474pub type SetUserIdResponse = Response<{ Command::SetUserId }, SetUserIdState>;
475pub type SetUserIdState = DefaultState;
476#[derive(Serialize, Deserialize)]
477pub struct SetUserIdData {
478    pub user_frame_id: u8, //文档中的变量名说明有错误
479}
480
481// get extio status
482pub type GetExtioStatusRequest = Request<{ Command::GetExtioStatus }, ()>;
483pub type GetExtioStatusResponse = Response<{ Command::GetExtioStatus }, GetExtioStatusState>;
484#[derive(Serialize, Deserialize)]
485pub struct GetExtioStatusState {
486    #[serde(rename = "errorCode")]
487    pub error_code: String,
488    #[serde(rename = "errorMsg")]
489    pub error_msg: String,
490    pub extio_status: ExtioStatus,
491}
492#[derive(Serialize, Deserialize)]
493pub struct ExtioStatus {
494    pub version: u8,
495    pub setups: Vec<Value>,
496}
497// struct ExtioSetup {
498//     setup_id: u8,
499//     mobus_io_name: String,
500//     address: SocketAddrV4,
501//     channel_counts: ChannelCounts,
502//     pinmap: HashMap<String, u8>,
503// }
504// struct ChannelCounts {
505//     ai: (u8, u8),
506//     do_: (u8, u8),
507//     ao: (u8, u8),
508//     di: (u8, u8),
509// }
510// struct ExtioCurrentState {
511//     state: u8,
512//     di: (u8, u8, u8, u8, u8, u8, u8, u8),
513// }
514
515// get funcdi status
516pub type GetFuncdiStatusRequest = Request<{ Command::GetFuncdiStatus }, ()>;
517pub type GetFuncdiStatusResponse = Response<{ Command::GetFuncdiStatus }, GetFuncdiStatusState>;
518#[derive(Serialize, Deserialize)]
519pub struct GetFuncdiStatusState {
520    #[serde(rename = "errorCode")]
521    pub error_code: String,
522    #[serde(rename = "errorMsg")]
523    pub error_msg: String,
524    pub funcdi_status: [[i8; 2]; 12],
525}
526
527// pub drag status
528pub type DragStatusRequest = Request<{ Command::DragStatus }, ()>;
529pub type DragStatusResponse = Response<{ Command::DragStatus }, DragStatusState>;
530#[derive(Serialize, Deserialize)]
531pub struct DragStatusState {
532    #[serde(rename = "errorCode")]
533    pub error_code: String,
534    #[serde(rename = "errorMsg")]
535    pub error_msg: String,
536    pub drag_status: bool,
537}
538
539// query user defined variable
540pub type QueryUserDefinedVariableRequest = Request<{ Command::QueryUserDefinedVariable }, ()>;
541pub type QueryUserDefinedVariableResponse =
542    Response<{ Command::QueryUserDefinedVariable }, QueryUserDefinedVariableState>;
543#[derive(Serialize, Deserialize)]
544pub struct QueryUserDefinedVariableState {
545    #[serde(rename = "errorCode")]
546    pub error_code: String,
547    #[serde(rename = "errorMsg")]
548    pub error_msg: String,
549    pub var_list: Vec<Value>,
550}
551
552// modify user defined variable
553pub type ModifyUserDefinedVariableRequest =
554    Request<{ Command::ModifyUserDefinedVariable }, ModifyUserDefinedVariableData>;
555pub type ModifyUserDefinedVariableResponse =
556    Response<{ Command::ModifyUserDefinedVariable }, ModifyUserDefinedVariableState>;
557pub type ModifyUserDefinedVariableState = DefaultState;
558#[derive(Serialize, Deserialize)]
559pub struct ModifyUserDefinedVariableData {
560    pub id_new: u32,
561    pub alias_new: String,
562    pub value_new: Value,
563}
564
565// protective stop status
566pub type ProtectiveStopStatusRequest = Request<{ Command::ProtectiveStopStatus }, ()>;
567pub type ProtectiveStopStatusResponse =
568    Response<{ Command::ProtectiveStopStatus }, ProtectiveStopStatusState>;
569#[derive(Serialize, Deserialize)]
570pub struct ProtectiveStopStatusState {
571    #[serde(rename = "errorCode")]
572    pub error_code: String,
573    #[serde(rename = "errorMsg")]
574    pub error_msg: String,
575    pub protective_stop: u8,
576}
577
578// jog
579pub type JogRequest = Request<{ Command::Jog }, JogData>;
580pub type JogResponse = Response<{ Command::Jog }, JogState>;
581pub type JogState = DefaultState;
582#[derive(Serialize, Deserialize)]
583pub enum JogData {
584    Mode0 {
585        coord_map: u8,
586        jnum: u8,
587    },
588    Mode1 {
589        coord_map: u8,
590        jnum: u8,
591        jogvel: f64,
592    },
593    Mode2 {
594        coord_map: u8,
595        jnum: u8,
596        jogvel: f64,
597        poscmd: f64,
598    },
599}
600
601impl JogData {
602    pub fn jog_mode(&self) -> u8 {
603        match self {
604            JogData::Mode0 { .. } => 0,
605            JogData::Mode1 { .. } => 1,
606            JogData::Mode2 { .. } => 2,
607        }
608    }
609}
610
611// move l
612pub type MoveLRequest = Request<{ Command::MoveL }, MoveLData>;
613pub type MoveLResponse = Response<{ Command::MoveL }, MoveLState>;
614pub type MoveLState = DefaultState;
615#[derive(Serialize, Deserialize)]
616pub struct MoveLData {
617    #[serde(rename = "cartPosition")]
618    pub cart_position: [f64; 6],
619    pub speed: f64,
620    pub accel: f64,
621    #[serde(rename = "relFlag")]
622    pub relflag: u8,
623}
624
625// wait complete DEPRECATED
626pub type WaitCompleteRequest = Request<{ Command::WaitComplete }, ()>;
627pub type WaitCompleteResponse = Response<{ Command::WaitComplete }, WaitCompleteState>;
628pub type WaitCompleteState = DefaultState;
629
630// set payload
631pub type SetPayloadRequest = Request<{ Command::SetPayload }, SetPayloadData>;
632pub type SetPayloadResponse = Response<{ Command::SetPayload }, SetPayloadState>;
633pub type SetPayloadState = DefaultState;
634#[derive(Serialize, Deserialize)]
635pub struct SetPayloadData {
636    pub mass: f64,
637    pub centroid: [f64; 3],
638}
639
640// get payload
641pub type GetPayloadRequest = Request<{ Command::GetPayload }, ()>;
642pub type GetPayloadResponse = Response<{ Command::GetPayload }, GetPayloadState>;
643#[derive(Serialize, Deserialize)]
644pub struct GetPayloadState {
645    #[serde(rename = "errorCode")]
646    pub error_code: String,
647    #[serde(rename = "errorMsg")]
648    pub error_msg: String,
649    pub mass: f64,
650    pub centroid: [f64; 3],
651}
652
653// set clsn sensitivity
654pub type SetClsnSensitivityRequest =
655    Request<{ Command::SetClsnSensitivity }, SetClsnSensitivityData>;
656pub type SetClsnSensitivityResponse =
657    Response<{ Command::SetClsnSensitivity }, SetClsnSensitivityState>;
658pub type SetClsnSensitivityState = DefaultState;
659#[derive(Serialize, Deserialize)]
660pub struct SetClsnSensitivityData {
661    #[serde(rename = "sensitivityVal")]
662    pub sensitivity_level: u8, // 更改了文档中的变量名以与下一命令一致
663}
664
665// get clsn sensitivity
666pub type GetClsnSensitivityRequest = Request<{ Command::GetClsnSensitivity }, ()>;
667pub type GetClsnSensitivityResponse =
668    Response<{ Command::GetClsnSensitivity }, GetClsnSensitivityState>;
669#[derive(Serialize, Deserialize)]
670pub struct GetClsnSensitivityState {
671    #[serde(rename = "errorCode")]
672    pub error_code: String,
673    #[serde(rename = "errorMsg")]
674    pub error_msg: String,
675    #[serde(rename = "sensitivityLevel")]
676    pub sensitivity_level: u8,
677}
678
679// kine forward
680pub type KineForwardRequest = Request<{ Command::KineForward }, ()>;
681pub type KineForwardResponse = Response<{ Command::KineForward }, KineForwardState>;
682#[derive(Serialize, Deserialize)]
683pub struct KineForwardState {
684    #[serde(rename = "errorCode")]
685    pub error_code: String,
686    #[serde(rename = "errorMsg")]
687    pub error_msg: String,
688    #[serde(rename = "jointPosition")]
689    pub joint_angles: [f64; 6],
690}
691#[derive(Serialize, Deserialize)]
692pub struct KineForwardData {
693    #[serde(rename = "cartPosition")]
694    pub cart_position: [f64; 6],
695}
696
697// kine inverse
698pub type KineInverseRequest = Request<{ Command::KineInverse }, KineInverseData>;
699pub type KineInverseResponse = Response<{ Command::KineInverse }, KineInverseState>;
700#[derive(Serialize, Deserialize)]
701pub struct KineInverseState {
702    #[serde(rename = "errorCode")]
703    pub error_code: String,
704    #[serde(rename = "errorMsg")]
705    pub error_msg: String,
706    #[serde(rename = "cartPosition")]
707    pub cart_position: [f64; 6],
708}
709#[derive(Serialize, Deserialize)]
710pub struct KineInverseData {
711    #[serde(rename = "jointPosition")]
712    pub joint_angles: [f64; 6],
713}
714
715// clear error
716pub type ClearErrorRequest = Request<{ Command::ClearError }, ()>;
717pub type ClearErrorResponse = Response<{ Command::ClearError }, ClearErrorState>;
718pub type ClearErrorState = DefaultState;
719
720// get joint pos
721pub type GetJointPosRequest = Request<{ Command::GetJointPos }, ()>;
722pub type GetJointPosResponse = Response<{ Command::GetJointPos }, GetJointPosState>;
723#[derive(Serialize, Deserialize)]
724pub struct GetJointPosState {
725    #[serde(rename = "errorCode")]
726    pub error_code: String,
727    #[serde(rename = "errorMsg")]
728    pub error_msg: String,
729    pub joint_pos: [f64; 6],
730}
731
732// get tcp pos
733pub type GetTcpPosRequest = Request<{ Command::GetTcpPos }, ()>;
734pub type GetTcpPosResponse = Response<{ Command::GetTcpPos }, GetTcpPosState>;
735#[derive(Serialize, Deserialize)]
736pub struct GetTcpPosState {
737    #[serde(rename = "errorCode")]
738    pub error_code: String,
739    #[serde(rename = "errorMsg")]
740    pub error_msg: String,
741    pub tcp_pos: [f64; 6],
742}
743
744impl From<DefaultState> for RobotResult<()> {
745    fn from(state: DefaultState) -> Self {
746        if state.error_code == "0" {
747            Ok(())
748        } else {
749            Err(RobotException::CommandException(format!(
750                "[{}: {}]",
751                state.error_code, state.error_msg
752            )))
753        }
754    }
755}
756
757impl<const C: Command, D> From<D> for Request<C, D> {
758    fn from(data: D) -> Self {
759        Self { data }
760    }
761}
762
763impl<const C: Command, S> From<S> for Response<C, S> {
764    fn from(state: S) -> Self {
765        Self { state }
766    }
767}
768
769impl<const C: Command, S> Response<C, S> {
770    pub fn into_state(self) -> S {
771        self.state
772    }
773}
774
775impl<const C: Command, D> CommandSerde for Request<C, D>
776where
777    D: Serialize + DeserializeOwned,
778{
779    fn serialize(&self) -> String {
780        let mut value = serde_json::to_value(&self.data).unwrap();
781        let command = serde_json::to_value(&C).unwrap();
782        match &mut value {
783            Value::Object(obj) => {
784                obj.insert("cmdName".to_string(), command);
785            }
786            Value::Null => {
787                let mut obj = serde_json::Map::new();
788                obj.insert("cmdName".to_string(), serde_json::to_value(C).unwrap());
789                value = Value::Object(obj);
790            }
791            _ => {}
792        }
793        value.to_string()
794    }
795    fn deserialize(data: &str) -> RobotResult<Self> {
796        let mut value: Value = serde_json::from_str(data).unwrap();
797        if let Value::Object(obj) = &mut value {
798            obj.remove("cmdName");
799        }
800        serde_json::from_value::<D>(value)
801            .map(|data| Request { data })
802            .map_err(|e| RobotException::DeserializeError(e.to_string()))
803    }
804}
805
806impl<const C: Command, S> CommandSerde for Response<C, S>
807where
808    S: Serialize + DeserializeOwned,
809{
810    fn serialize(&self) -> String {
811        let mut value = serde_json::to_value(&self.state).unwrap();
812        match &mut value {
813            Value::Object(obj) => {
814                obj.insert("cmdName".to_string(), serde_json::to_value(C).unwrap());
815            }
816            Value::Null => {
817                let mut obj = serde_json::Map::new();
818                obj.insert("cmdName".to_string(), serde_json::to_value(C).unwrap());
819                value = Value::Object(obj);
820            }
821            _ => {}
822        }
823        value.to_string()
824    }
825    fn deserialize(data: &str) -> RobotResult<Self> {
826        let mut value: Value = serde_json::from_str(data).unwrap();
827        if let Value::Object(obj) = &mut value {
828            obj.remove("cmdName");
829        }
830        serde_json::from_value::<S>(value)
831            .map(|state| Response { state })
832            .map_err(|e| RobotException::DeserializeError(e.to_string()))
833    }
834}
835
836#[cfg(test)]
837mod tests {}
libjaka_rs/types/robot_type.rs

libjaka_rs/types/
robot_type.rs
