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
133
134
135
136
137
138
139
140
141
142
143

pub use crate::grpc_interface::google::longrunning::*;
pub use crate::grpc_interface::kos;
pub use crate::grpc_interface::kos::common::ActionResponse;
pub use crate::kos_proto::{
    actuator::*, common::ActionResult, imu::*, inference::*, led_matrix::*, policy::*,
    process_manager::*, sound::*,
};
use async_trait::async_trait;
use bytes::Bytes;
use eyre::Result;
use futures::Stream;
use std::fmt::Display;
use std::pin::Pin;
use tokio::sync::mpsc::Sender;

// Type alias for the audio stream
pub type AudioStream = Pin<Box<dyn Stream<Item = Bytes> + Send>>;

#[async_trait]
pub trait Actuator: Send + Sync {
    async fn command_actuators(&self, commands: Vec<ActuatorCommand>) -> Result<Vec<ActionResult>>;
    async fn configure_actuator(&self, config: ConfigureActuatorRequest) -> Result<ActionResponse>;
    async fn calibrate_actuator(&self, request: CalibrateActuatorRequest) -> Result<Operation>;
    async fn get_actuators_state(
        &self,
        actuator_ids: Vec<u32>,
    ) -> Result<Vec<ActuatorStateResponse>>;
    async fn get_parameters(
        &self,
        actuator_ids: Vec<u32>,
    ) -> Result<Vec<(u32, prost_types::Struct)>>;
}

#[async_trait]
pub trait IMU: Send + Sync {
    async fn get_values(&self) -> Result<ImuValuesResponse>;
    async fn get_advanced_values(&self) -> Result<ImuAdvancedValuesResponse>;
    async fn calibrate(&self) -> Result<Operation>;
    async fn zero(
        &self,
        duration: Option<std::time::Duration>,
        max_retries: Option<u32>,
        max_angular_error: Option<f32>,
        max_vel: Option<f32>,
        max_accel: Option<f32>,
    ) -> Result<ActionResponse>;
    async fn get_euler(&self) -> Result<EulerAnglesResponse>;
    async fn get_quaternion(&self) -> Result<QuaternionResponse>;
    async fn get_calibration_state(&self) -> Result<std::collections::HashMap<String, i32>>;
}

#[async_trait]
pub trait ProcessManager: Send + Sync {
    async fn start_kclip(&self, action: String) -> Result<KClipStartResponse>;
    async fn stop_kclip(&self) -> Result<KClipStopResponse>;
}

#[async_trait]
pub trait Policy: Send + Sync {
    async fn start_policy(
        &self,
        action: String,
        action_scale: f32,
        episode_length: i32,
        dry_run: bool,
    ) -> Result<StartPolicyResponse>;
    async fn stop_policy(&self) -> Result<StopPolicyResponse>;
    async fn get_state(&self) -> Result<GetStateResponse>;
}

#[async_trait]
pub trait Inference: Send + Sync {
    async fn upload_model(
        &self,
        model: Vec<u8>,
        metadata: Option<ModelMetadata>,
    ) -> Result<UploadModelResponse>;

    async fn get_models_info(&self, request: GetModelsInfoRequest)
        -> Result<GetModelsInfoResponse>;

    async fn load_models(&self, uids: Vec<String>) -> Result<LoadModelsResponse>;
    async fn unload_models(&self, uids: Vec<String>) -> Result<ActionResponse>;
    async fn forward(
        &self,
        model_uid: String,
        inputs: std::collections::HashMap<String, Tensor>,
    ) -> Result<ForwardResponse>;
}

#[async_trait]
pub trait LEDMatrix: Send + Sync {
    async fn get_matrix_info(&self) -> Result<GetMatrixInfoResponse>;
    async fn write_buffer(&self, buffer: Vec<u8>) -> Result<ActionResponse>;
    async fn write_color_buffer(
        &self,
        buffer: Vec<u8>,
        width: u32,
        height: u32,
        format: String,
        brightness: u32,
    ) -> Result<ActionResponse>;
}

#[async_trait]
pub trait Sound: Send + Sync {
    /// Get information about audio capabilities
    async fn get_audio_info(&self) -> Result<GetAudioInfoResponse, tonic::Status>;

    /// Start playing audio with the given configuration
    async fn play_audio(
        &self,
        config: AudioConfig,
        sender: Sender<Bytes>,
    ) -> Result<ActionResponse, tonic::Status>;

    /// Start recording audio with the given configuration
    async fn record_audio(
        &self,
        config: AudioConfig,
        duration_ms: u32,
    ) -> Result<AudioStream, tonic::Status>;

    /// Stop an ongoing recording session
    async fn stop_recording(&self) -> Result<ActionResponse, tonic::Status>;
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CalibrationStatus {
    Calibrating,
    Calibrated,
    Timeout,
}

impl Display for CalibrationStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CalibrationStatus::Calibrating => write!(f, "calibrating"),
            CalibrationStatus::Calibrated => write!(f, "calibrated"),
            CalibrationStatus::Timeout => write!(f, "timeout"),
        }
    }
}