Struct embassy_embedded_hal::adapter::YieldingAsync

pub struct YieldingAsync<T> { /* private fields */ }

Wrapper that yields for each operation to the wrapped instance

This can be used in combination with BlockingAsync to enforce yields between long running blocking operations.

Implementations

impl<T> YieldingAsync<T>

pub fn new(wrapped: T) -> Self

Create a new instance of a wrapper that yields after each operation.

Trait Implementations

impl<T> ErrorType for YieldingAsync<T>

where T: ErrorType,

type Error = <T as ErrorType>::Error

Error type.

impl<T> ErrorType for YieldingAsync<T>

where T: ErrorType,

type Error = <T as ErrorType>::Error

Error type

impl<T: ErrorType> ErrorType for YieldingAsync<T>

NOR flash implementations

type Error = <T as ErrorType>::Error

Errors returned by this NOR flash.

impl<T> I2c for YieldingAsync<T>

where T: I2c,

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

Reads enough bytes from slave with address to fill buffer.

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

Writes bytes to slave with address address.

async 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.

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

Execute the provided operations on the I2C bus as a single transaction.

impl<T: NorFlash> NorFlash for YieldingAsync<T>

const WRITE_SIZE: usize = T::WRITE_SIZE

The minumum number of bytes the storage peripheral can write

const ERASE_SIZE: usize = T::ERASE_SIZE

The minumum number of bytes the storage peripheral can erase

async fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error>

If power is lost during write, the contents of the written words are undefined, but the rest of the page is guaranteed to be unchanged. It is not allowed to write to the same word twice.

async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error>

Erase the given storage range, clearing all data within [from..to]. The given range will contain all 1s afterwards.

impl<T: ReadNorFlash> ReadNorFlash for YieldingAsync<T>

const READ_SIZE: usize = T::READ_SIZE

The minumum number of bytes the storage peripheral can read

async fn read( &mut self, offset: u32, bytes: &mut [u8] ) -> Result<(), Self::Error>

Read a slice of data from the storage peripheral, starting the read operation at the given address offset, and reading bytes.len() bytes.

fn capacity(&self) -> usize

The capacity of the peripheral in bytes.

impl<T, Word: 'static + Copy> SpiBus<Word> for YieldingAsync<T>

where T: SpiBus<Word>,

async fn flush(&mut self) -> Result<(), Self::Error>

Wait until all operations have completed and the bus is idle.

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

Write words to the slave, ignoring all the incoming words.

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

Read words from the slave.

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

Write and read simultaneously. write is written to the slave on MOSI and words received on MISO are stored in read.

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

Write and read simultaneously. The contents of words are written to the slave, and the received words are stored into the same words buffer, overwriting it.