first commit

src/lib.rs

@@ -0,0 +1,207 @@
+use core::marker::PhantomData;
+
+use arduino_hal::{
+    delay_us,
+    pac::EXINT,
+    port::{
+        mode::{Input, PullUp},
+        Pin, PinOps,
+    },
+};
+
+use avr_device::asm::delay_cycles;
+
+use static_pins::StaticPinOps;
+
+pub type PollResult = Result<(), PollError>;
+pub type ReadByteResult = Result<u8, CorruptedData>;
+pub type CorruptedData = (u8, u8);
+
+const SERIAL_DELAY: u32 = 4;
+const FIRST_HALF_SERIAL_DELAY: u32 = SERIAL_DELAY / 2;
+const SECOND_HALF_SERIAL_DELAY: u32 = SERIAL_DELAY - FIRST_HALF_SERIAL_DELAY;
+
+const READING_ADJUST: u32 = 16;
+const FIRST_ENTRY_READING: u32 = 30;
+const LSB: u8 = 0x01;
+const MSB: u8 = 0x80;
+
+pub enum PollError {
+    NotFound,
+    NotReady,
+}
+
+pub struct HalfDuplexSerial<P> {
+    _pin: PhantomData<Pin<Input<PullUp>, P>>,
+}
+
+impl<P> HalfDuplexSerial<P>
+where
+    P: PinOps + StaticPinOps,
+{
+    #[inline]
+    pub fn new(_pin: Pin<Input<PullUp>, P>, exint: &EXINT) -> Self {
+        exint.eimsk.write(|w| w.bits(1 << 1));
+        exint.eicra.write(|w| unsafe { w.bits(!(1 << 3 | 1 << 2)) });
+
+        Self {
+            _pin: PhantomData {},
+        }
+    }
+}
+
+pub trait SoftSerial<P>
+where
+    P: PinOps + StaticPinOps,
+{
+    fn poll(&self) -> PollResult;
+    fn response(&self);
+
+    fn sync_reciever(&self);
+    fn sync_transmitter(&self);
+
+    fn write_byte(&self, data: u8);
+    fn read_byte(&self) -> ReadByteResult;
+
+    #[inline]
+    fn finish_write(&self) {
+        P::into_pull_up_input();
+        while P::is_low() {}
+    }
+
+    fn write_bytes(&self, transmit_data: &[u8]) {
+        for byte in transmit_data {
+            self.write_byte(*byte);
+            self.sync_transmitter();
+        }
+    }
+
+    fn read_bytes(&self, recieve_buffer: &mut [u8]) {
+        for byte in recieve_buffer {
+            if let Ok(data) = self.read_byte() {
+                *byte = data;
+            }
+            self.sync_reciever();
+        }
+    }
+}
+
+impl<P> SoftSerial<P> for HalfDuplexSerial<P>
+where
+    P: PinOps + StaticPinOps,
+{
+    fn poll(&self) -> PollResult {
+        P::into_output();
+        delay_cycles(1);
+        P::into_pull_up_input();
+
+        delay_us(SERIAL_DELAY);
+
+        if P::is_low() {
+            return PollResult::Err(PollError::NotFound);
+        }
+
+        delay_us(SERIAL_DELAY);
+
+        if P::is_high() {
+            return PollResult::Err(PollError::NotReady);
+        }
+
+        while P::is_low() {}
+
+        PollResult::Ok(())
+    }
+
+    fn response(&self) {
+        P::into_output_high();
+
+        delay_us(FIRST_HALF_SERIAL_DELAY);
+
+        P::set_low();
+
+        delay_us(SERIAL_DELAY);
+
+        P::into_pull_up_input();
+    }
+
+    #[inline(never)]
+    fn sync_transmitter(&self) {
+        P::into_output();
+
+        delay_us(SERIAL_DELAY);
+
+        P::set_high();
+    }
+
+    #[inline(never)]
+    fn sync_reciever(&self) {
+        while P::is_high() {}
+
+        while P::is_low() {}
+    }
+
+    #[inline(never)]
+    fn write_byte(&self, data: u8) {
+        let (mut data, mut parity_bit) = (data, 0);
+
+        for _ in 0..8 {
+            if data & MSB == 0 {
+                P::set_high();
+                parity_bit ^= 0;
+            } else {
+                P::set_low();
+                parity_bit ^= 1;
+            }
+
+            delay_us(SERIAL_DELAY);
+
+            data <<= 1;
+        }
+
+        // Hamming code and CRC are very weightful and slow, so I use simple parity check
+
+        if parity_bit == 0 {
+            P::set_high();
+        } else {
+            P::set_low();
+        }
+
+        delay_us(SERIAL_DELAY);
+    }
+
+    #[inline(never)]
+    fn read_byte(&self) -> ReadByteResult {
+        let (mut data, mut reciever_parity_bit) = (0, 0);
+
+        delay_cycles(FIRST_ENTRY_READING);
+        for _ in 0..8 {
+            delay_us(FIRST_HALF_SERIAL_DELAY);
+
+            if P::is_low() {
+                data |= 1;
+                reciever_parity_bit ^= 1;
+            } else {
+                data |= 0;
+                reciever_parity_bit ^= 0;
+            }
+
+            delay_cycles(READING_ADJUST);
+            delay_us(SECOND_HALF_SERIAL_DELAY);
+
+            data <<= 1;
+        }
+
+        delay_us(FIRST_HALF_SERIAL_DELAY);
+
+        let transmitter_parity_bit = (P::read() >> P::PIN_NUM) & LSB;
+
+        delay_cycles(READING_ADJUST);
+        delay_us(SECOND_HALF_SERIAL_DELAY);
+
+        if reciever_parity_bit != transmitter_parity_bit {
+            return Err((data, reciever_parity_bit));
+        }
+
+        Ok(data)
+    }
+}