Struct embedded_hal_bus::spi::RefCellDevice

pub struct RefCellDevice<'a, BUS, CS, D> { /* private fields */ }

RefCell-based shared bus SpiDevice implementation.

This allows for sharing an SpiBus, obtaining multiple SpiDevice instances, each with its own CS pin.

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.

Implementations

impl<'a, BUS, CS, D> RefCellDevice<'a, BUS, CS, D>

pub fn new(bus: &'a RefCell<BUS>, cs: CS, delay: D) -> Self

Create a new RefCellDevice.

impl<'a, BUS, CS> RefCellDevice<'a, BUS, CS, NoDelay>

pub fn new_no_delay(bus: &'a RefCell<BUS>, cs: CS) -> Self

Create a new RefCellDevice without support for in-transaction delays.

Warning: The returned instance technically doesn’t comply with the SpiDevice contract, which mandates delay support. It is relatively rare for drivers to use in-transaction delays, so you might still want to use this method because it’s more practical.

Note that a future version of the driver might start using delays, causing your code to panic. This wouldn’t be considered a breaking change from the driver side, because drivers are allowed to assume SpiDevice implementations comply with the contract. If you feel this risk outweighs the convenience of having cargo automatically upgrade the driver crate, you might want to pin the driver’s version.

Panics

The returned device will panic if you try to execute a transaction that contains any operations of type Operation::DelayNs.

Trait Implementations

impl<'a, BUS, CS, D> ErrorType for RefCellDevice<'a, BUS, CS, D>

where BUS: ErrorType, CS: OutputPin,

type Error = DeviceError<<BUS as ErrorType>::Error, <CS as ErrorType>::Error>

Error type.

impl<'a, Word: Copy + 'static, BUS, CS, D> SpiDevice<Word> for RefCellDevice<'a, BUS, CS, D>

where BUS: SpiBus<Word>, CS: OutputPin, D: DelayNs,

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

Perform a transaction against the device.

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

Do a read within a transaction.

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

Do a write within a transaction.

fn transfer( &mut self, read: &mut [Word], write: &[Word] ) -> Result<(), Self::Error>

Do a transfer within a transaction.

fn transfer_in_place(&mut self, buf: &mut [Word]) -> Result<(), Self::Error>

Do an in-place transfer within a transaction.