libfranka-rs 0.9.0

Library to control Franka Emika robots
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

// Copyright (c) 2021 Marco Boneberger
// Licensed under the EUPL-1.2-or-later

use std::fmt::Debug;

use serde::Deserialize;
use serde::Serialize;
use serde_repr::{Deserialize_repr, Serialize_repr};

use crate::network::MessageCommand;
use std::time::Duration;

pub static VERSION: u16 = 3;
pub static COMMAND_PORT: u16 = 1338;

#[derive(Serialize_repr, Deserialize_repr, Debug, Copy, Clone)]
#[repr(u16)]
pub enum Command {
    Connect,
    Homing,
    Grasp,
    Move,
    Stop,
}

#[derive(Serialize_repr, Deserialize_repr, Debug)]
#[repr(u16)]
pub enum Status {
    Success,
    Fail,
    Unsuccessful,
    Aborted,
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct GripperStateIntern {
    pub message_id: u32,
    pub width: f64,
    pub max_width: f64,
    pub is_grasped: bool,
    pub temperature: u16,
}

impl GripperStateIntern {
    pub fn get_time(&self) -> Duration {
        Duration::from_millis(self.message_id as u64)
    }
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct CommandHeader {
    pub command: Command,
    pub command_id: u32,
    pub size: u32,
}

impl CommandHeader {
    pub fn new(command: Command, command_id: u32, size: u32) -> CommandHeader {
        CommandHeader {
            command,
            command_id,
            size,
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct ConnectRequest {
    pub version: u16,
    pub udp_port: u16,
}
#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct MoveRequest {
    width: f64,
    speed: f64,
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct GraspEpsilon {
    inner: f64,
    outer: f64,
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct GraspRequest {
    width: f64,
    epsilon: GraspEpsilon,
    speed: f64,
    force: f64,
}

impl ConnectRequest {
    pub fn new(udp_port: u16) -> Self {
        ConnectRequest {
            version: VERSION,
            udp_port,
        }
    }
}

impl MoveRequest {
    pub fn new(width: f64, speed: f64) -> Self {
        MoveRequest { width, speed }
    }
}

impl GraspRequest {
    pub fn new(width: f64, speed: f64, force: f64, epsilon_inner: f64, epsilon_outer: f64) -> Self {
        GraspRequest {
            width,
            epsilon: GraspEpsilon {
                inner: epsilon_inner,
                outer: epsilon_outer,
            },
            speed,
            force,
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct ConnectRequestWithHeader {
    pub header: CommandHeader,
    pub request: ConnectRequest,
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct MoveRequestWithHeader {
    pub header: CommandHeader,
    pub request: MoveRequest,
}

pub type HomingRequestWithHeader = CommandHeader;
pub type StopRequestWithHeader = CommandHeader;

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
#[repr(packed)]
pub struct GraspRequestWithHeader {
    pub header: CommandHeader,
    pub request: GraspRequest,
}

impl MessageCommand for CommandHeader {
    fn get_command_message_id(&self) -> u32 {
        self.command_id
    }
}

impl MessageCommand for ConnectRequestWithHeader {
    fn get_command_message_id(&self) -> u32 {
        self.header.get_command_message_id()
    }
}

impl MessageCommand for MoveRequestWithHeader {
    fn get_command_message_id(&self) -> u32 {
        self.header.get_command_message_id()
    }
}

impl MessageCommand for GraspRequestWithHeader {
    fn get_command_message_id(&self) -> u32 {
        self.header.get_command_message_id()
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ConnectResponse {
    pub header: CommandHeader,
    pub status: Status,
    pub version: u16,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct MoveResponse {
    pub header: CommandHeader,
    pub status: Status,
}

pub type GraspResponse = MoveResponse;
pub type HomingResponse = MoveResponse;
pub type StopResponse = HomingResponse;