Remove the impls for no longer existing traits

Author: ivmarkov

src/ping.rs

@@ -3,14 +3,62 @@ use core::{ffi, mem, ptr, time::Duration};
 
 use ::log::*;
 
-use embedded_svc::ping::Ping;
-
 use crate::ipv4;
 use crate::private::common::*;
 use crate::private::waitable::*;
 use crate::sys::*;
 
-pub use embedded_svc::ping::{Configuration, Info, Reply, Summary};
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "use_serde", derive(Serialize, Deserialize))]
+pub struct Configuration {
+    pub count: u32,
+    pub interval: Duration,
+    pub timeout: Duration,
+    pub data_size: u32,
+    pub tos: u8,
+}
+
+impl Default for Configuration {
+    fn default() -> Self {
+        Configuration {
+            count: 5,
+            interval: Duration::from_secs(1),
+            timeout: Duration::from_secs(1),
+            data_size: 56,
+            tos: 0,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "use_serde", derive(Serialize, Deserialize))]
+pub struct Info {
+    #[cfg_attr(feature = "defmt", defmt(Debug2Format))]
+    pub addr: ipv4::Ipv4Addr,
+    pub seqno: u32,
+    pub ttl: u8,
+    pub elapsed_time: Duration,
+    pub recv_len: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "use_serde", derive(Serialize, Deserialize))]
+pub enum Reply {
+    Timeout,
+    Success(Info),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "use_serde", derive(Serialize, Deserialize))]
+pub struct Summary {
+    pub transmitted: u32,
+    pub received: u32,
+    pub time: Duration,
+}
 
 #[derive(Debug, Default)]
 pub struct EspPing(u32);
@@ -289,23 +337,6 @@ impl EspPing {
     }
 }
 
-impl Ping for EspPing {
-    type Error = EspError;
-
-    fn ping(&mut self, ip: ipv4::Ipv4Addr, conf: &Configuration) -> Result<Summary, Self::Error> {
-        EspPing::ping(self, ip, conf)
-    }
-
-    fn ping_details<F: FnMut(&Summary, &Reply) + Send>(
-        &mut self,
-        ip: ipv4::Ipv4Addr,
-        conf: &Configuration,
-        reply_callback: F,
-    ) -> Result<Summary, Self::Error> {
-        EspPing::ping_details(self, ip, conf, reply_callback)
-    }
-}
-
 struct Tracker<F: FnMut(&Summary, &Reply) + Send> {
     summary: Summary,
     waitable: Waitable<bool>,

src/systime.rs

@@ -1,8 +1,6 @@
 //! System time
 use core::time::Duration;
 
-use embedded_svc::sys_time::SystemTime;
-
 use crate::sys::*;
 
 /// Client for the ESP system time
@@ -20,9 +18,3 @@ impl EspSystemTime {
         Duration::from_micros(tv_now.tv_sec as u64 * 1000000_u64 + tv_now.tv_usec as u64)
     }
 }
-
-impl SystemTime for EspSystemTime {
-    fn now(&self) -> Duration {
-        EspSystemTime::now(self)
-    }
-}

src/timer.rs

@@ -18,9 +18,6 @@ extern crate alloc;
 use alloc::boxed::Box;
 use alloc::sync::Arc;
 
-use embedded_svc::sys_time::SystemTime;
-use embedded_svc::timer::{self, asynch, ErrorType, OnceTimer, PeriodicTimer, Timer, TimerService};
-
 use esp_idf_hal::task::asynch::Notification;
 
 use crate::sys::*;
@@ -135,32 +132,6 @@ impl<'a> RawHandle for EspTimer<'a> {
     }
 }
 
-impl<'a> ErrorType for EspTimer<'a> {
-    type Error = EspError;
-}
-
-impl<'a> timer::Timer for EspTimer<'a> {
-    fn is_scheduled(&self) -> Result<bool, Self::Error> {
-        EspTimer::is_scheduled(self)
-    }
-
-    fn cancel(&mut self) -> Result<bool, Self::Error> {
-        EspTimer::cancel(self)
-    }
-}
-
-impl<'a> OnceTimer for EspTimer<'a> {
-    fn after(&mut self, duration: Duration) -> Result<(), Self::Error> {
-        EspTimer::after(self, duration)
-    }
-}
-
-impl<'a> PeriodicTimer for EspTimer<'a> {
-    fn every(&mut self, duration: Duration) -> Result<(), Self::Error> {
-        EspTimer::every(self, duration)
-    }
-}
-
 pub struct EspAsyncTimer {
     timer: EspTimer<'static>,
     notification: Arc<Notification>,
@@ -192,30 +163,6 @@ impl EspAsyncTimer {
     }
 }
 
-impl ErrorType for EspAsyncTimer {
-    type Error = EspError;
-}
-
-impl asynch::OnceTimer for EspAsyncTimer {
-    async fn after(&mut self, duration: Duration) -> Result<(), Self::Error> {
-        EspAsyncTimer::after(self, duration).await
-    }
-}
-
-impl asynch::PeriodicTimer for EspAsyncTimer {
-    type Clock<'a> = &'a mut Self where Self: 'a;
-
-    fn every(&mut self, duration: Duration) -> Result<Self::Clock<'_>, Self::Error> {
-        EspAsyncTimer::every(self, duration)
-    }
-}
-
-impl<'a> asynch::Clock for &'a mut EspAsyncTimer {
-    async fn tick(&mut self) {
-        EspAsyncTimer::tick(self).await
-    }
-}
-
 impl embedded_hal_async::delay::DelayNs for EspAsyncTimer {
     async fn delay_ns(&mut self, ns: u32) {
         EspAsyncTimer::after(self, Duration::from_micros(ns as _))
@@ -369,47 +316,6 @@ where
     }
 }
 
-impl<T> ErrorType for EspTimerService<T>
-where
-    T: EspTimerServiceType,
-{
-    type Error = EspError;
-}
-
-impl<T> TimerService for EspTimerService<T>
-where
-    T: EspTimerServiceType,
-{
-    type Timer<'a> = EspTimer<'static> where Self: 'a;
-
-    fn timer<F>(&self, callback: F) -> Result<Self::Timer<'_>, Self::Error>
-    where
-        F: FnMut() + Send + 'static,
-    {
-        EspTimerService::timer(self, callback)
-    }
-}
-
-impl<T> SystemTime for EspTimerService<T>
-where
-    T: EspTimerServiceType,
-{
-    fn now(&self) -> Duration {
-        EspTimerService::now(self)
-    }
-}
-
-impl<T> asynch::TimerService for EspTimerService<T>
-where
-    T: EspTimerServiceType,
-{
-    type Timer<'a> = EspAsyncTimer where Self: 'a;
-
-    async fn timer(&self) -> Result<Self::Timer<'_>, Self::Error> {
-        EspTimerService::timer_async(self)
-    }
-}
-
 #[cfg(esp_idf_esp_timer_supports_isr_dispatch_method)]
 mod isr {
     use crate::sys::EspError;