ximu3 1.9.1

x-IMU3 API
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 crate::connection::*;
use std::fmt;
use std::net::Ipv4Addr;

#[derive(Clone, PartialEq)]
pub enum ConnectionConfig {
    UsbConnectionConfig(UsbConnectionConfig),
    SerialConnectionConfig(SerialConnectionConfig),
    TcpConnectionConfig(TcpConnectionConfig),
    UdpConnectionConfig(UdpConnectionConfig),
    BluetoothConnectionConfig(BluetoothConnectionConfig),
    FileConnectionConfig(FileConnectionConfig),
    MuxConnectionConfig(MuxConnectionConfig),
}

impl fmt::Display for ConnectionConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::UsbConnectionConfig(config) => config.fmt(formatter),
            Self::SerialConnectionConfig(config) => config.fmt(formatter),
            Self::TcpConnectionConfig(config) => config.fmt(formatter),
            Self::UdpConnectionConfig(config) => config.fmt(formatter),
            Self::BluetoothConnectionConfig(config) => config.fmt(formatter),
            Self::FileConnectionConfig(config) => config.fmt(formatter),
            Self::MuxConnectionConfig(config) => config.fmt(formatter),
        }
    }
}

#[derive(Clone, PartialEq)]
pub struct UsbConnectionConfig {
    pub port_name: String,
}

impl From<SerialConnectionConfig> for UsbConnectionConfig {
    fn from(config: SerialConnectionConfig) -> Self {
        Self {
            port_name: config.port_name,
        }
    }
}

impl fmt::Display for UsbConnectionConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "USB {}", self.port_name)
    }
}

#[derive(Clone, PartialEq)]
pub struct SerialConnectionConfig {
    pub port_name: String,
    pub baud_rate: u32,
    pub rts_cts_enabled: bool,
}

impl fmt::Display for SerialConnectionConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        let enabled_disabled = match self.rts_cts_enabled {
            true => "Enabled",
            false => "Disabled",
        };
        write!(formatter, "Serial {}, {}, RTS/CTS {}", self.port_name, self.baud_rate, enabled_disabled)
    }
}

#[derive(Clone, PartialEq)]
pub struct TcpConnectionConfig {
    pub ip_address: Ipv4Addr,
    pub port: u16,
}

impl fmt::Display for TcpConnectionConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "TCP {}:{}", self.ip_address, self.port)
    }
}

#[derive(Clone, PartialEq)]
pub struct UdpConnectionConfig {
    pub ip_address: Ipv4Addr,
    pub send_port: u16,
    pub receive_port: u16,
}

impl fmt::Display for UdpConnectionConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "UDP {}:{}, {}", self.ip_address, self.send_port, self.receive_port)
    }
}

#[derive(Clone, PartialEq)]
pub struct BluetoothConnectionConfig {
    pub port_name: String,
}

impl From<SerialConnectionConfig> for BluetoothConnectionConfig {
    fn from(config: SerialConnectionConfig) -> Self {
        Self {
            port_name: config.port_name,
        }
    }
}

impl fmt::Display for BluetoothConnectionConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "Bluetooth {}", self.port_name)
    }
}

#[derive(Clone, PartialEq)]
pub struct FileConnectionConfig {
    pub file_path: String,
}

impl fmt::Display for FileConnectionConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "File {}", self.file_path)
    }
}

#[derive(Clone)]
pub struct MuxConnectionConfig {
    pub channel: u8,
    pub(crate) connection: InternalConnection,
}

impl MuxConnectionConfig {
    pub fn new(channel: u8, connection: &Connection) -> MuxConnectionConfig {
        MuxConnectionConfig {
            channel,
            connection: connection.internal.clone(),
        }
    }
}

impl PartialEq for MuxConnectionConfig {
    #[rustfmt::skip]
    fn eq(&self, other: &Self) -> bool {
        let self_config = self.connection.lock().unwrap().get_config();
        let other_config = other.connection.lock().unwrap().get_config();
        self.channel == other.channel && self_config == other_config
    }
}

impl fmt::Display for MuxConnectionConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "Mux 0x{:02X}, {}", self.channel, self.connection.lock().unwrap().get_config().to_string())
    }
}