ebyte_e32/
lib.rs

1#![cfg_attr(not(any(test, feature = "value_enum")), no_std)]
2#![doc = include_str!("../README.md")]
3
4use core::marker::PhantomData;
5use embedded_hal::{
6    blocking::delay::DelayMs,
7    digital::v2::{InputPin, OutputPin},
8    serial::{Read, Write},
9};
10pub use error::Error;
11use mode::{Mode, Normal, Program};
12pub use model_data::ModelData;
13use nb::block;
14pub use parameters::Parameters;
15use parameters::Persistence;
16
17mod error;
18pub mod mode;
19mod model_data;
20pub mod parameters;
21
22#[cfg(test)]
23mod test;
24
25pub struct Ebyte<S, Aux, M0, M1, D, M>
26where
27    S: Read<u8> + Write<u8>,
28    Aux: InputPin,
29    M0: OutputPin,
30    M1: OutputPin,
31    D: DelayMs<u32>,
32{
33    serial: S,
34    aux: Aux,
35    m0: M0,
36    m1: M1,
37    delay: D,
38    mode: PhantomData<M>,
39}
40
41impl<S, Aux, M0, M1, D> Ebyte<S, Aux, M0, M1, D, Normal>
42where
43    S: Read<u8> + Write<u8>,
44    Aux: InputPin,
45    M0: OutputPin,
46    M1: OutputPin,
47    D: DelayMs<u32>,
48{
49    pub fn new(
50        serial: S,
51        mut aux: Aux,
52        mut m0: M0,
53        mut m1: M1,
54        mut delay: D,
55    ) -> Result<Self, Error> {
56        Normal::set_pins(&mut aux, &mut m0, &mut m1, &mut delay);
57
58        let ebyte = Self {
59            serial,
60            aux,
61            m0,
62            m1,
63            delay,
64            mode: PhantomData::<Normal>,
65        };
66
67        Ok(ebyte)
68    }
69
70    /// Write entire buffer to serial port
71    pub fn write_buffer(&mut self, buffer: &[u8]) -> Result<(), crate::Error> {
72        for ch in buffer {
73            block!(self.serial.write(*ch)).map_err(|_| Error::SerialWrite)?;
74        }
75        Ok(())
76    }
77
78    /// Read entire buffer from serial port
79    pub fn read_buffer(&mut self, buffer: &mut [u8]) -> Result<(), Error> {
80        for byte in buffer {
81            *byte = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
82        }
83        Ok(())
84    }
85
86    pub fn model_data(&mut self) -> Result<ModelData, Error> {
87        Program::set_pins(&mut self.aux, &mut self.m0, &mut self.m1, &mut self.delay);
88        let result = self.read_model_data();
89        Normal::set_pins(&mut self.aux, &mut self.m0, &mut self.m1, &mut self.delay);
90        result
91    }
92
93    fn read_model_data(&mut self) -> Result<ModelData, Error> {
94        block!(self.serial.write(0xC3)).map_err(|_| Error::SerialWrite)?;
95        block!(self.serial.write(0xC3)).map_err(|_| Error::SerialWrite)?;
96        block!(self.serial.write(0xC3)).map_err(|_| Error::SerialWrite)?;
97
98        let save = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
99        let model = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
100        let version = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
101        let features = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
102
103        if save == 0xC3 {
104            Ok(ModelData {
105                model,
106                version,
107                features,
108            })
109        } else {
110            Err(Error::ReadModelData)
111        }
112    }
113
114    pub fn parameters(&mut self) -> Result<Parameters, Error> {
115        Program::set_pins(&mut self.aux, &mut self.m0, &mut self.m1, &mut self.delay);
116        let result = self.read_parameters();
117        Normal::set_pins(&mut self.aux, &mut self.m0, &mut self.m1, &mut self.delay);
118        result
119    }
120
121    fn read_parameters(&mut self) -> Result<Parameters, Error> {
122        block!(self.serial.write(0xC1)).map_err(|_| Error::SerialWrite)?;
123        block!(self.serial.write(0xC1)).map_err(|_| Error::SerialWrite)?;
124        block!(self.serial.write(0xC1)).map_err(|_| Error::SerialWrite)?;
125        let save = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
126        let mut bytes = [0u8; 5];
127        for byte in &mut bytes {
128            *byte = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
129        }
130        if save != 0xC0 {
131            return Err(Error::ReadParameters);
132        }
133        let params = Parameters::from_bytes(&bytes).map_err(|e| Error::Parameter { source: e })?;
134        Ok(params)
135    }
136
137    pub fn set_parameters(&mut self, params: &Parameters, mode: Persistence) -> Result<(), Error> {
138        Program::set_pins(&mut self.aux, &mut self.m0, &mut self.m1, &mut self.delay);
139        let result = self.write_parameters(params, mode);
140        Normal::set_pins(&mut self.aux, &mut self.m0, &mut self.m1, &mut self.delay);
141        result
142    }
143
144    fn write_parameters(&mut self, params: &Parameters, mode: Persistence) -> Result<(), Error> {
145        let persistence = u8::from(mode);
146        block!(self.serial.write(persistence)).map_err(|_| Error::SerialWrite)?;
147
148        let bytes: [u8; 5] = params.to_bytes();
149        block!(self.serial.write(bytes[0])).map_err(|_| Error::SerialWrite)?;
150        block!(self.serial.write(bytes[1])).map_err(|_| Error::SerialWrite)?;
151        block!(self.serial.write(bytes[2])).map_err(|_| Error::SerialWrite)?;
152        block!(self.serial.write(bytes[3])).map_err(|_| Error::SerialWrite)?;
153        block!(self.serial.write(bytes[4])).map_err(|_| Error::SerialWrite)?;
154
155        let response_prefix = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
156        let mut response = [0u8; 5];
157        for byte in &mut response {
158            *byte = block!(self.serial.read()).map_err(|_| Error::SerialRead)?;
159        }
160        if response_prefix != 0xC0 {
161            return Err(Error::SetParameters);
162        }
163
164        if response != bytes {
165            return Err(Error::SetParameters);
166        }
167
168        self.delay.delay_ms(40);
169
170        Ok(())
171    }
172
173    pub fn reset(&mut self) -> Result<(), Error> {
174        Program::set_pins(&mut self.aux, &mut self.m0, &mut self.m1, &mut self.delay);
175        let result = self.perform_reset();
176        Normal::set_pins(&mut self.aux, &mut self.m0, &mut self.m1, &mut self.delay);
177        result
178    }
179
180    fn perform_reset(&mut self) -> Result<(), Error> {
181        block!(self.serial.write(0xC4)).map_err(|_| Error::SerialWrite)?;
182        block!(self.serial.write(0xC4)).map_err(|_| Error::SerialWrite)?;
183        block!(self.serial.write(0xC4)).map_err(|_| Error::SerialWrite)?;
184
185        Ok(())
186    }
187
188    pub fn release(self) -> (S, Aux, M0, M1, D) {
189        (self.serial, self.aux, self.m0, self.m1, self.delay)
190    }
191}
192
193impl<S, Aux, M0, M1, D> Read<u8> for Ebyte<S, Aux, M0, M1, D, Normal>
194where
195    S: Read<u8> + Write<u8>,
196    Aux: InputPin,
197    M0: OutputPin,
198    M1: OutputPin,
199    D: DelayMs<u32>,
200{
201    type Error = <S as Read<u8>>::Error;
202
203    fn read(&mut self) -> nb::Result<u8, Self::Error> {
204        self.serial.read()
205    }
206}
207
208/// Implement Write for Ebyte in normal mode.
209/// This just defers to the underlying serial implementation.
210impl<S, Aux, M0, M1, D> Write<u8> for Ebyte<S, Aux, M0, M1, D, Normal>
211where
212    S: Read<u8> + Write<u8>,
213    Aux: InputPin,
214    M0: OutputPin,
215    M1: OutputPin,
216    D: DelayMs<u32>,
217{
218    type Error = <S as Write<u8>>::Error;
219
220    fn write(&mut self, word: u8) -> nb::Result<(), Self::Error> {
221        self.serial.write(word)
222    }
223
224    fn flush(&mut self) -> nb::Result<(), Self::Error> {
225        self.serial.flush()
226    }
227}
ebyte_e32/lib.rs

ebyte_e32/
lib.rs
