Replace embedded-time with fugit

.gitignore

@@ -7,3 +7,4 @@ target/
 **/*secrets*
 
 Cargo.lock
+.DS_Store

examples/common_lib/Cargo.toml

@@ -15,7 +15,11 @@ name = "common"
 doctest = false
 
 [dependencies]
-serialport = "3.3.0"
-embedded-hal = "0.2.3"
-nb = "0.1.2"
-void = { version = "1.0.2", default-features = false }
+serialport = "4"
+embedded-hal = "^1.0.0-alpha.6"
+nb = "1"
+log = { version = "0.4", default-features = false }
+ublox-cellular-rs = { path = "../../ublox-cellular" }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+linux-embedded-hal = "0.3"

examples/common_lib/src/gpio.rs

@@ -0,0 +1,83 @@
+use embedded_hal::digital::blocking::{InputPin, OutputPin};
+
+#[cfg(target_os = "linux")]
+mod linux {
+    use super::*;
+    use linux_embedded_hal::{sysfs_gpio, Pin};
+
+    // implement newest embedded_hal traits
+    // linux_embedded_hal uses old ones
+    pub struct ExtPin(Pin);
+
+    impl OutputPin for ExtPin {
+        type Error = sysfs_gpio::Error;
+
+        fn set_low(&mut self) -> Result<(), Self::Error> {
+            if self.0.get_active_low()? {
+                self.0.set_value(1)
+            } else {
+                self.0.set_value(0)
+            }
+        }
+
+        fn set_high(&mut self) -> Result<(), Self::Error> {
+            if self.0.get_active_low()? {
+                self.0.set_value(0)
+            } else {
+                self.0.set_value(1)
+            }
+        }
+    }
+
+    impl InputPin for ExtPin {
+        type Error = sysfs_gpio::Error;
+
+        fn is_high(&self) -> Result<bool, Self::Error> {
+            if !self.0.get_active_low()? {
+                self.0.get_value().map(|val| val != 0)
+            } else {
+                self.0.get_value().map(|val| val == 0)
+            }
+        }
+
+        fn is_low(&self) -> Result<bool, Self::Error> {
+            self.is_high().map(|val| !val)
+        }
+    }
+}
+
+#[cfg(not(target_os = "linux"))]
+mod other {
+    use super::*;
+
+    pub struct ExtPin;
+
+    impl OutputPin for ExtPin {
+        type Error = std::convert::Infallible;
+
+        fn set_low(&mut self) -> Result<(), Self::Error> {
+            Ok(())
+        }
+
+        fn set_high(&mut self) -> Result<(), Self::Error> {
+            Ok(())
+        }
+    }
+
+    impl InputPin for ExtPin {
+        type Error = std::convert::Infallible;
+
+        fn is_high(&self) -> Result<bool, Self::Error> {
+            Ok(true)
+        }
+
+        fn is_low(&self) -> Result<bool, Self::Error> {
+            self.is_high().map(|val| !val)
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+pub use linux::ExtPin;
+#[cfg(not(target_os = "linux"))]
+pub use other::ExtPin;

examples/common_lib/src/lib.rs

@@ -1,2 +1,3 @@
+pub mod gpio;
 pub mod serial;
 pub mod timer;

examples/common_lib/src/serial.rs

@@ -5,17 +5,17 @@ use std::io::{ErrorKind as IoErrorKind, Read, Write};
 pub struct Serial(pub Box<dyn serialport::SerialPort>);
 
 /// Helper to convert std::io::Error to the nb::Error
-fn translate_io_errors(err: std::io::Error) -> nb::Error<IoErrorKind> {
+fn translate_io_errors(err: std::io::Error) -> nb::Error<hal::serial::ErrorKind> {
     match err.kind() {
         IoErrorKind::WouldBlock | IoErrorKind::TimedOut | IoErrorKind::Interrupted => {
             nb::Error::WouldBlock
         }
-        err => nb::Error::Other(err),
+        _err => nb::Error::Other(hal::serial::ErrorKind::Other),
     }
 }
 
-impl hal::serial::Read<u8> for Serial {
-    type Error = IoErrorKind;
+impl hal::serial::nb::Read<u8> for Serial {
+    type Error = hal::serial::ErrorKind;
 
     fn read(&mut self) -> nb::Result<u8, Self::Error> {
         let mut buffer = [0; 1];
@@ -28,8 +28,8 @@ impl hal::serial::Read<u8> for Serial {
     }
 }
 
-impl hal::serial::Write<u8> for Serial {
-    type Error = IoErrorKind;
+impl hal::serial::nb::Write<u8> for Serial {
+    type Error = hal::serial::ErrorKind;
 
     fn write(&mut self, word: u8) -> nb::Result<(), Self::Error> {
         self.0.write(&[word]).map_err(translate_io_errors)?;

examples/common_lib/src/timer.rs

@@ -1,41 +1,87 @@
-use embedded_hal::timer::CountDown;
-use std::time::{Duration, Instant};
+use ublox_cellular::fugit;
+use ublox_cellular::prelude::*;
 
-pub struct SysTimer {
-    start: Instant,
-    count: u32,
+pub struct SysTimer<const TIMER_HZ: u32> {
+    description: String,
+    monotonic: std::time::Instant,
+    start: Option<std::time::Instant>,
+    duration: fugit::TimerDurationU32<TIMER_HZ>,
 }
 
-impl SysTimer {
-    pub fn new() -> SysTimer {
-        SysTimer {
-            start: Instant::now(),
-            count: 0,
+impl<const TIMER_HZ: u32> SysTimer<TIMER_HZ> {
+    pub fn new(description: &str) -> Self {
+        Self {
+            description: description.into(),
+            monotonic: std::time::Instant::now(),
+            start: None,
+            duration: fugit::TimerDurationU32::millis(0),
         }
     }
 }
 
-impl CountDown for SysTimer {
-    type Time = u32;
+impl<const TIMER_HZ: u32> Clock<TIMER_HZ> for SysTimer<TIMER_HZ> {
+    type Error = std::convert::Infallible;
 
-    fn start<T>(&mut self, count: T)
-    where
-        T: Into<Self::Time>,
-    {
-        self.start = Instant::now();
-        self.count = count.into();
+    fn now(&mut self) -> fugit::TimerInstantU32<TIMER_HZ> {
+        let millis = self.monotonic.elapsed().as_millis();
+        fugit::TimerInstantU32::from_ticks(millis as u32)
     }
 
-    fn wait(&mut self) -> nb::Result<(), void::Void> {
-        if Instant::now() - self.start > Duration::from_millis(self.count as u64) {
-            Ok(())
+    fn start(&mut self, duration: fugit::TimerDurationU32<TIMER_HZ>) -> Result<(), Self::Error> {
+        self.start = Some(std::time::Instant::now());
+        self.duration = duration.convert();
+        log::debug!(
+            "[{}] start {:?} duration {:?}",
+            self.description,
+            self.start,
+            self.duration
+        );
+        Ok(())
+    }
+
+    fn cancel(&mut self) -> Result<(), Self::Error> {
+        if self.start.is_some() {
+            self.start = None;
+        }
+        Ok(())
+    }
+
+    fn wait(&mut self) -> nb::Result<(), Self::Error> {
+        if let Some(start) = self.start {
+            if std::time::Instant::now() - start
+                > std::time::Duration::from_millis(self.duration.ticks() as u64)
+            {
+                log::debug!(
+                    "[{}] now {:?} start {:?} duration {:?} {:?}",
+                    self.description,
+                    std::time::Instant::now(),
+                    self.start,
+                    self.duration,
+                    std::time::Duration::from_millis(self.duration.ticks() as u64)
+                );
+                Ok(())
+            } else {
+                Err(nb::Error::WouldBlock)
+            }
         } else {
-            Err(nb::Error::WouldBlock)
+            Ok(())
         }
     }
 }
 
-// #[cfg(test)]
-// mod tests {
-//     extern crate nb;
-// }
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use fugit::ExtU32;
+
+    #[test]
+    fn sys_timer() {
+        let now = std::time::Instant::now();
+
+        let mut t: SysTimer<1000> = SysTimer::new("");
+        t.start(1.secs()).unwrap();
+        nb::block!(t.wait()).unwrap();
+
+        assert!(now.elapsed().as_millis() >= 1000);
+    }
+}