Shared buses with SetConfig

embassy-embedded-hal/src/shared_bus/blocking/i2c.rs

@@ -7,6 +7,7 @@ use embedded_hal_1::i2c::blocking::{I2c, Operation};
 use embedded_hal_1::i2c::ErrorType;
 
 use crate::shared_bus::i2c::I2cBusDeviceError;
+use crate::SetConfig;
 
 pub struct I2cBusDevice<'a, M: RawMutex, BUS> {
     bus: &'a Mutex<M, RefCell<BUS>>,
@@ -82,3 +83,86 @@ where
         todo!()
     }
 }
+
+pub struct I2cBusDeviceWithConfig<'a, M: RawMutex, BUS, C> {
+    bus: &'a Mutex<M, RefCell<BUS>>,
+    config: C,
+}
+
+impl<'a, M: RawMutex, BUS, C> I2cBusDeviceWithConfig<'a, M, BUS, C> {
+    pub fn new(bus: &'a Mutex<M, RefCell<BUS>>, config: C) -> Self {
+        Self { bus, config }
+    }
+}
+
+impl<'a, M: RawMutex, BUS, C> ErrorType for I2cBusDeviceWithConfig<'a, M, BUS, C>
+where
+    BUS: ErrorType,
+{
+    type Error = I2cBusDeviceError<BUS::Error>;
+}
+
+impl<M, BUS, C> I2c for I2cBusDeviceWithConfig<'_, M, BUS, C>
+where
+    M: RawMutex,
+    BUS: I2c + SetConfig<C>,
+{
+    fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+        self.bus.lock(|bus| {
+            let mut bus = bus.borrow_mut();
+            bus.set_config(&self.config);
+            bus.read(address, buffer).map_err(I2cBusDeviceError::I2c)
+        })
+    }
+
+    fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
+        self.bus.lock(|bus| {
+            let mut bus = bus.borrow_mut();
+            bus.set_config(&self.config);
+            bus.write(address, bytes).map_err(I2cBusDeviceError::I2c)
+        })
+    }
+
+    fn write_read(&mut self, address: u8, wr_buffer: &[u8], rd_buffer: &mut [u8]) -> Result<(), Self::Error> {
+        self.bus.lock(|bus| {
+            let mut bus = bus.borrow_mut();
+            bus.set_config(&self.config);
+            bus.write_read(address, wr_buffer, rd_buffer)
+                .map_err(I2cBusDeviceError::I2c)
+        })
+    }
+
+    fn transaction<'a>(&mut self, address: u8, operations: &mut [Operation<'a>]) -> Result<(), Self::Error> {
+        let _ = address;
+        let _ = operations;
+        todo!()
+    }
+
+    fn write_iter<B: IntoIterator<Item = u8>>(&mut self, addr: u8, bytes: B) -> Result<(), Self::Error> {
+        let _ = addr;
+        let _ = bytes;
+        todo!()
+    }
+
+    fn write_iter_read<B: IntoIterator<Item = u8>>(
+        &mut self,
+        addr: u8,
+        bytes: B,
+        buffer: &mut [u8],
+    ) -> Result<(), Self::Error> {
+        let _ = addr;
+        let _ = bytes;
+        let _ = buffer;
+        todo!()
+    }
+
+    fn transaction_iter<'a, O: IntoIterator<Item = Operation<'a>>>(
+        &mut self,
+        address: u8,
+        operations: O,
+    ) -> Result<(), Self::Error> {
+        let _ = address;
+        let _ = operations;
+        todo!()
+    }
+}