Initial power-policy integration tests

Author: RobertZ2011

Cargo.lock

@@ -17,6 +17,7 @@ pub mod buffer;
 pub mod cfu;
 pub mod comms;
 pub mod ec_type;
+pub mod event;
 pub mod fmt;
 pub mod hid;
 pub mod init;

embedded-service/src/lib.rs

@@ -2,7 +2,8 @@
 use embassy_sync::mutex::Mutex;
 
 use super::{DeviceId, Error};
-use crate::power::policy::policy::EventReceiver;
+use crate::event::Receiver;
+use crate::power::policy::policy::RequestData;
 use crate::power::policy::{ConsumerPowerCapability, ProviderPowerCapability};
 use crate::sync::Lockable;
 use crate::{GlobalRawMutex, intrusive_list};
@@ -117,10 +118,12 @@ pub trait DeviceTrait {
     fn connect_provider(&mut self, capability: ProviderPowerCapability) -> impl Future<Output = Result<(), Error>>;
     /// Connect this device to consume power from an external connection
     fn connect_consumer(&mut self, capability: ConsumerPowerCapability) -> impl Future<Output = Result<(), Error>>;
+    /// Device is out of sync with the policy, reset and renotify power policy
+    fn reset(&mut self) -> impl Future<Output = Result<(), Error>>;
 }
 
 /// Device struct
-pub struct Device<'a, C: Lockable, R: EventReceiver>
+pub struct Device<'a, C: Lockable, R: Receiver<RequestData>>
 where
     C::Inner: DeviceTrait,
 {
@@ -133,15 +136,15 @@ where
     /// Reference to hardware
     pub device: &'a C,
     /// Event receiver
-    pub receiver: &'a R,
+    pub receiver: Mutex<GlobalRawMutex, R>,
 }
 
-impl<'a, C: Lockable, R: EventReceiver> Device<'a, C, R>
+impl<'a, C: Lockable, R: Receiver<RequestData>> Device<'a, C, R>
 where
     C::Inner: DeviceTrait,
 {
     /// Create a new device
-    pub fn new(id: DeviceId, device: &'a C, receiver: &'a R) -> Self {
+    pub fn new(id: DeviceId, device: &'a C, receiver: R) -> Self {
         Self {
             node: intrusive_list::Node::uninit(),
             id,
@@ -151,7 +154,7 @@ where
                 requested_provider_capability: None,
             }),
             device,
-            receiver,
+            receiver: Mutex::new(receiver),
         }
     }
 
@@ -194,7 +197,7 @@ where
     }
 }
 
-impl<C: Lockable, R: EventReceiver> intrusive_list::NodeContainer for Device<'static, C, R>
+impl<C: Lockable, R: Receiver<RequestData> + 'static> intrusive_list::NodeContainer for Device<'static, C, R>
 where
     C::Inner: DeviceTrait,
 {
@@ -204,15 +207,15 @@ where
 }
 
 /// Trait for any container that holds a device
-pub trait DeviceContainer<C: Lockable, R: EventReceiver>
+pub trait DeviceContainer<C: Lockable, R: Receiver<RequestData>>
 where
     C::Inner: DeviceTrait,
 {
     /// Get the underlying device struct
     fn get_power_policy_device(&self) -> &Device<'_, C, R>;
 }
 
-impl<C: Lockable, R: EventReceiver> DeviceContainer<C, R> for Device<'_, C, R>
+impl<C: Lockable, R: Receiver<RequestData>> DeviceContainer<C, R> for Device<'_, C, R>
 where
     C::Inner: DeviceTrait,
 {

embedded-service/src/power/policy/device.rs

@@ -4,6 +4,7 @@ use core::pin::pin;
 use core::sync::atomic::{AtomicBool, Ordering};
 
 use crate::broadcaster::immediate as broadcaster;
+use crate::event::{self, Receiver};
 use crate::power::policy::device::DeviceTrait;
 use crate::power::policy::{CommsMessage, ConsumerPowerCapability, ProviderPowerCapability};
 use crate::sync::Lockable;
@@ -70,12 +71,7 @@ pub struct Response {
 }
 
 /// Trait used by devices to send events to a power policy implementation
-pub trait EventSender {
-    /// Try to send an event
-    fn try_send(&mut self, event: RequestData) -> Option<()>;
-    /// Send an event
-    fn send(&mut self, event: RequestData) -> impl Future<Output = ()>;
-
+pub trait Sender: event::Sender<RequestData> {
     /// Wrapper to simplify sending this event
     fn on_attach(&mut self) -> impl Future<Output = ()> {
         self.send(RequestData::Attached)
@@ -122,13 +118,7 @@ pub trait EventSender {
     }
 }
 
-/// Receiver trait used by a policy implementation
-pub trait EventReceiver {
-    /// Attempt to get a pending event
-    fn try_next(&self) -> Option<RequestData>;
-    /// Wait for the next event
-    fn wait_next(&self) -> impl Future<Output = RequestData>;
-}
+impl<T> Sender for T where T: event::Sender<RequestData> {}
 
 /// Power policy context
 struct Context {
@@ -158,7 +148,7 @@ pub fn init() {
 }
 
 /// Register a device with the power policy service
-pub async fn register_device<C: Lockable + 'static, R: EventReceiver + 'static>(
+pub async fn register_device<C: Lockable + 'static, R: Receiver<RequestData> + 'static>(
     device: &'static impl device::DeviceContainer<C, R>,
 ) -> Result<(), intrusive_list::Error>
 where
@@ -183,7 +173,7 @@ pub async fn register_charger(device: &'static impl charger::ChargerContainer) -
 }
 
 /// Find a device by its ID
-async fn get_device<C: Lockable + 'static, R: EventReceiver + 'static>(
+async fn get_device<C: Lockable + 'static, R: Receiver<RequestData> + 'static>(
     id: DeviceId,
 ) -> Option<&'static device::Device<'static, C, R>>
 where
@@ -249,14 +239,14 @@ pub async fn register_message_receiver(
 }
 
 /// Singleton struct to give access to the power policy context
-pub struct ContextToken<D: Lockable, R: EventReceiver>
+pub struct ContextToken<D: Lockable, R: Receiver<RequestData>>
 where
     D::Inner: DeviceTrait,
 {
     _phantom: PhantomData<(D, R)>,
 }
 
-impl<D: Lockable + 'static, R: EventReceiver + 'static> ContextToken<D, R>
+impl<D: Lockable + 'static, R: Receiver<RequestData> + 'static> ContextToken<D, R>
 where
     D::Inner: DeviceTrait,
 {
@@ -311,7 +301,7 @@ where
         let mut futures = heapless::Vec::<_, 16>::new();
         for device in self.devices().await.iter_only::<device::Device<'static, D, R>>() {
             // TODO: check this at compile time
-            let _ = futures.push(async { device.receiver.wait_next().await });
+            let _ = futures.push(async { device.receiver.lock().await.wait_next().await });
         }
 
         let (event, index) = select_slice(pin!(&mut futures)).await;

embedded-service/src/power/policy/policy.rs

@@ -19,6 +19,14 @@ embassy-time.workspace = true
 embedded-services.workspace = true
 log = { workspace = true, optional = true }
 
+[dev-dependencies]
+static_cell.workspace = true
+critical-section = { workspace = true, features = ["std"] }
+embassy-time = { workspace = true, features = ["std", "generic-queue-8"] }
+tokio = { workspace = true, features = ["rt", "macros", "time"] }
+env_logger = "0.9.0"
+log = { workspace = true }
+
 [features]
 default = []
 defmt = [

power-policy-service/Cargo.toml

@@ -35,7 +35,7 @@ fn cmp_consumer_capability(
     ))
 }
 
-impl<D: Lockable + 'static, R: EventReceiver + 'static> PowerPolicy<D, R>
+impl<D: Lockable + 'static, R: Receiver<RequestData> + 'static> PowerPolicy<D, R>
 where
     D::Inner: DeviceTrait,
 {
@@ -194,10 +194,13 @@ where
 
             state.current_consumer_state = None;
             let consumer_device = self.context.get_device(current_consumer.device_id).await?;
-            // Disconnect the current consumer if needed
-            info!("Device{}: Disconnecting current consumer", current_consumer.device_id.0);
-            // disconnect current consumer and set idle
-            consumer_device.device.lock().await.disconnect().await?;
+            if matches!(consumer_device.state().await, State::ConnectedConsumer(_)) {
+                // Disconnect the current consumer if needed
+                info!("Device{}: Disconnecting current consumer", current_consumer.device_id.0);
+                // disconnect current consumer and set idle
+                consumer_device.device.lock().await.disconnect().await?;
+                consumer_device.state.lock().await.state = State::Idle;
+            }
 
             // If no chargers are registered, they won't receive the new power capability.
             // Also, if chargers return UnpoweredAck, that means the charger isn't powered.
@@ -224,6 +227,7 @@ where
                 .await
                 .connect_consumer(new_consumer.consumer_power_capability)
                 .await?;
+            device.state.lock().await.state = State::ConnectedConsumer(new_consumer.consumer_power_capability);
             self.post_consumer_connected(state, new_consumer).await?;
             Ok(())
         } else {