Add Rc<RefCell<T>>-based implementation of shared I2c buses

Author: adri326

embedded-hal-bus/Cargo.toml

@@ -20,6 +20,8 @@ async = ["dep:embedded-hal-async"]
 defmt-03 = ["dep:defmt-03", "embedded-hal/defmt-03", "embedded-hal-async?/defmt-03"]
 # Enables additional utilities requiring a global allocator.
 alloc = []
+# TODO: remove this
+default = ["alloc"]
 
 [dependencies]
 embedded-hal = { version = "1.0.0", path = "../embedded-hal" }

embedded-hal-bus/src/i2c/mod.rs

@@ -10,3 +10,8 @@ mod critical_section;
 pub use self::critical_section::*;
 mod atomic;
 pub use atomic::*;
+
+#[cfg(feature = "alloc")]
+mod rc;
+#[cfg(feature = "alloc")]
+pub use rc::*;

embedded-hal-bus/src/i2c/rc.rs

@@ -0,0 +1,75 @@
+extern crate alloc;
+use alloc::rc::Rc;
+
+use core::cell::RefCell;
+use embedded_hal::i2c::{ErrorType, I2c};
+
+/// `Rc<RefCell<T>>`-based shared bus [`I2c`] implementation.
+/// This is the reference-counting equivalent of [`RefCellDevice`](super::RefCellDevice).
+///
+/// Sharing is implemented with a [`RefCell`] and ownership is managed by [`Rc`].
+/// Like [`RefCellDevice`](super::RefCellDevice), `RcDevice` instances are not [`Send`],
+/// so they can only be shared within a single thread (interrupt priority level).
+///
+/// When this `RcDevice` is dropped, the reference count of the I2C bus will be decremented.
+/// Once that reference count hits zero, it will be cleaned up.
+#[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
+pub struct RcDevice<Bus> {
+    bus: Rc<RefCell<Bus>>,
+}
+
+impl<Bus> RcDevice<Bus> {
+    /// Creates a new `RcDevice`.
+    ///
+    /// This function does not increment the reference count for the bus:
+    /// you will need to call `Rc::clone(&bus)` if you only have a `&Rc<RefCell<Bus>>`.
+    #[inline]
+    pub fn new(bus: Rc<RefCell<Bus>>) -> Self {
+        Self { bus }
+    }
+}
+
+impl<Bus> ErrorType for RcDevice<Bus>
+where
+    Bus: ErrorType,
+{
+    type Error = Bus::Error;
+}
+
+impl<Bus> I2c for RcDevice<Bus>
+where
+    Bus: I2c,
+{
+    #[inline]
+    fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
+        let bus = &mut *self.bus.borrow_mut();
+        bus.read(address, read)
+    }
+
+    #[inline]
+    fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+        let bus = &mut *self.bus.borrow_mut();
+        bus.write(address, write)
+    }
+
+    #[inline]
+    fn write_read(
+        &mut self,
+        address: u8,
+        write: &[u8],
+        read: &mut [u8],
+    ) -> Result<(), Self::Error> {
+        let bus = &mut *self.bus.borrow_mut();
+        bus.write_read(address, write, read)
+    }
+
+    #[inline]
+    fn transaction(
+        &mut self,
+        address: u8,
+        operations: &mut [embedded_hal::i2c::Operation<'_>],
+    ) -> Result<(), Self::Error> {
+        let bus = &mut *self.bus.borrow_mut();
+        bus.transaction(address, operations)
+    }
+}