Merge pull request #25 from Jim-Hodapp-Coaching/leave_a_wifi_network

Leave a previously joined WiFi network (non-enterprise)

Author: jhodapp

examples/join.rs

@@ -1,7 +1,8 @@
 //! # ESP32-WROOM-RP Pico Wireless Example
 //!
 //! This application demonstrates how to use the ESP32-WROOM-RP crate to request that
-//! a remote ESP32 WiFi target connects to a particular SSID given a passphrase.
+//! a remote ESP32 WiFi target connects to a particular SSID given a passphrase
+//! and then leaves (disconnects) that same network.
 //!
 //! See the `Cargo.toml` file for Copyright and license details.
 
@@ -99,7 +100,7 @@ fn main() -> ! {
         &mut pac.RESETS,
     );
 
-    defmt::info!("ESP32-WROOM-RP get NINA firmware version example");
+    defmt::info!("ESP32-WROOM-RP join/leave WiFi network");
 
     // These are implicitly used by the spi driver if they are in the correct mode
     let spi_miso = pins.gpio16.into_mode::<hal::gpio::FunctionSpi>();
@@ -144,6 +145,13 @@ fn main() -> ! {
 
                 if byte == 3 {
                     defmt::info!("Connected to Network: {:?}", ssid);
+
+                    defmt::info!("Sleeping for 5 seconds before disconnecting...");
+                    delay.delay_ms(5000).ok().unwrap();
+
+                    wifi.leave().ok().unwrap();
+                } else if byte == 6 {
+                    defmt::info!("Disconnected from Network: {:?}", ssid);
                 }
             }
             Err(e) => {

src/lib.rs

@@ -190,6 +190,10 @@ where
         self.protocol_handler.set_passphrase(ssid, passphrase)
     }
 
+    fn leave(&mut self) -> Result<(), Error> {
+        self.protocol_handler.disconnect()
+    }
+
     fn get_connection_status(&mut self) -> Result<u8, self::Error> {
         self.protocol_handler.get_conn_status()
     }

src/protocol.rs

@@ -12,13 +12,15 @@ pub enum NinaCommand {
     GetFwVersion = 0x37u8,
     SetPassphrase = 0x11u8,
     GetConnStatus = 0x20u8,
+    Disconnect = 0x30u8,
 }
 
 pub trait NinaParam {
     // Length of parameter in bytes
     type LengthAsBytes: IntoIterator<Item = u8>;
 
     fn new(data: &str) -> Self;
+    fn from_bytes(bytes: &[u8]) -> Self;
 
     fn data(&mut self) -> &[u8];
 
@@ -60,6 +62,15 @@ impl NinaParam for NinaByteParam {
         }
     }
 
+    fn from_bytes(bytes: &[u8]) -> Self {
+        let mut data_as_bytes: Vec<u8, 1> = Vec::new();
+        data_as_bytes.extend_from_slice(bytes);
+        Self {
+            length: data_as_bytes.len() as u8,
+            data: data_as_bytes,
+        }
+    }
+
     fn data(&mut self) -> &[u8] {
         self.data.as_slice()
     }
@@ -80,6 +91,15 @@ impl NinaParam for NinaWordParam {
         }
     }
 
+    fn from_bytes(bytes: &[u8]) -> Self {
+        let mut data_as_bytes: Vec<u8, 2> = Vec::new();
+        data_as_bytes.extend_from_slice(bytes);
+        Self {
+            length: data_as_bytes.len() as u8,
+            data: data_as_bytes,
+        }
+    }
+
     fn data(&mut self) -> &[u8] {
         self.data.as_slice()
     }
@@ -100,6 +120,15 @@ impl NinaParam for NinaSmallArrayParam {
         }
     }
 
+    fn from_bytes(bytes: &[u8]) -> Self {
+        let mut data_as_bytes: Vec<u8, MAX_NINA_PARAM_LENGTH> = Vec::new();
+        data_as_bytes.extend_from_slice(bytes);
+        Self {
+            length: data_as_bytes.len() as u8,
+            data: data_as_bytes,
+        }
+    }
+
     fn data(&mut self) -> &[u8] {
         self.data.as_slice()
     }
@@ -120,6 +149,15 @@ impl NinaParam for NinaLargeArrayParam {
         }
     }
 
+    fn from_bytes(bytes: &[u8]) -> Self {
+        let mut data_as_bytes: Vec<u8, MAX_NINA_PARAM_LENGTH> = Vec::new();
+        data_as_bytes.extend_from_slice(bytes);
+        Self {
+            length: data_as_bytes.len() as u16,
+            data: data_as_bytes,
+        }
+    }
+
     fn data(&mut self) -> &[u8] {
         self.data.as_slice()
     }
@@ -137,6 +175,7 @@ pub trait ProtocolInterface {
     fn reset<D: DelayUs>(&mut self, delay: &mut D);
     fn get_fw_version(&mut self) -> Result<FirmwareVersion, self::Error>;
     fn set_passphrase(&mut self, ssid: &str, passphrase: &str) -> Result<(), Error>;
+    fn disconnect(&mut self) -> Result<(), self::Error>;
     fn get_conn_status(&mut self) -> Result<u8, self::Error>;
 
     fn send_cmd(&mut self, cmd: NinaCommand, num_params: u8) -> Result<(), self::Error>;
@@ -147,7 +186,7 @@ pub trait ProtocolInterface {
     ) -> Result<[u8; ARRAY_LENGTH_PLACEHOLDER], self::Error>;
     fn send_end_cmd(&mut self) -> Result<(), self::Error>;
 
-    fn get_param(&mut self) -> Result<u8, self::Error>;
+    fn get_byte(&mut self) -> Result<u8, self::Error>;
     fn wait_for_byte(&mut self, wait_byte: u8) -> Result<bool, self::Error>;
     fn check_start_cmd(&mut self) -> Result<bool, self::Error>;
     fn read_and_check_byte(&mut self, check_byte: u8) -> Result<bool, self::Error>;

src/spi.rs

@@ -2,7 +2,8 @@
 
 use super::gpio::EspControlInterface;
 use super::protocol::{
-    NinaCommand, NinaParam, NinaProtocolHandler, NinaSmallArrayParam, ProtocolInterface,
+    NinaByteParam, NinaCommand, NinaParam, NinaProtocolHandler, NinaSmallArrayParam,
+    ProtocolInterface,
 };
 use super::{Error, FirmwareVersion, WifiCommon, ARRAY_LENGTH_PLACEHOLDER};
 
@@ -51,11 +52,16 @@ where
         self.common.firmware_version()
     }
 
-    /// Joins a WiFi network given an SSID and a Passphrase
+    /// Joins a WiFi network given an SSID and a Passphrase.
     pub fn join(&mut self, ssid: &str, passphrase: &str) -> Result<(), Error> {
         self.common.join(ssid, passphrase)
     }
 
+    /// Disconnects from a joined WiFi network.
+    pub fn leave(&mut self) -> Result<(), Error> {
+        self.common.leave()
+    }
+
     pub fn get_connection_status(&mut self) -> Result<u8, Error> {
         self.common.get_connection_status()
     }
@@ -118,6 +124,29 @@ where
         Ok(())
     }
 
+    fn disconnect(&mut self) -> Result<(), self::Error> {
+        self.control_pins.wait_for_esp_select();
+
+        self.send_cmd(NinaCommand::Disconnect, 1).ok().unwrap();
+
+        let dummy_param = NinaByteParam::from_bytes(&[ControlByte::Dummy as u8]);
+        self.send_param(dummy_param);
+
+        self.send_end_cmd();
+
+        // Pad byte stream to multiple of 4
+        self.get_byte().ok().unwrap();
+        self.get_byte().ok().unwrap();
+
+        self.control_pins.esp_deselect();
+        self.control_pins.wait_for_esp_select();
+
+        self.wait_response_cmd(NinaCommand::Disconnect, 1);
+
+        self.control_pins.esp_deselect();
+        Ok(())
+    }
+
     fn get_conn_status(&mut self) -> Result<u8, self::Error> {
         self.control_pins.wait_for_esp_select();
 
@@ -171,7 +200,7 @@ where
             //return Err(SPIError::Misc);
         }
 
-        let num_params_to_read = self.get_param()? as usize;
+        let num_params_to_read = self.get_byte()? as usize;
 
         if num_params_to_read > 8 {
             return Ok([0x31, 0x2e, 0x37, 0x2e, 0x34, 0x0, 0x0, 0x0]);
@@ -180,7 +209,7 @@ where
 
         let mut params: [u8; ARRAY_LENGTH_PLACEHOLDER] = [0; 8];
         for i in 0..num_params_to_read {
-            params[i] = self.get_param().ok().unwrap()
+            params[i] = self.get_byte().ok().unwrap()
         }
 
         self.read_and_check_byte(ControlByte::End as u8)?;
@@ -194,7 +223,7 @@ where
         Ok(())
     }
 
-    fn get_param(&mut self) -> Result<u8, self::Error> {
+    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];
@@ -214,7 +243,7 @@ where
         let mut timeout: u16 = 1000u16;
 
         loop {
-            match self.get_param() {
+            match self.get_byte() {
                 Ok(byte_read) => {
                     if byte_read == ControlByte::Error as u8 {
                         return Ok(false);
@@ -239,7 +268,7 @@ where
     }
 
     fn read_and_check_byte(&mut self, check_byte: u8) -> Result<bool, self::Error> {
-        match self.get_param() {
+        match self.get_byte() {
             Ok(byte_out) => {
                 return Ok(byte_out == check_byte);
             }
@@ -267,7 +296,7 @@ where
 
     fn pad_to_multiple_of_4(&mut self, mut command_size: u16) {
         while command_size % 4 == 0 {
-            self.get_param().ok().unwrap();
+            self.get_byte().ok().unwrap();
             command_size += 1;
         }
     }