Struct atsamd_hal::sercom::spi_future::SpiFuture

pub struct SpiFuture<S, B, SS = NoneT, W = fn()>where
    S: CheckBufLen,
    B: AsRef<[u8]> + AsMut<[u8]> + 'static,
    SS: ControlSS,
    W: FnOnce() + 'static,{ /* private fields */ }

A Future-like interface for SPI transactions

See the module-level documentation for more details.

Implementations

impl<S, B> SpiFuture<S, B>where
    S: CheckBufLen,
    B: AsRef<[u8]> + AsMut<[u8]> + 'static,

pub fn new(spi: S, buf: B) -> Self

Create a new SpiFuture with no SS pin or waker

impl<S, B, W> SpiFuture<S, B, NoneT, W>where
    S: CheckBufLen,
    B: AsRef<[u8]> + AsMut<[u8]> + 'static,
    W: FnOnce() + 'static,

pub fn with_ss<SS>(self, pin: SS) -> SpiFuture<S, B, SS, W>where
    SS: SomePin + OutputPin<Error = Infallible>,

Add an SS pin to the SpiFuture

This function changes the SS type, so it must take an owned self.

impl<S, B, SS> SpiFuture<S, B, SS>where
    S: CheckBufLen,
    B: AsRef<[u8]> + AsMut<[u8]> + 'static,
    SS: ControlSS,

pub fn with_waker<W>(self, waker: W) -> SpiFuture<S, B, SS, W>where
    W: FnOnce() + 'static,

Add a waker to the SpiFuture

This function changes the waker type, so it must take an owned self.

impl<S, B, SS, W> SpiFuture<S, B, SS, W>where
    S: CheckBufLen,
    B: AsRef<[u8]> + AsMut<[u8]> + 'static,
    SS: ControlSS,
    W: FnOnce() + 'static,

pub fn start(&mut self)

Start the SpiFuture transaction

This will assert the SS pin, if present, and enable the DRE and RXC interrupts.

pub fn send(&mut self) -> Result<(), Error>

Send the next set of bytes from the buffer

This method should be called from the DRE interrupt handler. Once all bytes of the transaction have been sent, this function will automatically disable the DRE interrupt.

pub fn recv(&mut self) -> Result<(), Error>

Received the next set of bytes and write them to the buffer

This method should be called from the RXC interrupt handler. Once all bytes of the transaction have been received, this function will automatically disable the RXC interrupt, deassert the SS pin (if present), and call the waker (if present).

pub fn poll(&self) -> Poll<&[u8]>

Poll the SpiFuture

This function will return Poll::Pending until all bytes have been received. When the transaction is complete, it will return Poll::Ready with a reference to the completed buffer.

pub fn free(self) -> Result<(S, B, SS), Self>

Consume the SpiFuture and free its components

If the transaction is complete, this function will consume the SpiFuture and return the Spi object, the buffer, and the SS pin, if present.

If the transaction is not complete, it will return Err(self).

pub unsafe fn free_unchecked(self) -> (S, B, SS)

Consume the SpiFuture and free its components without checking for completion

Ending the transaction prematurely could leave the Spi in an inconsistent state. It is not safe to call this function unless the transaction is complete.