Struct embedded_hal_compat::Compat

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

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

Implementations

impl<T> Compat<T>

pub fn new(inner: T) -> Compat<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 Compat<T> where
    T: DelayMs<u16>, 

type Error = Infallible

Enumeration of DelayMs errors

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

Pauses execution for ms milliseconds

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

type Error = Infallible

Enumeration of DelayMs errors

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

Pauses execution for ms milliseconds

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

type Error = Infallible

Enumeration of DelayMs errors

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

Pauses execution for us microseconds

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

type Error = Infallible

Enumeration of DelayMs errors

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

Pauses execution for us microseconds

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

type Error = E

Error type

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

Is the input pin high?

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

Is the input pin low?

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

type Error = E

Error type

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

Set the output as high

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

Set the output as low

pub fn try_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 Compat<T> where
    T: Read<Error = E>, 

type Error = E

Error type

fn try_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 Compat<T> where
    T: Write<u8, Error = E> + Transfer<u8, Error = E>, 

type Error = E

Associated error type

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

Execute the provided transactions

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

type Error = E

Error type

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

Sends words to the slave. Returns the words received from the slave

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

type Error = E

Error type

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

Sends bytes to slave with address address

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

type Error = E

The type of error that can occur when writing

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

Writes a slice, blocking until everything has been written

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

Block until the serial interface has sent all buffered words

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

type Error = E

Error type

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

Sends words to the slave, ignoring all the incoming words

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

type Error = E

Error type

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

Sends bytes to slave with address address

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

type Error = E

Error type

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

Sends words to the slave, ignoring all the incoming words

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

type Error = E

Error type

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

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

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

type Error = E

Error type

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

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