Adds a first host-side integration test that tests for the protocol::ProtocolError::NinaProtocolVersionMismatch error

Author: jhodapp

cross/get_fw_version/src/main.rs

@@ -86,14 +86,14 @@ fn main() -> ! {
     let spi = hal::Spi::<_, _, 8>::new(pac.SPI0);
 
     // Exchange the uninitialized SPI driver for an initialized one
-    let spi = spi.init(
+    let mut spi = spi.init(
         &mut pac.RESETS,
         clocks.peripheral_clock.freq(),
         8_000_000u32.Hz(),
         &MODE_0,
     );
 
-    let esp_pins = esp32_wroom_rp::gpio::EspControlPins {
+    let mut esp_pins = esp32_wroom_rp::gpio::EspControlPins {
         // CS on pin x (GPIO7)
         cs: pins.gpio7.into_mode::<hal::gpio::PushPullOutput>(),
         // GPIO0 on pin x (GPIO2)
@@ -103,7 +103,7 @@ fn main() -> ! {
         // ACK on pin x (GPIO10)
         ack: pins.gpio10.into_mode::<hal::gpio::FloatingInput>(),
     };
-    let mut wifi = esp32_wroom_rp::wifi::Wifi::init(spi, esp_pins, &mut delay).unwrap();
+    let mut wifi = esp32_wroom_rp::wifi::Wifi::init(&mut spi, &mut esp_pins, &mut delay).unwrap();
     let firmware_version = wifi.firmware_version();
     defmt::info!("NINA firmware version: {:?}", firmware_version);
 

cross/join/src/main.rs

@@ -89,14 +89,14 @@ fn main() -> ! {
     let spi = hal::Spi::<_, _, 8>::new(pac.SPI0);
 
     // Exchange the uninitialized SPI driver for an initialized one
-    let spi = spi.init(
+    let mut spi = spi.init(
         &mut pac.RESETS,
         clocks.peripheral_clock.freq(),
         8_000_000u32.Hz(),
         &MODE_0,
     );
 
-    let esp_pins = esp32_wroom_rp::gpio::EspControlPins {
+    let mut esp_pins = esp32_wroom_rp::gpio::EspControlPins {
         // CS on pin x (GPIO7)
         cs: pins.gpio7.into_mode::<hal::gpio::PushPullOutput>(),
         // GPIO0 on pin x (GPIO2)
@@ -107,7 +107,8 @@ fn main() -> ! {
         ack: pins.gpio10.into_mode::<hal::gpio::FloatingInput>(),
     };
 
-    let mut wifi = esp32_wroom_rp::wifi::Wifi::init(spi, esp_pins, &mut delay).unwrap();
+    let mut wifi = esp32_wroom_rp::wifi::Wifi::init(&mut spi, &mut esp_pins, &mut delay).unwrap();
+
     let result = wifi.join(SSID, PASSPHRASE);
     defmt::info!("Join Result: {:?}", result);
 

esp32-wroom-rp/src/gpio.rs

@@ -75,7 +75,7 @@ pub trait EspControlInterface {
 /// A structured representation of all GPIO pins that control a ESP32-WROOM NINA firmware-based
 /// device outside of commands sent over the SPI/I²C bus. Pass a single instance of this struct
 /// into `Wifi::init()`.
-pub struct EspControlPins<CS: OutputPin, GPIO0: OutputPin, RESETN: OutputPin, ACK: InputPin> {
+pub struct EspControlPins<CS, GPIO0, RESETN, ACK> {
     /// Chip select pin to let the NINA firmware know we're going to send it a command over
     /// the SPI bus.
     pub cs: CS,
@@ -131,13 +131,13 @@ where
 
     fn wait_for_esp_ready(&self) {
         while self.get_esp_ready() != true {
-            cortex_m::asm::nop(); // Make sure rustc doesn't optimize this loop out
+            //cortex_m::asm::nop(); // Make sure rustc doesn't optimize this loop out
         }
     }
 
     fn wait_for_esp_ack(&self) {
         while self.get_esp_ack() == false {
-            cortex_m::asm::nop(); // Make sure rustc doesn't optimize this loop out
+            //cortex_m::asm::nop(); // Make sure rustc doesn't optimize this loop out
         }
     }
 
@@ -148,6 +148,17 @@ where
     }
 }
 
+impl Default for EspControlPins<(), (), (), ()> {
+    fn default() -> Self {
+        Self {
+            cs: (),
+            gpio0: (),
+            resetn: (),
+            ack: ()
+        }
+    }
+}
+
 #[cfg(test)]
 mod gpio_tests {
     use super::EspControlPins;

esp32-wroom-rp/src/lib.rs

@@ -75,7 +75,7 @@
 //!     ack: pins.gpio10.into_mode::<hal::gpio::FloatingInput>(),
 //! };
 //!
-//! let mut wifi = esp32_wroom_rp::spi::Wifi::init(spi, esp_pins, &mut delay).unwrap();
+//! let mut wifi = esp32_wroom_rp::spi::Wifi::init(&mut spi, &mut esp_pins, &mut delay).unwrap();
 //! let version = wifi.firmware_version();
 //! ```
 
@@ -88,7 +88,7 @@ pub mod gpio;
 /// Fundamental interface for controlling a connected ESP32-WROOM NINA firmware-based Wifi board.
 pub mod wifi;
 
-mod protocol;
+pub mod protocol;
 mod spi;
 
 use protocol::{ProtocolInterface, ProtocolError};
@@ -99,7 +99,7 @@ use embedded_hal::blocking::delay::DelayMs;
 const ARRAY_LENGTH_PLACEHOLDER: usize = 8;
 
 /// Highest level error types for this crate.
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum Error {
     /// SPI/I2C related communications error with the ESP32 WiFi target
     Bus,
@@ -118,13 +118,7 @@ impl Format for Error {
 
 impl From<protocol::ProtocolError> for Error {
     fn from(err: protocol::ProtocolError) -> Self {
-        match err {
-            protocol::ProtocolError::CommunicationTimeout => Error::Protocol(err),
-            protocol::ProtocolError::InvalidCommand => Error::Protocol(err),
-            protocol::ProtocolError::InvalidNumberOfParameters => Error::Protocol(err),
-            protocol::ProtocolError::NinaProtocolVersionMismatch => Error::Protocol(err),
-            protocol::ProtocolError::TooManyParameters => Error::Protocol(err),
-        }
+        Error::Protocol(err)
     }
 }
 
@@ -167,7 +161,7 @@ impl Format for FirmwareVersion {
     }
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 struct WifiCommon<PH> {
     protocol_handler: PH,
 }

esp32-wroom-rp/src/protocol.rs

@@ -1,4 +1,4 @@
-pub mod operation;
+pub(crate) mod operation;
 
 use super::*;
 
@@ -8,7 +8,7 @@ use defmt::{write, Format, Formatter};
 
 use heapless::{String, Vec};
 
-pub const MAX_NINA_PARAM_LENGTH: usize = 255;
+pub(crate) const MAX_NINA_PARAM_LENGTH: usize = 255;
 
 #[repr(u8)]
 #[derive(Copy, Clone, Debug)]
@@ -231,15 +231,15 @@ pub(crate) trait ProtocolInterface {
     fn get_conn_status(&mut self) -> Result<u8, ProtocolError>;
 }
 
-#[derive(Debug, Default)]
-pub(crate) struct NinaProtocolHandler<B, C> {
+#[derive(Debug)]
+pub(crate) struct NinaProtocolHandler<'a, B, C> {
     /// A Spi or I2c instance
-    pub bus: B,
+    pub bus: &'a mut B,
     /// An EspControlPins instance
-    pub control_pins: C,
+    pub control_pins: &'a mut C,
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum ProtocolError {
     NinaProtocolVersionMismatch,
     CommunicationTimeout,

esp32-wroom-rp/src/spi.rs

@@ -27,23 +27,23 @@ enum ControlByte {
 }
 
 /// Fundamental struct for controlling a connected ESP32-WROOM NINA firmware-based Wifi board.
-#[derive(Debug, Default)]
-pub struct Wifi<B, C> {
-    common: WifiCommon<NinaProtocolHandler<B, C>>,
+#[derive(Debug)]
+pub struct Wifi<'a, B, C> {
+    common: WifiCommon<NinaProtocolHandler<'a, B, C>>,
 }
 
-impl<S, C> Wifi<S, C>
+impl<'a, S, C> Wifi<'a, S, C>
 where
     S: Transfer<u8>,
     C: EspControlInterface,
 {
     /// Initializes the ESP32-WROOM Wifi device.
     /// Calling this function puts the connected ESP32-WROOM device in a known good state to accept commands.
     pub fn init<D: DelayMs<u16>>(
-        spi: S,
-        control_pins: C,
+        spi: &'a mut S,
+        control_pins: &'a mut C,
         delay: &mut D,
-    ) -> Result<Wifi<S, C>, Error> {
+    ) -> Result<Wifi<'a, S, C>, Error> {
         let mut wifi = Wifi {
             common: WifiCommon {
                 protocol_handler: NinaProtocolHandler {
@@ -82,7 +82,7 @@ where
 }
 
 // All SPI-specific aspects of the NinaProtocolHandler go here in this struct impl
-impl<S, C> ProtocolInterface for NinaProtocolHandler<S, C>
+impl<'a, S, C> ProtocolInterface for NinaProtocolHandler<'a, S, C>
 where
     S: Transfer<u8>,
     C: EspControlInterface,
@@ -142,7 +142,7 @@ where
     }
 }
 
-impl<S, C> NinaProtocolHandler<S, C>
+impl<'a, S, C> NinaProtocolHandler<'a, S, C>
 where
     S: Transfer<u8>,
     C: EspControlInterface,
@@ -199,6 +199,8 @@ where
 
         for byte in buf {
             let write_buf = &mut [byte];
+            // FIXME: temporary for test writing debugging
+            defmt::debug!("0x{:02x}, ", write_buf[0]);
             self.bus.transfer(write_buf).ok();
         }
 
@@ -213,7 +215,7 @@ where
         cmd: &NinaCommand,
         num_params: u8,
     ) -> Result<[u8; ARRAY_LENGTH_PLACEHOLDER], ProtocolError> {
-        self.check_start_cmd().ok().unwrap();
+        self.check_start_cmd()?;
         let byte_to_check: u8 = *cmd as u8 | ControlByte::Reply as u8;
         let result = self.read_and_check_byte(&byte_to_check).ok().unwrap();
         // Ensure we see a cmd byte

host-tests/Cargo.toml

@@ -12,3 +12,4 @@ description = "Host-side tests for the Rust-based Espressif ESP32-WROOM WiFi dri
 
 [dev-dependencies]
 embedded-hal-mock = "0.8.0"
+esp32-wroom-rp = { path = "../esp32-wroom-rp" }

host-tests/tests/spi.rs

@@ -1,2 +1,60 @@
+use embedded_hal_mock::spi;
+use embedded_hal_mock::pin::{
+    Mock as PinMock, State as PinState, Transaction as PinTransaction,
+};
+use embedded_hal_mock::delay::MockNoop;
+
+use esp32_wroom_rp::wifi::Wifi;
+use esp32_wroom_rp::gpio::EspControlInterface;
+
+struct EspControlMock {}
+
+impl EspControlInterface for EspControlMock {
+    fn init(&mut self) {}
+
+    fn reset<D>(&mut self, _delay: &mut D) {}
+
+    fn get_esp_ack(&self) -> bool {
+        true
+    }
+
+   fn  wait_for_esp_select(&mut self) {}
+
+    fn wait_for_esp_ack(&self) {}
+
+    fn wait_for_esp_ready(&self) {}
+
+    fn esp_select(&mut self) {}
+
+    fn esp_deselect(&mut self) {}
+
+    fn get_esp_ready(&self) -> bool {
+        true
+    }
+}
+
 #[test]
-fn do_something_with_spi_succeeds() {}
+fn invalid_command_induces_nina_protocol_version_mismatch_error() {
+    let spi_expectations = vec![
+        // send_cmd()
+        spi::Transaction::transfer(vec![0xe0], vec![0x0]),
+        spi::Transaction::transfer(vec![0x37], vec![0x0]),
+        spi::Transaction::transfer(vec![0x0], vec![0x0]),
+        spi::Transaction::transfer(vec![0xee], vec![0x0]),
+
+        // wait_response_cmd()
+        spi::Transaction::transfer(vec![0xff], vec![0xef]),
+    ];
+    let mut spi = spi::Mock::new(&spi_expectations);
+
+    let mut delay = MockNoop::new();
+
+    let mut pins = EspControlMock {};
+
+    let mut wifi = Wifi::init(&mut spi, &mut pins, &mut delay).ok().unwrap();
+    let f = wifi.firmware_version();
+
+    assert_eq!(f.unwrap_err(), esp32_wroom_rp::Error::Protocol(esp32_wroom_rp::protocol::ProtocolError::NinaProtocolVersionMismatch));
+
+    spi.done();
+}