Struct ExclusiveDevice

pub struct ExclusiveDevice<BUS, CS, D> { /* 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, D> ExclusiveDevice<BUS, CS, D>

pub fn new(bus: BUS, cs: CS, delay: D) -> Result<Self, CS::Error>

where CS: OutputPin,

Create a new ExclusiveDevice.

This sets the cs pin high, and returns an error if that fails. It is recommended to set the pin high the moment it’s configured as an output, to avoid glitches.

pub fn bus(&self) -> &BUS

Returns a reference to the underlying bus object.

pub fn bus_mut(&mut self) -> &mut BUS

Returns a mutable reference to the underlying bus object.

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

pub fn new_no_delay(bus: BUS, cs: CS) -> Result<Self, CS::Error>

where CS: OutputPin,

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

This sets the cs pin high, and returns an error if that fails. It is recommended to set the pin high the moment it’s configured as an output, to avoid glitches.

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<BUS, CS, D> ErrorType for ExclusiveDevice<BUS, CS, D>

where BUS: ErrorType, CS: OutputPin,

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

Error type.

impl<Word: Copy + 'static, BUS, CS, D> SpiDevice<Word> for ExclusiveDevice<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.

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

where BUS: AsyncSpiBus<Word>, CS: OutputPin, D: AsyncDelayNs,

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

Perform a transaction against the device.

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

Do a read within a transaction.

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

Do a write within a transaction.

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

Do a transfer within a transaction.

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

Do an in-place transfer within a transaction.