kos 0.7.10

The K-Scale Operating System
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

use crate::grpc_interface::kos::actuator::{
    ActuatorCommand as ProtoActuatorCommand, ActuatorStateResponse,
};
use crate::grpc_interface::kos::imu::{EulerAnglesResponse, ImuValuesResponse, QuaternionResponse};
use serde::Serialize;

#[derive(Serialize)]
pub struct ImuValues {
    pub accel_x: f64,
    pub accel_y: f64,
    pub accel_z: f64,
    pub gyro_x: f64,
    pub gyro_y: f64,
    pub gyro_z: f64,
    pub mag_x: Option<f64>,
    pub mag_y: Option<f64>,
    pub mag_z: Option<f64>,
    pub error: Option<String>,
}

#[derive(Serialize)]
pub struct EulerAngles {
    pub roll: f64,
    pub pitch: f64,
    pub yaw: f64,
}

#[derive(Serialize)]
pub struct Quaternion {
    pub x: f64,
    pub y: f64,
    pub z: f64,
    pub w: f64,
}

#[derive(Serialize)]
pub struct ActuatorState {
    pub actuator_id: u32,
    pub online: bool,
    pub position: Option<f64>,
    pub velocity: Option<f64>,
    pub torque: Option<f64>,
    pub temperature: Option<f64>,
    pub voltage: Option<f32>,
    pub current: Option<f32>,
    pub torque_enabled: Option<bool>,
    pub min_position: Option<f64>,
    pub max_position: Option<f64>,
    pub kp: Option<f64>,
    pub kd: Option<f64>,
    pub ki: Option<f64>,
    pub max_torque: Option<f64>,
}

#[derive(Clone, Debug, Serialize)]
pub struct ActuatorCommand {
    pub actuator_id: u32,
    pub position: Option<f64>,
    pub velocity: Option<f64>,
    pub torque: Option<f64>,
}

impl From<&EulerAnglesResponse> for EulerAngles {
    fn from(resp: &EulerAnglesResponse) -> Self {
        Self {
            roll: resp.roll,
            pitch: resp.pitch,
            yaw: resp.yaw,
        }
    }
}

impl From<&ImuValuesResponse> for ImuValues {
    fn from(resp: &ImuValuesResponse) -> Self {
        Self {
            accel_x: resp.accel_x,
            accel_y: resp.accel_y,
            accel_z: resp.accel_z,
            gyro_x: resp.gyro_x,
            gyro_y: resp.gyro_y,
            gyro_z: resp.gyro_z,
            mag_x: resp.mag_x,
            mag_y: resp.mag_y,
            mag_z: resp.mag_z,
            error: resp.error.as_ref().map(|e| e.message.clone()),
        }
    }
}

impl From<&QuaternionResponse> for Quaternion {
    fn from(resp: &QuaternionResponse) -> Self {
        Self {
            x: resp.x,
            y: resp.y,
            z: resp.z,
            w: resp.w,
        }
    }
}

impl From<&ActuatorStateResponse> for ActuatorState {
    fn from(resp: &ActuatorStateResponse) -> Self {
        Self {
            actuator_id: resp.actuator_id,
            online: resp.online,
            position: resp.position,
            velocity: resp.velocity,
            torque: resp.torque,
            temperature: resp.temperature,
            voltage: resp.voltage,
            current: resp.current,
            torque_enabled: resp.torque_enabled,
            min_position: resp.min_position,
            max_position: resp.max_position,
            kp: resp.kp,
            kd: resp.kd,
            ki: resp.ki,
            max_torque: resp.max_torque,
        }
    }
}

impl From<&ProtoActuatorCommand> for ActuatorCommand {
    fn from(cmd: &ProtoActuatorCommand) -> Self {
        Self {
            actuator_id: cmd.actuator_id,
            position: cmd.position,
            velocity: cmd.velocity,
            torque: cmd.torque,
        }
    }
}