Add set function blocking version consolidate with test (#41)

douglascgh · Copilot · web-flow · commit 230c581050e6 · 2026-01-28T11:12:56.000-08:00
Certain functionalities are only defined as async traits and not
available in blocking. Expanding the relevant function so the macro also
generates blocking version so it can be adopted to an environment where
async support is not available such as driver running in Zephyr. The
macro that generates async function has been expanded to also generate
blocking function for traits that is relevant for both blocking and
async.

The patch also expands the current set to cover the newly added blocking
traits.

---------

Co-authored-by: Copilot &lt;175728472+Copilot@users.noreply.github.com&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/embedded-sensors-async/Cargo.toml b/embedded-sensors-async/Cargo.toml
@@ -9,7 +9,7 @@ license = "MIT"
 name = "embedded-sensors-hal-async"
 readme = "README.md"
 repository = "https://github.com/OpenDevicePartnership/embedded-sensors"
-version = "0.3.0"
+version = "0.4.0"
 
 [features]
 defmt = ["dep:defmt", "embedded-sensors-hal/defmt"]
diff --git a/embedded-sensors-async/src/humidity.rs b/embedded-sensors-async/src/humidity.rs
@@ -82,8 +82,7 @@
 //! }
 //! ```
 
-use crate::decl_threshold_traits;
-use crate::sensor::ErrorType;
+use crate::sensor::{decl_threshold_traits, ErrorType};
 pub use embedded_sensors_hal::humidity::Percentage;
 
 /// Async Relative Humidity Sensor methods.
@@ -99,7 +98,22 @@ impl<T: RelativeHumiditySensor + ?Sized> RelativeHumiditySensor for &mut T {
     }
 }
 
+// This macro generates the following async threshold traits:
+//
+// pub trait RelativeHumidityThresholdSet: RelativeHumiditySensor {
+//     async fn set_relative_humidity_threshold_low(&mut self, threshold: Percentage) -> Result<(), Self::Error>;
+//     async fn set_relative_humidity_threshold_high(&mut self, threshold: Percentage) -> Result<(), Self::Error>;
+// }
+//
+// pub trait RelativeHumidityHysteresis: RelativeHumidityThresholdSet {
+//     async fn set_relative_humidity_threshold_hysteresis(&mut self, hysteresis: Percentage) -> Result<(), Self::Error>;
+// }
+//
+// pub trait RelativeHumidityThresholdWait: RelativeHumidityThresholdSet {
+//     async fn wait_for_relative_humidity_threshold(&mut self) -> Result<Percentage, Self::Error>;
+// }
 decl_threshold_traits!(
+    async,
     RelativeHumidity,
     RelativeHumiditySensor,
     Percentage,
diff --git a/embedded-sensors-async/src/sensor.rs b/embedded-sensors-async/src/sensor.rs
@@ -2,59 +2,11 @@
 //!
 //! This module contains traits generic to all sensors.
 //!
-//! Please see specific sensor-type modules for addtional example usage
+//! Please see specific sensor-type modules for additional example usage
 //! (e.g. see temperature.rs for TemperatureSensor examples).
 
 pub use embedded_sensors_hal::sensor::{Error, ErrorKind, ErrorType};
 
-/// Generates threshold traits for the specified sensor type.
-#[macro_export]
-macro_rules! decl_threshold_traits {
-    ($SensorName:ident, $SensorTrait:ident, $SampleType:ty, $unit:expr) => {
-        paste::paste! {
-            #[doc = concat!(" Asynchronously set ", stringify!($SensorName), " thresholds.")]
-            pub trait [<$SensorName ThresholdSet>]: $SensorTrait {
-                #[doc = concat!(" Set lower ", stringify!($SensorName), " threshold (in ", $unit, ").")]
-                async fn [<set_ $SensorName:snake _threshold_low>](&mut self, threshold: $SampleType) -> Result<(), Self::Error>;
-
-                #[doc = concat!(" Set upper ", stringify!($SensorName), " threshold (in ", $unit, ").")]
-                async fn [<set_ $SensorName:snake _threshold_high>](&mut self, threshold: $SampleType) -> Result<(), Self::Error>;
-            }
-
-            #[doc = concat!(" Asynchronously wait for ", stringify!($SensorName), " measurements to exceed specified thresholds.")]
-            pub trait [<$SensorName ThresholdWait>]: [<$SensorName ThresholdSet>] {
-                #[doc = concat!(" Wait for ", stringify!($SensorName), " to be measured above or below the previously set high and low thresholds.")]
-                #[doc = concat!(" Returns the measured ", stringify!($SensorName), " at time threshold is exceeded (in ", $unit, ").")]
-                async fn [<wait_for_ $SensorName:snake _threshold>](&mut self) -> Result<$SampleType, Self::Error>;
-            }
-
-            #[doc = concat!(" Asynchronously set ", stringify!($SensorName), " threshold hysteresis.")]
-            pub trait [<$SensorName Hysteresis>]: [<$SensorName ThresholdSet>] {
-                #[doc = concat!(" Set ", stringify!($SensorName), " threshold hysteresis (in ", $unit, ").")]
-                async fn [<set_ $SensorName:snake _threshold_hysteresis>](&mut self, hysteresis: $SampleType) -> Result<(), Self::Error>;
-            }
-
-            impl<T: [<$SensorName ThresholdSet>] + ?Sized> [<$SensorName ThresholdSet>] for &mut T {
-                async fn [<set_ $SensorName:snake _threshold_low>](&mut self, threshold: $SampleType) -> Result<(), Self::Error> {
-                    T::[<set_ $SensorName:snake _threshold_low>](self, threshold).await
-                }
-
-                async fn [<set_ $SensorName:snake _threshold_high>](&mut self, threshold: $SampleType) -> Result<(), Self::Error> {
-                    T::[<set_ $SensorName:snake _threshold_high>](self, threshold).await
-                }
-            }
-
-            impl<T: [<$SensorName ThresholdWait>] + ?Sized> [<$SensorName ThresholdWait>] for &mut T {
-                async fn [<wait_for_ $SensorName:snake _threshold>](&mut self) -> Result<$SampleType, Self::Error> {
-                    T::[<wait_for_ $SensorName:snake _threshold>](self).await
-                }
-            }
-
-            impl<T: [<$SensorName Hysteresis>] + ?Sized> [<$SensorName Hysteresis>] for &mut T {
-                async fn [<set_ $SensorName:snake _threshold_hysteresis>](&mut self, hysteresis: $SampleType) -> Result<(), Self::Error> {
-                    T::[<set_ $SensorName:snake _threshold_hysteresis>](self, hysteresis).await
-                }
-            }
-        }
-    };
-}
+// Re-export the unified threshold traits macro from the blocking crate.
+// The async crate uses the `async` mode to generate async versions of the traits.
+pub use embedded_sensors_hal::decl_threshold_traits;
diff --git a/embedded-sensors-async/src/temperature.rs b/embedded-sensors-async/src/temperature.rs
@@ -81,8 +81,7 @@
 //! }
 //! ```
 
-use crate::decl_threshold_traits;
-use crate::sensor::ErrorType;
+use crate::sensor::{decl_threshold_traits, ErrorType};
 pub use embedded_sensors_hal::temperature::DegreesCelsius;
 
 /// Async Temperature Sensor methods.
@@ -98,7 +97,22 @@ impl<T: TemperatureSensor + ?Sized> TemperatureSensor for &mut T {
     }
 }
 
+// This macro generates the following async threshold traits:
+//
+// pub trait TemperatureThresholdSet: TemperatureSensor {
+//     async fn set_temperature_threshold_low(&mut self, threshold: DegreesCelsius) -> Result<(), Self::Error>;
+//     async fn set_temperature_threshold_high(&mut self, threshold: DegreesCelsius) -> Result<(), Self::Error>;
+// }
+//
+// pub trait TemperatureHysteresis: TemperatureThresholdSet {
+//     async fn set_temperature_threshold_hysteresis(&mut self, hysteresis: DegreesCelsius) -> Result<(), Self::Error>;
+// }
+//
+// pub trait TemperatureThresholdWait: TemperatureThresholdSet {
+//     async fn wait_for_temperature_threshold(&mut self) -> Result<DegreesCelsius, Self::Error>;
+// }
 decl_threshold_traits!(
+    async,
     Temperature,
     TemperatureSensor,
     DegreesCelsius,
diff --git a/embedded-sensors/Cargo.toml b/embedded-sensors/Cargo.toml
@@ -9,13 +9,14 @@ license = "MIT"
 name = "embedded-sensors-hal"
 readme = "README.md"
 repository = "https://github.com/OpenDevicePartnership/embedded-sensors"
-version = "0.1.0"
+version = "0.1.1"
 
 [features]
 defmt = ["dep:defmt"]
 
 [dependencies]
 defmt = { package = "defmt", version = "1.0.0", optional = true }
+paste = "1.0.15"
 
 [dev-dependencies]
 assert_approx_eq = "1.1.0"
diff --git a/embedded-sensors/src/humidity.rs b/embedded-sensors/src/humidity.rs
@@ -40,6 +40,7 @@
 //! }
 //! ```
 
+use crate::decl_threshold_traits;
 use crate::sensor::ErrorType;
 
 /// Associates the units relative humidity (RH) samples are measured in with the underlying data type.
@@ -58,6 +59,24 @@ impl<T: RelativeHumiditySensor + ?Sized> RelativeHumiditySensor for &mut T {
     }
 }
 
+// This macro generates the following blocking threshold traits:
+//
+// pub trait RelativeHumidityThresholdSet: RelativeHumiditySensor {
+//     fn set_relative_humidity_threshold_low(&mut self, threshold: Percentage) -> Result<(), Self::Error>;
+//     fn set_relative_humidity_threshold_high(&mut self, threshold: Percentage) -> Result<(), Self::Error>;
+// }
+//
+// pub trait RelativeHumidityHysteresis: RelativeHumidityThresholdSet {
+//     fn set_relative_humidity_threshold_hysteresis(&mut self, hysteresis: Percentage) -> Result<(), Self::Error>;
+// }
+decl_threshold_traits!(
+    blocking,
+    RelativeHumidity,
+    RelativeHumiditySensor,
+    Percentage,
+    "percentage"
+);
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -78,6 +97,9 @@ mod tests {
 
     struct MockHumiditySensor {
         value: Percentage,
+        threshold_low: Option<Percentage>,
+        threshold_high: Option<Percentage>,
+        hysteresis: Option<Percentage>,
     }
 
     impl crate::sensor::ErrorType for MockHumiditySensor {
@@ -90,10 +112,41 @@ mod tests {
         }
     }
 
+    impl RelativeHumidityThresholdSet for MockHumiditySensor {
+        fn set_relative_humidity_threshold_low(
+            &mut self,
+            threshold: Percentage,
+        ) -> Result<(), Self::Error> {
+            self.threshold_low = Some(threshold);
+            Ok(())
+        }
+
+        fn set_relative_humidity_threshold_high(
+            &mut self,
+            threshold: Percentage,
+        ) -> Result<(), Self::Error> {
+            self.threshold_high = Some(threshold);
+            Ok(())
+        }
+    }
+
+    impl RelativeHumidityHysteresis for MockHumiditySensor {
+        fn set_relative_humidity_threshold_hysteresis(
+            &mut self,
+            hysteresis: Percentage,
+        ) -> Result<(), Self::Error> {
+            self.hysteresis = Some(hysteresis);
+            Ok(())
+        }
+    }
+
     #[test]
     fn test_humidity_sensor_trait() {
         let mut sensor = MockHumiditySensor {
             value: TEST_HUMIDITY,
+            threshold_low: None,
+            threshold_high: None,
+            hysteresis: None,
         };
         let result = sensor.relative_humidity();
         assert!(result.is_ok());
@@ -104,11 +157,93 @@ mod tests {
     fn test_humidity_sensor_trait_mut_ref() {
         let mut sensor = MockHumiditySensor {
             value: TEST_HUMIDITY,
+            threshold_low: None,
+            threshold_high: None,
+            hysteresis: None,
         };
         let mut_ref = &mut sensor;
         let result = mut_ref.relative_humidity();
         assert!(result.is_ok());
         let value = result.unwrap();
         assert_approx_eq!(value, TEST_HUMIDITY);
     }
+
+    #[test]
+    fn test_humidity_threshold_set_low() {
+        let mut sensor = MockHumiditySensor {
+            value: TEST_HUMIDITY,
+            threshold_low: None,
+            threshold_high: None,
+            hysteresis: None,
+        };
+        let threshold = 50.0;
+        let result = sensor.set_relative_humidity_threshold_low(threshold);
+        assert!(result.is_ok());
+        assert_approx_eq!(sensor.threshold_low.unwrap(), threshold);
+    }
+
+    #[test]
+    fn test_humidity_threshold_set_high() {
+        let mut sensor = MockHumiditySensor {
+            value: TEST_HUMIDITY,
+            threshold_low: None,
+            threshold_high: None,
+            hysteresis: None,
+        };
+        let threshold = 80.0;
+        let result = sensor.set_relative_humidity_threshold_high(threshold);
+        assert!(result.is_ok());
+        assert_approx_eq!(sensor.threshold_high.unwrap(), threshold);
+    }
+
+    #[test]
+    fn test_humidity_threshold_set_mut_ref() {
+        let mut sensor = MockHumiditySensor {
+            value: TEST_HUMIDITY,
+            threshold_low: None,
+            threshold_high: None,
+            hysteresis: None,
+        };
+        let mut_ref = &mut sensor;
+        let low_threshold = 40.0;
+        let high_threshold = 90.0;
+
+        let result_low = mut_ref.set_relative_humidity_threshold_low(low_threshold);
+        assert!(result_low.is_ok());
+
+        let result_high = mut_ref.set_relative_humidity_threshold_high(high_threshold);
+        assert!(result_high.is_ok());
+
+        assert_approx_eq!(sensor.threshold_low.unwrap(), low_threshold);
+        assert_approx_eq!(sensor.threshold_high.unwrap(), high_threshold);
+    }
+
+    #[test]
+    fn test_humidity_hysteresis() {
+        let mut sensor = MockHumiditySensor {
+            value: TEST_HUMIDITY,
+            threshold_low: None,
+            threshold_high: None,
+            hysteresis: None,
+        };
+        let hyst = 5.0;
+        let result = sensor.set_relative_humidity_threshold_hysteresis(hyst);
+        assert!(result.is_ok());
+        assert_approx_eq!(sensor.hysteresis.unwrap(), hyst);
+    }
+
+    #[test]
+    fn test_humidity_hysteresis_mut_ref() {
+        let mut sensor = MockHumiditySensor {
+            value: TEST_HUMIDITY,
+            threshold_low: None,
+            threshold_high: None,
+            hysteresis: None,
+        };
+        let mut_ref = &mut sensor;
+        let hyst = 3.0;
+        let result = mut_ref.set_relative_humidity_threshold_hysteresis(hyst);
+        assert!(result.is_ok());
+        assert_approx_eq!(sensor.hysteresis.unwrap(), hyst);
+    }
 }
diff --git a/embedded-sensors/src/sensor.rs b/embedded-sensors/src/sensor.rs
diff --git a/embedded-sensors/src/temperature.rs b/embedded-sensors/src/temperature.rs
