Updated cargo dependencies and upgrades to IDF v5.1.1

.cargo/config.toml

@@ -5,12 +5,13 @@ target = "xtensa-esp32-espidf"
 linker = "ldproxy"
 # runner = "espflash --monitor" # Select this runner for espflash v1.x.x
 runner = "espflash flash --monitor" # Select this runner for espflash v2.x.x
-
+rustflags = [ "--cfg",  "espidf_time64"] # Extending time_t for ESP IDF 5: https://github.com/esp-rs/rust/issues/110
 
 [unstable]
 build-std = ["std", "panic_abort"]
 
 [env]
 # Note: these variables are not used when using pio builder (`cargo build --features pio`)
-ESP_IDF_VERSION = "release/v4.4"
+ESP_IDF_VERSION = "release/v5.1"
+ESP_IDF_PATH_ISSUES = "warn" # or "ignore"
 

Cargo.toml

@@ -15,23 +15,18 @@ opt-level = "z"
 
 [features]
 
-default = ["std", "hal", "esp-idf-sys/native"]
+default = ["std", "embassy", "esp-idf-svc/native"]
+pio = ["esp-idf-svc/pio"]
+std = ["alloc", "esp-idf-svc/binstart", "esp-idf-svc/std"]
+alloc = ["esp-idf-svc/alloc"]
+nightly = ["esp-idf-svc/nightly"]
+experimental = ["esp-idf-svc/experimental"]
+embassy = ["esp-idf-svc/embassy-sync", "esp-idf-svc/critical-section", "esp-idf-svc/embassy-time-driver"]
 
 
-pio = ["esp-idf-sys/pio"]
-all = ["std", "nightly", "experimental", "embassy"]
-hal = ["esp-idf-hal", "embedded-svc", "esp-idf-svc"]
-std = ["alloc", "esp-idf-sys/std", "esp-idf-sys/binstart", "embedded-svc?/std", "esp-idf-hal?/std", "esp-idf-svc?/std"]
-alloc = ["embedded-svc?/alloc", "esp-idf-hal?/alloc", "esp-idf-svc?/alloc"]
-nightly = ["embedded-svc?/nightly", "esp-idf-svc?/nightly"] # Future: "esp-idf-hal?/nightly"
-experimental = ["embedded-svc?/experimental", "esp-idf-svc?/experimental"]
-embassy = ["esp-idf-hal?/embassy-sync", "esp-idf-hal?/critical-section", "esp-idf-hal?/edge-executor", "esp-idf-svc?/embassy-time-driver", "esp-idf-svc?/embassy-time-isr-queue"]
-
 [dependencies]
 log = { version = "0.4.17", default-features = false }
-esp-idf-sys = { version = "0.33", default-features = false }
+esp-idf-svc = { version = "0.47.3", default-features = false }
-esp-idf-hal = { version = "0.41", optional = true, default-features = false }
-esp-idf-svc = { version = "0.46", optional = true, default-features = false }
 embedded-svc = { version = "0.25", optional = true, default-features = false }
 nmea-parser = "0.10.0"
 embedded-graphics = "0.8.0"

build.rs

@@ -1,6 +1,5 @@
 // Necessary because of this issue: https://github.com/rust-lang/cargo/issues/9641
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    embuild::build::CfgArgs::output_propagated("ESP_IDF")?;
+    embuild::espidf::sysenv::output();
-    embuild::build::LinkArgs::output_propagated("ESP_IDF")?;
     Ok(())
 }

src/display/mod.rs

@@ -1,25 +1,23 @@
 use crate::error::Error;
 
+use display_interface_i2c::I2CInterface;
+
 use embedded_graphics::{
-    prelude::*,
+    mono_font::{ascii::FONT_10X20, MonoTextStyle},
-    mono_font::{ascii::FONT_7X13, ascii::FONT_10X20, MonoTextStyle},
     pixelcolor::BinaryColor,
-    text::{Text, Alignment},
+    prelude::*,
+    text::{Alignment, Text},
 };
 
-use esp_idf_hal::{
+use esp_idf_svc::hal::i2c::I2cDriver;
-    self,
+
-    prelude::Peripherals, 
+
-    units::Hertz,
+
-    i2c::{I2cConfig, I2cDriver, I2c} 
+use ssd1306::{
+    prelude::*, rotation::DisplayRotation, size::DisplaySize, I2CDisplayInterface, Ssd1306,
 };
 
-use ssd1306::{prelude::*, I2CDisplayInterface, Ssd1306};
+// clear the stage of failure of the display
-
-use display_interface_i2c;
-
-
-/// Enum to make clear the stage of failure of the display
 #[derive(Debug)]
 pub enum DisplayError {
     SetupError(display_interface::DisplayError),
@@ -28,45 +26,46 @@ pub enum DisplayError {
 }
 
 pub struct Display<'a, SIZE: DisplaySize> {
-    display: Ssd1306<I2CInterface<I2cDriver<'a>>, SIZE, ssd1306::mode::BufferedGraphicsMode<SIZE>>
+    display: Ssd1306<I2CInterface<I2cDriver<'a>>, SIZE, ssd1306::mode::BufferedGraphicsMode<SIZE>>,
 }
 
-impl<'a, SIZE: DisplaySize> Display<'a, SIZE>
+impl<'a, SIZE: DisplaySize> Display<'a, SIZE> {
-{
     /// Function to create a new display interface abstraction
-    pub fn new(i2c: I2cDriver<'a>, size: SIZE, rotation: DisplayRotation) -> Result<Display<'a, SIZE>, Error> {
+    pub fn new(
+        i2c: I2cDriver<'a>,
+        size: SIZE,
+        rotation: DisplayRotation,
+    ) -> Result<Display<'a, SIZE>, Error> {
         // Construct the I2C driver into a display interface
         let interface = I2CDisplayInterface::new(i2c);
 
         // Construct display with new anew driver
-        let mut display = Ssd1306::new(interface, size, rotation)
+        let mut display = Ssd1306::new(interface, size, rotation).into_buffered_graphics_mode();
-            .into_buffered_graphics_mode();
+        display
-        display.init().map_err(|err| Error::DisplayError(DisplayError::SetupError(err)))?;
+            .init()
+            .map_err(|err| Error::DisplayError(DisplayError::SetupError(err)))?;
 
-        Ok(Display{display})
+        Ok(Display { display })
     }
 
     /// Function to draw a given set of text to a display
     pub fn draw(&mut self, text: &str) -> Result<(), Error> {
         // Clear display ready for next write
         let style = MonoTextStyle::new(&FONT_10X20, BinaryColor::On);
-        self.display.clear(BinaryColor::Off)
+        self.display
-        .map_err(|_| Error::DisplayError(DisplayError::DrawingError))?;
+            .clear(BinaryColor::Off)
+            .map_err(|_| Error::DisplayError(DisplayError::DrawingError))?;
 
         // Draw text to Display
-        Text::with_alignment(
+        Text::with_alignment(text, Point::new(64, 20), style, Alignment::Center)
-            text,
+            .draw(&mut self.display)
-            Point::new(64, 20),
+            .map_err(|_| Error::DisplayError(DisplayError::DrawingError))?;
-            style,
-            Alignment::Center,
-        )
-        .draw(&mut self.display)
-        .map_err(|_| Error::DisplayError(DisplayError::DrawingError))?;
 
         //Flush data to the display
-        self.display.flush()
+        self.display
-        .map_err(|_| Error::DisplayError(DisplayError::FlushError))?;
+            .flush()
+            .map_err(|_| Error::DisplayError(DisplayError::FlushError))?;
 
         Ok(())
     }
-}
+}

src/error.rs

@@ -1,4 +1,4 @@
-use esp_idf_sys::EspError;
+use esp_idf_svc::sys::EspError;
 use crate::display::DisplayError;
 use crate::gps::GpsError;
 

src/gps/gpsdata.rs

@@ -16,12 +16,13 @@ pub struct GpsData {
     /// Altitude reported from GPS location
     altitude: Option<f64>,
     /// Timestamp of the last report
-    timestamp: Option<DateTime<Utc>>
+    timestamp: Option<DateTime<Utc>>,
 }
 
 impl ToString for GpsData {
     fn to_string(&self) -> String {
-        format!("Latitude: {:.4?} \nLongitude: {:.4?} \nSpeed: {:.1?}mph \nAltitude: {:.1?}m", 
+        format!(
+            "Latitude: {:.4?} \nLongitude: {:.4?} \nSpeed: {:.1?}mph \nAltitude: {:.1?}m",
             self.latitude.unwrap_or_default(),
             self.longitude.unwrap_or_default(),
             self.speed.unwrap_or_default(),
@@ -40,7 +41,8 @@ impl GpsData {
 
         // Format the nmea buffer into a usable string
         let nmea_raw = String::from_utf8(buf.to_owned())
-            .map_err(|_| GpsError::ReadError()).unwrap_or_default();
+            .map_err(|_| GpsError::ReadError())
+            .unwrap_or_default();
         let nmea_vec: Vec<&str> = nmea_raw.split('$').collect();
 
         // Loop through each sentence and use the information to update GPS data
@@ -49,17 +51,19 @@ impl GpsData {
             if nmea_line.is_empty() {
                 continue;
             }
-            
+
             // Construct string that is in the correct format for parsing
             let mut sentence = "$".to_string();
             sentence.push_str(nmea_line);
-            
+
             let nmea = match nmea_parser.parse_sentence(sentence.as_str()) {
                 Ok(nmea) => nmea,
                 // Don't continue processing a sentence if we know that it isn't supported
-                Err(_) => { continue; }
+                Err(_) => {
+                    continue;
+                }
             };
-            
+
             // print decoded gps data to serial
             match nmea {
                 // TODO: Investigate why the GGA Packets seem to come in mangled
@@ -67,7 +71,7 @@ impl GpsData {
                     // Update Altitude above ground level
                     self.altitude = match gga.altitude {
                         Some(_) => gga.altitude,
-                        None => self.altitude 
+                        None => self.altitude,
                     };
                 }
                 nmea_parser::ParsedMessage::Gll(gll) => {
@@ -88,14 +92,16 @@ impl GpsData {
                             None => {}
                         }
                     }
-                },
+                }
                 nmea_parser::ParsedMessage::Rmc(rms) => {
                     // Update Ground Speed
                     match rms.sog_knots {
-                        Some(_) => self.speed = Some(knots_to_mph(rms.sog_knots.unwrap_or_default())),
+                        Some(_) => {
+                            self.speed = Some(knots_to_mph(rms.sog_knots.unwrap_or_default()))
+                        }
                         None => {}
                     }
-                },
+                }
                 _ => {}
             }
         }
@@ -104,15 +110,12 @@ impl GpsData {
     }
 
     /// Function to get a &str of the current speed reported by the GPS module
-    pub fn get_speed(&self) -> String {
+    pub fn get_speed(&self) -> Option<f64> {
-        match self.speed {  
+        self.speed
-            Some(speed) => format!("{:.2?}mph\n", speed),
-            None => format!("AWAITING\nGPS\nDATA")
-        }
     }
 }
 
 /// Function to simply convert knots to mph
-fn knots_to_mph(knots: f64) -> f64{
+fn knots_to_mph(knots: f64) -> f64 {
     knots * 1.150779
 }

src/gps/mod.rs

@@ -1,4 +1,4 @@
-use esp_idf_hal::{
+use esp_idf_svc::hal::{
     self,
     peripheral::Peripheral,
     gpio::{AnyInputPin, AnyOutputPin, InputPin},

src/main.rs

@@ -1,12 +1,14 @@
 #![allow(unused)]
 
-use esp_idf_hal::{
+use esp_idf_svc::hal::{
     self,
+    gpio::*,
     i2c::{I2cConfig, I2cDriver},
     prelude::Peripherals,
     units::Hertz,
 };
-use esp_idf_sys as _; // If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
+
+use std::sync::atomic::{AtomicBool, Ordering};
 
 mod error;
 use error::Error;
@@ -14,16 +16,16 @@ use error::Error;
 mod appstate;
 
 mod gps;
-use gps::{gpsdata, GPS};
+use gps::{gpsdata::GpsData, GPS};
 
 mod display;
-use display::{Display, DisplayError};
+use display::Display;
 use ssd1306::prelude::*;
 
 fn main() -> Result<(), Error> {
     // It is necessary to call this function once. Otherwise some patches to the runtime
     // implemented by esp-idf-sys might not link properly. See https://github.com/esp-rs/esp-idf-template/issues/71
-    esp_idf_sys::link_patches();
+    esp_idf_svc::sys::link_patches();
     // Bind the log crate to the ESP Logging facilities
     //esp_idf_svc::log::EspLogger::initialize_default();
 
@@ -42,20 +44,41 @@ fn main() -> Result<(), Error> {
     let i2c =
         I2cDriver::new(peripherals.i2c0, sda, scl, &config).map_err(|err| Error::EspError(err))?;
 
+    // Setup GPIO interrupts
+    static FLAG: AtomicBool = AtomicBool::new(false);
+    let mut interrupt_button_handle = PinDriver::input(pins.gpio9).unwrap();
+
+    interrupt_button_handle.set_pull(Pull::Up);
+    interrupt_button_handle.set_interrupt_type(InterruptType::NegEdge);
+    unsafe {
+        interrupt_button_handle.subscribe(app_state_interrupt);
+    }
+    interrupt_button_handle.enable_interrupt();
+
+    // Prepare components for processing
     let mut gps: GPS = GPS::new(peripherals.uart0, gps_rx)?;
     let mut display: Display<DisplaySize128x64> =
         Display::new(i2c, DisplaySize128x64, DisplayRotation::Rotate0)?;
-    let mut app_state = appstate::AppState::default();
+    let mut _app_state = appstate::AppState::default();
+    const NO_DATA: &str = "NO\nGPS\nDATA";
 
     loop {
-        let text: &str;
+        let text: String;
-
         // Get the latest data from GPS module and flush to Display
-        match gps.poll() {
+        text = match gps.poll() {
-            Ok(res) => display.draw(&res.get_speed().as_str())?,
+            Ok(res) => match res.get_speed() {
+                Some(s) => format!("{:.2} MPH", s),
+                None => NO_DATA.to_string(),
+            },
             Err(e) => {
-                display.draw("NO\nGPS\nDATA");
+                eprintln!("{:?}", e);
+                NO_DATA.to_string()
             }
-        }
+        };
+        display.draw(text.as_str())?
     }
 }
+
+fn app_state_interrupt() {
+    println!("inteerrupt");
+}