rust-powered-lego 0.2.0

This crate aims to control a regular Powered Up motor using a Technic Hub.
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

//! This crate aims to control Lego hub and its various peripherals with the Rust programming language.
//! 
//! ConnectionManager is the object to start with.
//! Ask the CM for a Hub, with its name or address.
//! Then, kindly ask the Hub to get a port of specific type (sorry, currently only the motor).
//! 
//! This crate is far from completion - more types and functionality will be added in the future.
//! 
//! Below are the main traits. More located at lego/mod.rs
//! 

use std::pin::Pin;

use anyhow::Result;
use async_trait::async_trait;

use btleplug::api::ValueNotification;
use hub::{
    PortInfoValueReply, PortInfoModeReply, PortInfoCombinationsReply
};
use lego::{
    message_parameters::{
        PortModeInformationType,
        PortOutputCommandParams, 
        StartupAndCompletionInfo,
    },
    consts:: {
        EndState, 
        Profile,
    }
};
use ports::{
    Motor,
};
use tokio_stream::Stream;

pub mod connection_manager;
pub mod hub;
pub mod lego;
pub mod ports;


/* Hubs type */

#[async_trait]
pub trait HubType {
    
    async fn shut_down_hub(&self) -> Result<()>;

    async fn get_notification(&self) -> Result<Pin<Box<dyn Stream<Item = ValueNotification> + Send>>>;

    async fn get_port_info_value(
        &self, 
        port_id: u8,
    ) -> Result<PortInfoValueReply>;

    async fn get_port_info_raw_value(
        &self,
        port_id: u8
    ) -> Result<i32>;

    async fn get_port_info_mode(
        &self, 
        port_id: u8,
    ) -> Result<PortInfoModeReply>;

    async fn get_port_info_combinations(
        &self, 
        port_id: u8,
    ) -> Result<PortInfoCombinationsReply>;

    async fn get_mode_information(
        &self, 
        port_id: u8, 
        mode_id: u8, 
        info_type: PortModeInformationType
    ) -> Result<Vec<u8>>;

    async fn setup_port_input_format(
        &self,
        port_id:                u8,
        mode_id:                u8,
        delta:                  u32,
        enable_notifications:   bool,
    ) -> Result<()>;

    async fn send_output_command(&self, subcommand: PortOutputCommandParams)-> Result<Vec<u8>>;

    async fn get_motor(&self, port_id: u8) -> Result<Motor>;
}



/* Ports type */

#[async_trait]
pub trait MotorType {
    
    async fn set_acceleration_time(
        &self, 
        time: i16,
        start_up_info: StartupAndCompletionInfo,
    ) -> Result<Vec<u8>>;

    async fn set_deceleration_time(
        &self,
        time: i16,
        start_up_info: StartupAndCompletionInfo,
    ) -> Result<Vec<u8>>;

    async fn start_power(
        &self, 
        power: i8, 
        start_up_info: StartupAndCompletionInfo
    ) -> Result<Vec<u8>>;

    async fn start_speed(
        &self, 
        speed: i8, 
        max_power: i8, 
        use_profile: Profile, 
        start_up_info: StartupAndCompletionInfo,
    ) -> Result<Vec<u8>>;

    async fn stop_motor(
        &self,
        end_state: EndState,
        use_profile: Profile, 
        start_up_info: StartupAndCompletionInfo
    ) -> Result<Vec<u8>>;

    async fn set_abs_position(
        &self, 
        position: i32, 
        start_up_info: StartupAndCompletionInfo
    ) -> Result<Vec<u8>>;

    async fn go_to_abs_position(
        &self, 
        abs_pos: i32,
        speed: i8,
        max_power: i8,
        end_state: EndState,
        use_profile: Profile,
        start_up_info: StartupAndCompletionInfo,
    ) -> Result<Vec<u8>>;

    async fn start_speed_for_deg (
        &self, 
        degrees: i32,
        speed: i8,
        max_power: i8,
        end_state: EndState,
        use_profile: Profile,
        start_up_info: StartupAndCompletionInfo,
    ) -> Result<Vec<u8>>;
}