Struct embedded_hal_compat::Forward

pub struct Forward<T> { /* fields omitted */ }

Forward compatibility container object. This is generic over different E-H types and will provide adaption depending on the bound type.

Implementations

impl<T> Forward<T>

pub fn new(inner: T) -> Forward<T>

Create a new compatibility wrapper object

pub fn inner(&self) -> &T

Fetch a reference to the wrapped object

pub fn inner_mut(&mut self) -> &mut T

Fetch a mutable reference to the wrapped object

pub fn unwrap(self) -> T

Destroy the compatibility wrapper, returning the wrapped object

Trait Implementations

impl<T> DelayMs<u16> for Forward<T> where
    T: DelayMs<u16>, 

type Error = Infallible

Enumeration of DelayMs errors

fn delay_ms(&mut self, ms: u16) -> Result<(), Self::Error>

Pauses execution for ms milliseconds

impl<T> DelayMs<u32> for Forward<T> where
    T: DelayMs<u32>, 

type Error = Infallible

Enumeration of DelayMs errors

fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error>

Pauses execution for ms milliseconds

impl<T> DelayUs<u16> for Forward<T> where
    T: DelayUs<u16>, 

type Error = Infallible

Enumeration of DelayMs errors

fn delay_us(&mut self, us: u16) -> Result<(), Self::Error>

Pauses execution for us microseconds

impl<T> DelayUs<u32> for Forward<T> where
    T: DelayUs<u32>, 

type Error = Infallible

Enumeration of DelayMs errors

fn delay_us(&mut self, us: u32) -> Result<(), Self::Error>

Pauses execution for us microseconds

impl<T, E> InputPin for Forward<T> where
    T: InputPin<Error = E>,
    E: Debug, 

fn is_high(&self) -> Result<bool, Self::Error>

Is the input pin high?

fn is_low(&self) -> Result<bool, Self::Error>

Is the input pin low?

type Error = E

Error type

impl<T, E> OutputPin for Forward<T> where
    T: OutputPin<Error = E>,
    E: Debug, 

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

Set the output as high

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

Set the output as low

type Error = E

Error type

fn set_state(&mut self, state: PinState) -> Result<(), Self::Error>

Drives the pin high or low depending on the provided value

impl<T, E> Read<u8> for Forward<T> where
    T: Read<Error = E>,
    E: Debug, 

type Error = E

Error type

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

Reads enough bytes from slave with address to fill buffer

impl<T, E> Transactional<u8> for Forward<T> where
    T: Write<u8, Error = E> + Transfer<u8, Error = E>,
    E: Debug, 

type Error = E

Associated error type

fn exec<'a>(
    &mut self,
    operations: &mut [Operation<'a, u8>]
) -> Result<(), Self::Error>

Execute the provided transactions

impl<T, E> Transfer<u8> for Forward<T> where
    T: Transfer<u8, Error = E>,
    E: Debug, 

type Error = E

Error type

fn transfer<'a>(&mut self, words: &'a mut [u8]) -> Result<(), Self::Error>

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

impl<T, E> Write<u8> for Forward<T> where
    T: Write<Error = E>,
    E: Debug, 

type Error = E

Error type

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

Writes bytes to slave with address address

impl<T, E> Write<u8> for Forward<T> where
    T: Write<u8, Error = E>,
    E: Debug, 

type Error = E

The type of error that can occur when writing

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

Writes a slice, blocking until everything has been written

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

Block until the serial interface has sent all buffered words

impl<T, E> Write<u8> for Forward<T> where
    T: Write<u8, Error = E>,
    E: Debug, 

type Error = E

Error type

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

Writes words to the slave, ignoring all the incoming words

impl<T, E> WriteIter<u8> for Forward<T> where
    T: WriteIter<Error = E>,
    E: Debug, 

type Error = E

Error type

fn write_iter<B>(
    &mut self,
    address: SevenBitAddress,
    words: B
) -> Result<(), Self::Error> where
    B: IntoIterator<Item = u8>, 

Writes bytes to slave with address address

impl<T, E> WriteIter<u8> for Forward<T> where
    T: WriteIter<u8, Error = E>,
    E: Debug, 

type Error = E

Error type

fn write_iter<WI>(&mut self, words: WI) -> Result<(), Self::Error> where
    WI: IntoIterator<Item = u8>, 

Writes words to the slave, ignoring all the incoming words

impl<T, E> WriteIterRead<u8> for Forward<T> where
    T: WriteIterRead<Error = E>,
    E: Debug, 

type Error = E

Error type

fn write_iter_read<B>(
    &mut self,
    address: SevenBitAddress,
    bytes: B,
    buffer: &mut [u8]
) -> Result<(), Self::Error> where
    B: IntoIterator<Item = u8>, 

Writes bytes to slave with address address and then reads enough bytes to fill buffer in a single transaction

impl<T, E> WriteRead<u8> for Forward<T> where
    T: WriteRead<Error = E>,
    E: Debug, 

type Error = E

Error type

fn write_read(
    &mut self,
    address: SevenBitAddress,
    bytes: &[u8],
    buffer: &mut [u8]
) -> Result<(), Self::Error>

Writes bytes to slave with address address and then reads enough bytes to fill buffer in a single transaction