md22 0.1.0

An MD22 motor driver which uses I2C via embedded-hal.
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

//! Platform-agnostic MD22 motor driver which uses I2C via
//! [embedded-hal].
//!
//! [embedded-hal]: https://docs.rs/embedded-hal

#![forbid(unsafe_code)]
#![cfg_attr(not(test), no_std)]


mod register;
use embedded_hal as hal;
use crate::register::Register;
use core::fmt::Debug;
use hal::blocking::i2c::{Write, WriteRead};



#[derive(Clone, Copy)]
/// Device I2C bus address switch states
pub enum I2CAddressSwitchState {
    /// Switch 1 - On, Switch 2 - On, Switch 3 - On, Switch 4 - On, 
    OnOnOnOn    = 0xB0,
    /// Switch 1 - Off, Switch 2 - On, Switch 3 - On, Switch 4 - On,
    OffOnOnOn   = 0xB2,
    /// Switch 1 - On, Switch 2 - Off, Switch 3 - On, Switch 4 - On,
    OnOffOnOn   = 0xB4,
    /// Switch 1 - Off, Switch 2 - Off, Switch 3 - On, Switch 4 - On,
    OffOffOnOn  = 0xB6,
    /// Switch 1 - On, Switch 2 - On, Switch 3 - Off, Switch 4 - On,
    OnOnOffOn   = 0xB8,
    /// Switch 1 - Off, Switch 2 - On, Switch 3 - Off, Switch 4 - On,
    OffOnOffOn  = 0xBA,
    /// Switch 1 - On, Switch 2 - Off, Switch 3 - Off, Switch 4 - On,
    OnOffOffOn  = 0xBC,
    /// Switch 1 - Off, Switch 2 - Off, Switch 3 - Off, Switch 4 - On,
    OffOffOffOn = 0xBE,
}

impl I2CAddressSwitchState {
    fn bits(self) -> u8 {
        self as u8
    }
}

#[derive(Clone, Copy)]
/// I2C operating mode
pub enum OperatingMode {
    /// (Default)  The meaning of the speed registers is literal speeds in the range of:  
    /// - 0 (full reverse)
    /// - 128 (stop)
    /// - 255 (full forward)
    Mode0,
    /// The speed registers are interpreted as signed values:  
    /// - -128 (full reverse)
    /// - 0 (stop)
    /// - 127 (full forward)
    Mode1,

}

impl OperatingMode {

    /// Get raw representation of operating mode.
    pub fn bits(self) -> u8 {
        self as u8
    }

    pub fn is_turn_mode(&self) -> bool {
        match self {
            OperatingMode::Mode0 | OperatingMode::Mode1 => false,
            _ => true,
        }
    }
}

/// MD22 Driver
pub struct Md22<I2C> {
    /// Comment above struct member
    i2c: I2C,
    mode: u8,
    address: u8,
}

impl<I2C, E> Md22<I2C>
where
    I2C: WriteRead<Error = E> + Write<Error = E>,
    E: Debug,
{
    /// Create a new MD22 driver from the given I2C peripheral and mode.  
    /// Defaults the speed, acceleration, and turn registers to 0.
    pub fn new(i2c: I2C, mode: OperatingMode, address: I2CAddressSwitchState) -> Result<Self, E> {
        let mut md22 = Md22 {
            i2c: i2c,
            mode: mode.bits(),
            address: address.bits()
        };
        md22.set_mode(mode)?;
        md22.set_acceleration(0)?;
        md22.set_speed(0)?;
        md22.set_turn(0)?;

        Ok(md22)
    }

    /// Set the operating mode.
    pub fn set_mode(&mut self, mode: OperatingMode) -> Result<(), E> {
        let bytes = [Register::Mode.addr(), mode as u8];
        self.i2c.write(self.address, &bytes)?;
        Ok(())
    }

    /// Set the motor speed register to the specified value.
    pub fn set_speed(&mut self, speed: u8) -> Result<(), E> {
        let bytes = [Register::Speed.addr(), speed];
        self.i2c.write(self.address, &bytes)?;
        Ok(())
    }

    /// Set the motor turn register to the specified value.
    pub fn set_turn(&mut self, turn: u8) -> Result<(), E> {
        let bytes = [Register::Turn.addr(), turn];
        self.i2c.write(self.address, &bytes)?;
        Ok(())
    }

    /// Set the motor acceleration register to the specified value.  
    /// The acceleration time is given by this value * 64us * n_steps.
    pub fn set_acceleration(&mut self, acceleration: u8) -> Result<(), E> {
        let bytes = [Register::Acceleration.addr(), acceleration];
        self.i2c.write(self.address, &bytes)?;
        Ok(())
    }
    
    pub fn get_software_revision(&mut self) -> Result<u8, E> {
        let bytes = [Register::SoftwareRevision.addr()];
        let mut buffer: [u8;1] = [0;1];
        self.i2c.write_read(self.address, &bytes, &mut buffer)?;
        Ok(buffer[0])
    }
}


#[cfg(test)]
mod tests {

    
    use crate::*;

    use embedded_hal_mock as hal;

    #[test]
    fn get_software_revision() {
        let address = I2CAddressSwitchState::OnOnOnOn;
        let expectation = [
            hal::i2c::Transaction::write(address.bits(), vec![Register::Mode.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Acceleration.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Speed.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Turn.addr(), 0]),
            hal::i2c::Transaction::write_read(address.bits(), vec![Register::SoftwareRevision.addr()], vec![255]),
        ];
        let i2c = hal::i2c::Mock::new(&expectation);
        let mut md22 = Md22::new(i2c, OperatingMode::Mode0, address).unwrap();
        assert_eq!(255, md22.get_software_revision().unwrap());
    }

    #[test]
    fn set_mode() {
        let address = I2CAddressSwitchState::OnOnOnOn;
        let expectation = [
            hal::i2c::Transaction::write(address.bits(), vec![Register::Mode.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Acceleration.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Speed.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Turn.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Mode.addr(), OperatingMode::Mode1.bits()]),
        ];
        let i2c = hal::i2c::Mock::new(&expectation);
        let mut md22 = Md22::new(i2c, OperatingMode::Mode0, address).unwrap();
        md22.set_mode(OperatingMode::Mode1).unwrap();
    }
    
    #[test]
    fn set_acceleration() {
        let address = I2CAddressSwitchState::OnOnOnOn;
        let expectation = [
            hal::i2c::Transaction::write(address.bits(), vec![Register::Mode.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Acceleration.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Speed.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Turn.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Acceleration.addr(), 255]),
        ];
        let i2c = hal::i2c::Mock::new(&expectation);
        let mut md22 = Md22::new(i2c, OperatingMode::Mode0, address).unwrap();
        md22.set_acceleration(255).unwrap();
    }

    #[test]
    fn set_speed() {
        let address = I2CAddressSwitchState::OnOnOnOn;
        let expectation = [
            hal::i2c::Transaction::write(address.bits(), vec![Register::Mode.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Acceleration.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Speed.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Turn.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Speed.addr(), 255]),
        ];
        let i2c = hal::i2c::Mock::new(&expectation);
        let mut md22 = Md22::new(i2c, OperatingMode::Mode0, address).unwrap();
        md22.set_speed(255).unwrap();
    }

    #[test]
    fn set_turn() {
        let address = I2CAddressSwitchState::OnOnOnOn;
        let expectation = [
            hal::i2c::Transaction::write(address.bits(), vec![Register::Mode.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Acceleration.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Speed.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Turn.addr(), 0]),
            hal::i2c::Transaction::write(address.bits(), vec![Register::Turn.addr(), 255]),
        ];
        let i2c = hal::i2c::Mock::new(&expectation);
        let mut md22 = Md22::new(i2c, OperatingMode::Mode0, address).unwrap();
        md22.set_turn(255).unwrap();
    }
}