Add ProtocolError

Author: calebbourg

cross/get_fw_version/src/main.rs

@@ -63,10 +63,7 @@ fn main() -> ! {
     .ok()
     .unwrap();
 
-    let mut delay = cortex_m::delay::Delay::new(
-        core.SYST,
-        clocks.system_clock.freq().integer(),
-    );
+    let mut delay = cortex_m::delay::Delay::new(core.SYST, clocks.system_clock.freq().integer());
 
     // The single-cycle I/O block controls our GPIO pins
     let sio = hal::Sio::new(pac.SIO);

cross/join/src/main.rs

@@ -66,10 +66,7 @@ fn main() -> ! {
     .ok()
     .unwrap();
 
-    let mut delay = cortex_m::delay::Delay::new(
-        core.SYST,
-        clocks.system_clock.freq().integer(),
-    );
+    let mut delay = cortex_m::delay::Delay::new(core.SYST, clocks.system_clock.freq().integer());
 
     // The single-cycle I/O block controls our GPIO pins
     let sio = hal::Sio::new(pac.SIO);

esp32-wroom-rp/src/gpio.rs

@@ -41,7 +41,7 @@ enum IOError {
 
 /// Provides an internal pin interface that abstracts the extra control lines that
 /// are separate from a data bus (e.g. SPI/I2C).
-/// 
+///
 /// Not meant to be used outside of the crate.
 pub trait EspControlInterface {
     /// Initializes all controls pins to set ready communication with the NINA firmware.
@@ -98,27 +98,27 @@ where
 {
     fn init(&mut self) {
         // Chip select is active-low, so we'll initialize it to a driven-high state
-        self.cs.set_high().ok().unwrap();
-        self.gpio0.set_high().ok().unwrap();
-        self.resetn.set_high().ok().unwrap();
+        self.cs.set_high().ok();
+        self.gpio0.set_high().ok();
+        self.resetn.set_high().ok();
         self.get_esp_ready();
     }
 
     fn reset<D: DelayMs<u16>>(&mut self, delay: &mut D) {
-        self.gpio0.set_high().ok().unwrap();
-        self.cs.set_high().ok().unwrap();
-        self.resetn.set_low().ok().unwrap();
+        self.gpio0.set_high().ok();
+        self.cs.set_high().ok();
+        self.resetn.set_low().ok();
         delay.delay_ms(10);
-        self.resetn.set_high().ok().unwrap();
+        self.resetn.set_high().ok();
         delay.delay_ms(750);
     }
 
     fn esp_select(&mut self) {
-        self.cs.set_low().ok().unwrap();
+        self.cs.set_low().ok();
     }
 
     fn esp_deselect(&mut self) {
-        self.cs.set_high().ok().unwrap();
+        self.cs.set_high().ok();
     }
 
     fn get_esp_ready(&self) -> bool {

esp32-wroom-rp/src/protocol.rs

@@ -236,3 +236,8 @@ pub(crate) struct NinaProtocolHandler<B, C> {
     /// An EspControlPins instance
     pub control_pins: C,
 }
+
+pub(crate) enum Error {
+    NinaProtocolVersionMismatch,
+    Timeout,
+}

esp32-wroom-rp/src/spi.rs

@@ -7,11 +7,14 @@ use super::protocol::{
 };
 
 use super::protocol::operation::Operation;
+use super::protocol::Error as ProtocolError;
 use super::{Error, FirmwareVersion, WifiCommon, ARRAY_LENGTH_PLACEHOLDER};
 
 use embedded_hal::blocking::delay::DelayMs;
 use embedded_hal::blocking::spi::Transfer;
 
+use core::convert::Infallible;
+
 // TODO: this should eventually move into NinaCommandHandler
 #[repr(u8)]
 #[derive(Debug)]
@@ -251,44 +254,24 @@ where
         Ok(())
     }
 
-    fn get_byte(&mut self) -> Result<u8, self::Error> {
-        // Blocking read, don't return until we've read a byte successfully
-        loop {
-            let word_out = &mut [ControlByte::Dummy as u8];
-            match self.bus.transfer(word_out) {
-                Ok(word) => {
-                    let byte: u8 = word[0] as u8;
-                    return Ok(byte);
-                }
-                Err(_e) => {
-                    continue;
-                }
-            }
-        }
+    fn get_byte(&mut self) -> Result<u8, Infallible> {
+        let word_out = &mut [ControlByte::Dummy as u8];
+        let word = self.bus.transfer(word_out).ok().unwrap();
+        Ok(word[0] as u8)
     }
 
-    fn wait_for_byte(&mut self, wait_byte: u8) -> Result<bool, self::Error> {
-        let mut timeout: u16 = 1000u16;
-
-        loop {
-            match self.get_byte() {
-                Ok(byte_read) => {
-                    if byte_read == ControlByte::Error as u8 {
-                        return Ok(false);
-                        //return Err(SPIError::Misc);
-                    } else if byte_read == wait_byte {
-                        return Ok(true);
-                    } else if timeout == 0 {
-                        return Ok(false);
-                        //return Err(SPIError::Timeout);
-                    }
-                    timeout -= 1;
-                }
-                Err(e) => {
-                    return Err(e);
-                }
+    fn wait_for_byte(&mut self, wait_byte: u8) -> Result<bool, ProtocolError> {
+        let retry_limit: u16 = 1000u16;
+
+        for _ in 0..retry_limit {
+            let byte_read = self.get_byte().ok().unwrap();
+            if byte_read == ControlByte::Error as u8 {
+                return Err(ProtocolError::NinaProtocolVersionMismatch);
+            } else if byte_read == wait_byte {
+                return Ok(true);
             }
         }
+        Err(ProtocolError::Timeout)
     }
 
     fn check_start_cmd(&mut self) -> Result<bool, self::Error> {