Struct embedded_hal::spi::blocking::ExclusiveDevice

pub struct ExclusiveDevice<BUS, CS> { /* private fields */ }

SpiDevice implementation with exclusive access to the bus (not shared).

This is the most straightforward way of obtaining an SpiDevice from an SpiBus, ideal for when no sharing is required (only one SPI device is present on the bus).

Implementations

impl<BUS, CS> ExclusiveDevice<BUS, CS>

pub fn new(bus: BUS, cs: CS) -> Self

Create a new ExclusiveDevice

Trait Implementations

impl<BUS, CS> ErrorType for ExclusiveDevice<BUS, CS> where
    BUS: ErrorType,
    CS: OutputPin, 

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

Error type

impl<BUS, CS> SpiDevice for ExclusiveDevice<BUS, CS> where
    BUS: SpiBusFlush,
    CS: OutputPin, 

type Bus = BUS

SPI Bus type for this device.

fn transaction<R>(
    &mut self,
    f: impl FnOnce(&mut Self::Bus) -> Result<R, <Self::Bus as ErrorType>::Error>
) -> Result<R, Self::Error>

Perform a transaction against the device.

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

Do a write within a transaction.

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

Do a read within a transaction.

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

Do a transfer within a transaction.

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

Do an in-place transfer within a transaction.