Removed the active/inactive concept, and changed bus to use blocking …

…traits to allow users to use shared-bus

README.md

@@ -33,8 +33,10 @@ of the SPI implementation.  It must be set up to work as the W5500 chip requires
     let mut spi = ...; // SPI interface to use
     let mut cs : OutputPin = ...; // chip select
 
-    let interface = Interface::setup(spi, cs, MacAddress::new(0, 1, 2, 3, 4, 5), Ipv4Addr::new(192, 168, 86, 79)).unwrap();
-    let socket = interface.connect(
+    let device = UninitializedDevice::new(FourWire::new(spi, cs));
+    let device = device.initialize_manual(MacAddress::new(0, 1, 2, 3, 4, 5), Ipv4Addr::new(192, 168, 86, 79), Mode::default()).unwrap();
+    let socket = interface.socket();
+    socket.connect(
         SocketAddr::new(IpAddr::V4(Ipv4Addr::new(192, 168, 86, 38)), 8000),
     ).unwrap();
     block!(interface.send(&mut socket, &[104, 101, 108, 108, 111, 10]));

src/bus/four_wire.rs

@@ -1,50 +1,43 @@
 #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
 
 use core::fmt;
+use embedded_hal::blocking::spi::{Transfer, Write};
 use embedded_hal::digital::v2::OutputPin;
-use embedded_hal::spi::FullDuplex;
 
-use crate::bus::{ActiveBus, Bus};
+use crate::bus::Bus;
 
 const WRITE_MODE_MASK: u8 = 0b00000_1_00;
 
-pub struct FourWire<ChipSelect: OutputPin> {
+pub struct FourWire<Spi: Transfer<u8> + Write<u8>, ChipSelect: OutputPin> {
     cs: ChipSelect,
+    spi: Spi,
 }
 
-impl<ChipSelect: OutputPin> FourWire<ChipSelect> {
-    pub fn new(cs: ChipSelect) -> Self {
-        Self { cs }
-    }
-    pub fn release(self) -> ChipSelect {
-        self.cs
+impl<Spi: Transfer<u8> + Write<u8>, ChipSelect: OutputPin> FourWire<Spi, ChipSelect> {
+    pub fn new(spi: Spi, cs: ChipSelect) -> Self {
+        Self { spi, cs }
     }
-}
 
-impl<ChipSelect: OutputPin> Bus for FourWire<ChipSelect> {}
-
-impl<ChipSelect: OutputPin> FourWire<ChipSelect> {
-    pub fn activate<Spi: FullDuplex<u8>>(self, spi: Spi) -> ActiveFourWire<Spi, ChipSelect> {
-        ActiveFourWire { cs: self.cs, spi }
+    pub fn release(self) -> (Spi, ChipSelect) {
+        (self.spi, self.cs)
     }
 }
 
-pub struct ActiveFourWire<Spi: FullDuplex<u8>, ChipSelect: OutputPin> {
-    cs: ChipSelect,
-    spi: Spi,
-}
-
-impl<Spi: FullDuplex<u8>, ChipSelect: OutputPin> ActiveBus for ActiveFourWire<Spi, ChipSelect> {
-    type Error = FourWireError<Spi::Error, ChipSelect::Error>;
+impl<Spi: Transfer<u8> + Write<u8>, ChipSelect: OutputPin> Bus for FourWire<Spi, ChipSelect> {
+    type Error =
+        FourWireError<<Spi as Transfer<u8>>::Error, <Spi as Write<u8>>::Error, ChipSelect::Error>;
     fn read_frame(&mut self, block: u8, address: u16, data: &mut [u8]) -> Result<(), Self::Error> {
         let address_phase = address.to_be_bytes();
         let control_phase = block << 3;
         let data_phase = data;
         self.cs.set_low().map_err(FourWireError::ChipSelectError)?;
-        Self::write_bytes(&mut self.spi, &address_phase)
-            .and_then(|_| Self::transfer_byte(&mut self.spi, control_phase))
-            .and_then(|_| Self::read_bytes(&mut self.spi, data_phase))
-            .map_err(FourWireError::SpiError)?;
+        self.spi
+            .write(&address_phase)
+            .and_then(|_| self.spi.write(&[control_phase]))
+            .map_err(FourWireError::WriteError)?;
+        self.spi
+            .transfer(data_phase)
+            .map_err(FourWireError::TransferError)?;
         self.cs.set_high().map_err(FourWireError::ChipSelectError)?;
 
         Ok(())
@@ -54,37 +47,40 @@ impl<Spi: FullDuplex<u8>, ChipSelect: OutputPin> ActiveBus for ActiveFourWire<Sp
         let control_phase = block << 3 | WRITE_MODE_MASK;
         let data_phase = data;
         self.cs.set_low().map_err(FourWireError::ChipSelectError)?;
-        Self::write_bytes(&mut self.spi, &address_phase)
-            .and_then(|_| Self::transfer_byte(&mut self.spi, control_phase))
-            .and_then(|_| Self::write_bytes(&mut self.spi, data_phase))
-            .map_err(FourWireError::SpiError)?;
+        self.spi
+            .write(&address_phase)
+            .and_then(|_| self.spi.write(&[control_phase]))
+            .and_then(|_| self.spi.write(data_phase))
+            .map_err(FourWireError::WriteError)?;
         self.cs.set_high().map_err(FourWireError::ChipSelectError)?;
 
         Ok(())
     }
 }
-impl<Spi: FullDuplex<u8>, ChipSelect: OutputPin> ActiveFourWire<Spi, ChipSelect> {
-    pub fn deactivate(self) -> (FourWire<ChipSelect>, Spi) {
-        (FourWire::new(self.cs), self.spi)
-    }
-}
 
 // Must use map_err, ambiguity prevents From from being implemented
 #[repr(u8)]
-pub enum FourWireError<SpiError, ChipSelectError> {
-    SpiError(SpiError),
+pub enum FourWireError<TransferError, WriteError, ChipSelectError> {
+    TransferError(TransferError),
+    WriteError(WriteError),
     ChipSelectError(ChipSelectError),
 }
 
-impl<SpiError, ChipSelectError> fmt::Debug for FourWireError<SpiError, ChipSelectError> {
+impl<TransferError, WriteError, ChipSelectError> fmt::Debug
+    for FourWireError<TransferError, WriteError, ChipSelectError>
+{
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
             "FourWireError::{}",
             match self {
-                Self::SpiError(_) => "SpiError",
+                Self::TransferError(_) => "TransferError",
+                Self::WriteError(_) => "WriteError",
                 Self::ChipSelectError(_) => "ChipSelectError",
             }
         )
     }
 }
+
+// TODO Improved error rendering could be done with specialization.
+// https://github.com/rust-lang/rust/issues/31844

src/bus/mod.rs

@@ -1,38 +1,15 @@
 use core::fmt::Debug;
-use embedded_hal::spi::FullDuplex;
 
 mod four_wire;
 mod three_wire;
 
-pub use self::four_wire::ActiveFourWire;
 pub use self::four_wire::FourWire;
-pub use self::three_wire::ActiveThreeWire;
 pub use self::three_wire::ThreeWire;
 
-pub trait Bus {}
-
-pub trait ActiveBus {
+pub trait Bus {
     type Error: Debug;
 
     fn read_frame(&mut self, block: u8, address: u16, data: &mut [u8]) -> Result<(), Self::Error>;
 
     fn write_frame(&mut self, block: u8, address: u16, data: &[u8]) -> Result<(), Self::Error>;
-
-    fn read_bytes<Spi: FullDuplex<u8>>(spi: &mut Spi, bytes: &mut [u8]) -> Result<(), Spi::Error> {
-        for byte in bytes.iter_mut() {
-            *byte = Self::transfer_byte(spi, *byte)?;
-        }
-        Ok(())
-    }
-
-    fn write_bytes<Spi: FullDuplex<u8>>(spi: &mut Spi, bytes: &[u8]) -> Result<(), Spi::Error> {
-        for byte in bytes.iter() {
-            Self::transfer_byte(spi, *byte)?;
-        }
-        Ok(())
-    }
-
-    fn transfer_byte<Spi: FullDuplex<u8>>(spi: &mut Spi, byte: u8) -> Result<u8, Spi::Error> {
-        block!(spi.send(byte)).and_then(|_| block!(spi.read()))
-    }
 }

src/bus/three_wire.rs

@@ -1,44 +1,32 @@
 #![allow(clippy::inconsistent_digit_grouping, clippy::unusual_byte_groupings)]
 
 use core::fmt;
-use embedded_hal::spi::FullDuplex;
+use embedded_hal::blocking::spi::{Transfer, Write};
 
-use crate::bus::{ActiveBus, Bus};
+use crate::bus::Bus;
 
 const WRITE_MODE_MASK: u8 = 0b00000_1_0;
 
 const FIXED_DATA_LENGTH_MODE_1: u8 = 0b000000_01;
 const FIXED_DATA_LENGTH_MODE_2: u8 = 0b000000_10;
 const FIXED_DATA_LENGTH_MODE_4: u8 = 0b000000_11;
 
-pub struct ThreeWire {}
-
-impl ThreeWire {
-    pub fn new() -> Self {
-        Self {}
-    }
+pub struct ThreeWire<Spi: Transfer<u8> + Write<u8>> {
+    spi: Spi,
 }
 
-impl Default for ThreeWire {
-    fn default() -> Self {
-        Self::new()
+impl<Spi: Transfer<u8> + Write<u8>> ThreeWire<Spi> {
+    pub fn new(spi: Spi) -> Self {
+        Self { spi }
     }
-}
 
-impl Bus for ThreeWire {}
-
-impl ThreeWire {
-    pub fn activate<Spi: FullDuplex<u8>>(self, spi: Spi) -> ActiveThreeWire<Spi> {
-        ActiveThreeWire { spi }
+    pub fn release(self) -> Spi {
+        self.spi
     }
 }
 
-pub struct ActiveThreeWire<Spi: FullDuplex<u8>> {
-    spi: Spi,
-}
-
-impl<Spi: FullDuplex<u8>> ActiveBus for ActiveThreeWire<Spi> {
-    type Error = ThreeWireError<Spi::Error>;
+impl<Spi: Transfer<u8> + Write<u8>> Bus for ThreeWire<Spi> {
+    type Error = ThreeWireError<<Spi as Transfer<u8>>::Error, <Spi as Write<u8>>::Error>;
 
     /// Transfers a frame with an arbitrary data length in FDM
     ///
@@ -74,20 +62,20 @@ impl<Spi: FullDuplex<u8>> ActiveBus for ActiveThreeWire<Spi> {
             }
 
             let address_phase = address.to_be_bytes();
-            Self::write_bytes(&mut self.spi, &address_phase)
-                .and_then(|_| Self::transfer_byte(&mut self.spi, control_phase))
-                .and_then(|_| {
-                    Self::read_bytes(
-                        &mut self.spi,
-                        &mut data_phase[..last_length_written as usize],
-                    )
-                })?;
+            self.spi
+                .write(&address_phase)
+                .and_then(|_| self.spi.write(&[control_phase]))
+                .map_err(ThreeWireError::WriteError)?;
+            self.spi
+                .transfer(&mut data_phase[..last_length_written as usize])
+                .map_err(ThreeWireError::TransferError)?;
 
             address += last_length_written;
             data_phase = &mut data_phase[last_length_written as usize..];
         }
         Ok(())
     }
+
     fn write_frame(&mut self, block: u8, mut address: u16, data: &[u8]) -> Result<(), Self::Error> {
         let mut control_phase = block << 3 | WRITE_MODE_MASK;
 
@@ -106,11 +94,11 @@ impl<Spi: FullDuplex<u8>> ActiveBus for ActiveThreeWire<Spi> {
             }
 
             let address_phase = address.to_be_bytes();
-            Self::write_bytes(&mut self.spi, &address_phase)
-                .and_then(|_| Self::transfer_byte(&mut self.spi, control_phase))
-                .and_then(|_| {
-                    Self::write_bytes(&mut self.spi, &data_phase[..last_length_written as usize])
-                })?;
+            self.spi
+                .write(&address_phase)
+                .and_then(|_| self.spi.write(&[control_phase]))
+                .and_then(|_| self.spi.write(&data_phase[..last_length_written as usize]))
+                .map_err(ThreeWireError::WriteError)?;
 
             address += last_length_written;
             data_phase = &data_phase[last_length_written as usize..];
@@ -119,29 +107,20 @@ impl<Spi: FullDuplex<u8>> ActiveBus for ActiveThreeWire<Spi> {
     }
 }
 
-impl<Spi: FullDuplex<u8>> ActiveThreeWire<Spi> {
-    pub fn deactivate(self) -> (ThreeWire, Spi) {
-        (ThreeWire::new(), self.spi)
-    }
-}
-
-pub enum ThreeWireError<SpiError> {
-    SpiError(SpiError),
-}
-
-impl<SpiError> From<SpiError> for ThreeWireError<SpiError> {
-    fn from(error: SpiError) -> ThreeWireError<SpiError> {
-        ThreeWireError::SpiError(error)
-    }
+// Must use map_err, ambiguity prevents From from being implemented
+pub enum ThreeWireError<TransferError, WriteError> {
+    TransferError(TransferError),
+    WriteError(WriteError),
 }
 
-impl<SpiError> fmt::Debug for ThreeWireError<SpiError> {
+impl<TransferError, WriteError> fmt::Debug for ThreeWireError<TransferError, WriteError> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
             "ThreeWireError::{}",
             match self {
-                Self::SpiError(_) => "SpiError",
+                Self::TransferError(_) => "TransferError",
+                Self::WriteError(_) => "WriteError",
             }
         )
     }

src/device.rs

@@ -3,18 +3,14 @@ use crate::uninitialized_device::UninitializedDevice;
 use bit_field::BitArray;
 use bus::{ActiveBus, ActiveFourWire, ActiveThreeWire, FourWire, ThreeWire};
 use embedded_hal::digital::v2::OutputPin;
-use embedded_hal::spi::FullDuplex;
 
-use interface::Interface;
-use network::Network;
-use crate::bus::{ActiveBus, ActiveFourWire, ActiveThreeWire, FourWire, ThreeWire};
+use crate::bus::{Bus, FourWire, ThreeWire};
 use crate::host::Host;
-use crate::inactive_device::InactiveDevice;
 use crate::register;
 use crate::socket::Socket;
 use crate::uninitialized_device::UninitializedDevice;
 
-pub struct Device<SpiBus: ActiveBus, HostImpl: Host> {
+pub struct Device<SpiBus: Bus, HostImpl: Host> {
     pub bus: SpiBus,
     host: HostImpl,
     sockets: [u8; 1],
@@ -31,7 +27,7 @@ impl<E> From<E> for ResetError<E> {
     }
 }
 
-impl<SpiBus: ActiveBus, HostImpl: Host> Device<SpiBus, HostImpl> {
+impl<SpiBus: Bus, HostImpl: Host> Device<SpiBus, HostImpl> {
     pub fn new(bus: SpiBus, host: HostImpl) -> Self {
         Device {
             bus,
@@ -58,6 +54,7 @@ impl<SpiBus: ActiveBus, HostImpl: Host> Device<SpiBus, HostImpl> {
     }
 
     pub fn take_socket(&mut self) -> Option<Socket> {
+        // TODO maybe return Future that resolves when release_socket invoked
         for index in 0..8 {
             if self.sockets.get_bit(index) {
                 self.sockets.set_bit(index, false);
@@ -82,19 +79,3 @@ impl<SpiBus: ActiveBus, HostImpl: Host> Device<SpiBus, HostImpl> {
         (self.bus, self.host)
     }
 }
-
-impl<Spi: FullDuplex<u8>, ChipSelect: OutputPin, HostImpl: Host>
-    Device<ActiveFourWire<Spi, ChipSelect>, HostImpl>
-{
-    pub fn deactivate(self) -> (InactiveDevice<FourWire<ChipSelect>, HostImpl>, Spi) {
-        let (bus, spi) = self.bus.deactivate();
-        (InactiveDevice::new(bus, self.host), spi)
-    }
-}
-
-impl<Spi: FullDuplex<u8>, HostImpl: Host> Device<ActiveThreeWire<Spi>, HostImpl> {
-    pub fn deactivate(self) -> (InactiveDevice<ThreeWire, HostImpl>, Spi) {
-        let (bus, spi) = self.bus.deactivate();
-        (InactiveDevice::new(bus, self.host), spi)
-    }
-}

src/host/dhcp.rs

@@ -1,4 +1,4 @@
-use crate::bus::ActiveBus;
+use crate::bus::Bus;
 use crate::host::Host;
 use crate::MacAddress;
 
@@ -22,7 +22,7 @@ impl Dhcp {
 
 impl Host for Dhcp {
     /// Gets (if necessary) and sets the host settings on the chip
-    fn refresh<SpiBus: ActiveBus>(&mut self, _bus: &mut SpiBus) -> Result<(), SpiBus::Error> {
+    fn refresh<SpiBus: Bus>(&mut self, _bus: &mut SpiBus) -> Result<(), SpiBus::Error> {
         // TODO actually negotiate settings from DHCP
         // TODO figure out how should receive socket for DHCP negotiations
         Ok(())