webots 0.8.0

Webots bindings for Rust
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

use webots_bindings::{
    wb_device_get_node_type, wb_motor_disable_force_feedback, wb_motor_disable_torque_feedback,
    wb_motor_enable_force_feedback, wb_motor_enable_torque_feedback, wb_motor_get_acceleration,
    wb_motor_get_available_force, wb_motor_get_available_torque, wb_motor_get_brake,
    wb_motor_get_force_feedback, wb_motor_get_force_feedback_sampling_period,
    wb_motor_get_max_force, wb_motor_get_max_position, wb_motor_get_max_torque,
    wb_motor_get_max_velocity, wb_motor_get_min_position, wb_motor_get_multiplier,
    wb_motor_get_position_sensor, wb_motor_get_target_position, wb_motor_get_torque_feedback,
    wb_motor_get_torque_feedback_sampling_period, wb_motor_get_type, wb_motor_get_velocity,
    wb_motor_set_acceleration, wb_motor_set_available_force, wb_motor_set_available_torque,
    wb_motor_set_control_pid, wb_motor_set_force, wb_motor_set_position, wb_motor_set_torque,
    wb_motor_set_velocity, WbDeviceTag, WbNodeType_WB_NODE_LINEAR_MOTOR,
    WbNodeType_WB_NODE_ROTATIONAL_MOTOR,
};

use crate::{Brake, JointType, PositionSensor};

pub struct Motor(WbDeviceTag);

impl Motor {
    pub(crate) fn new(device: WbDeviceTag) -> Self {
        assert!({
            let node_type = unsafe { wb_device_get_node_type(device) };
            node_type == WbNodeType_WB_NODE_LINEAR_MOTOR
                || node_type == WbNodeType_WB_NODE_ROTATIONAL_MOTOR
        });
        Self(device)
    }

    pub fn set_position(&self, position: f64) {
        unsafe { wb_motor_set_position(self.0, position) }
    }

    pub fn set_acceleration(&self, acceleration: f64) {
        unsafe { wb_motor_set_acceleration(self.0, acceleration) }
    }

    pub fn set_velocity(&self, velocity: f64) {
        unsafe { wb_motor_set_velocity(self.0, velocity) }
    }

    pub fn set_force(&self, force: f64) {
        unsafe { wb_motor_set_force(self.0, force) }
    }

    pub fn set_torque(&self, torque: f64) {
        unsafe { wb_motor_set_torque(self.0, torque) }
    }

    pub fn set_available_force(&self, available_force: f64) {
        unsafe { wb_motor_set_available_force(self.0, available_force) }
    }

    pub fn set_available_torque(&self, available_torque: f64) {
        unsafe { wb_motor_set_available_torque(self.0, available_torque) }
    }

    pub fn set_control_pid(&self, p: f64, i: f64, d: f64) {
        unsafe { wb_motor_set_control_pid(self.0, p, i, d) }
    }

    pub fn enable_force_feedback(&self, sampling_period: i32) {
        unsafe { wb_motor_enable_force_feedback(self.0, sampling_period) }
    }

    pub fn disable_force_feedback(&self) {
        unsafe { wb_motor_disable_force_feedback(self.0) }
    }

    pub fn get_force_feedback_sampling_period(&self) -> i32 {
        unsafe { wb_motor_get_force_feedback_sampling_period(self.0) }
    }

    pub fn get_force_feedback(&self) -> f64 {
        unsafe { wb_motor_get_force_feedback(self.0) }
    }

    pub fn enable_torque_feedback(&self, sampling_period: i32) {
        unsafe { wb_motor_enable_torque_feedback(self.0, sampling_period) }
    }

    pub fn disable_torque_feedback(&self) {
        unsafe { wb_motor_disable_torque_feedback(self.0) }
    }

    pub fn get_torque_feedback_sampling_period(&self) -> i32 {
        unsafe { wb_motor_get_torque_feedback_sampling_period(self.0) }
    }

    pub fn get_torque_feedback(&self) -> f64 {
        unsafe { wb_motor_get_torque_feedback(self.0) }
    }

    pub fn get_type(&self) -> JointType {
        unsafe { wb_motor_get_type(self.0).into() }
    }

    pub fn get_target_position(&self) -> f64 {
        unsafe { wb_motor_get_target_position(self.0) }
    }

    pub fn get_min_position(&self) -> f64 {
        unsafe { wb_motor_get_min_position(self.0) }
    }

    pub fn get_max_position(&self) -> f64 {
        unsafe { wb_motor_get_max_position(self.0) }
    }

    pub fn get_velocity(&self) -> f64 {
        unsafe { wb_motor_get_velocity(self.0) }
    }

    pub fn get_max_velocity(&self) -> f64 {
        unsafe { wb_motor_get_max_velocity(self.0) }
    }

    pub fn get_acceleration(&self) -> f64 {
        unsafe { wb_motor_get_acceleration(self.0) }
    }

    pub fn get_available_force(&self) -> f64 {
        unsafe { wb_motor_get_available_force(self.0) }
    }

    pub fn get_max_force(&self) -> f64 {
        unsafe { wb_motor_get_max_force(self.0) }
    }

    pub fn get_available_torque(&self) -> f64 {
        unsafe { wb_motor_get_available_torque(self.0) }
    }

    pub fn get_max_torque(&self) -> f64 {
        unsafe { wb_motor_get_max_torque(self.0) }
    }

    pub fn get_multiplier(&self) -> f64 {
        unsafe { wb_motor_get_multiplier(self.0) }
    }

    pub fn get_brake(&self) -> Brake {
        Brake::new(unsafe { wb_motor_get_brake(self.0) })
    }

    pub fn get_position_sensor(&self) -> PositionSensor {
        PositionSensor::new(unsafe { wb_motor_get_position_sensor(self.0) })
    }
}