Struct embedded_hal_bus::i2c::RefCellDevice

pub struct RefCellDevice<'a, T> { /* private fields */ }

RefCell-based shared bus I2c implementation.

Sharing is implemented with a RefCell. This means it has low overhead, but RefCellDevice instances are not Send, so it only allows sharing within a single thread (interrupt priority level). If you need to share a bus across several threads, use CriticalSectionDevice instead.

Examples

Assuming there is a pressure sensor with address 0x42 on the same bus as a temperature sensor with address 0x20; RefCellDevice can be used to give access to both of these sensors from a single i2c instance.

use embedded_hal_bus::i2c;
use core::cell::RefCell;

let i2c = hal.i2c();
let i2c_ref_cell = RefCell::new(i2c);
let mut temperature_sensor = TemperatureSensor::new(
  i2c::RefCellDevice::new(&i2c_ref_cell),
  0x20,
);
let mut pressure_sensor = PressureSensor::new(
  i2c::RefCellDevice::new(&i2c_ref_cell),
  0x42,
);

Implementations

impl<'a, T> RefCellDevice<'a, T>

pub fn new(bus: &'a RefCell<T>) -> Self

Create a new RefCellDevice.

Trait Implementations

impl<'a, T> ErrorType for RefCellDevice<'a, T>

where T: I2c,

type Error = <T as ErrorType>::Error

Error type

impl<'a, T> I2c for RefCellDevice<'a, T>

where T: I2c,

fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error>

Reads enough bytes from slave with address to fill read.

fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error>

Writes bytes to slave with address address.

fn write_read( &mut self, address: u8, write: &[u8], read: &mut [u8], ) -> Result<(), Self::Error>

Writes bytes to slave with address address and then reads enough bytes to fill read in a single transaction.

fn transaction( &mut self, address: u8, operations: &mut [Operation<'_>], ) -> Result<(), Self::Error>

Execute the provided operations on the I2C bus.