Struct embedded_hal_compat::Reverse

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

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

Implementations

impl<T> Reverse<T>

pub fn new(inner: T) -> Reverse<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, E> DelayMs<u16> for Reverse<T> where
    T: DelayMs<u16, Error = E>,
    E: Debug, 

fn delay_ms(&mut self, ms: u16)

Pauses execution for ms milliseconds

impl<T, E> DelayMs<u32> for Reverse<T> where
    T: DelayMs<u32, Error = E>,
    E: Debug, 

fn delay_ms(&mut self, ms: u32)

Pauses execution for ms milliseconds

impl<T, E> DelayUs<u16> for Reverse<T> where
    T: DelayUs<u16, Error = E>,
    E: Debug, 

fn delay_us(&mut self, us: u16)

Pauses execution for us microseconds

impl<T, E> DelayUs<u32> for Reverse<T> where
    T: DelayUs<u32, Error = E>,
    E: Debug, 

fn delay_us(&mut self, us: u32)

Pauses execution for us microseconds

impl<T, E> InputPin for Reverse<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 Reverse<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 Reverse<T> where
    T: Read<SevenBitAddress, 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> Transfer<u8> for Reverse<T> where
    T: Transfer<u8, Error = E>,
    E: Debug, 

type Error = E

Error type

fn 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 Reverse<T> where
    T: Write<SevenBitAddress, 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 Reverse<T> where
    T: Write<u8, Error = E>,
    E: Debug, 

type Error = E

The type of error that can occur when writing

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

Writes a slice, blocking until everything has been written

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

Block until the serial interface has sent all buffered words

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

type Error = E

Error type

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

Sends words to the slave, ignoring all the incoming words

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

type Error = E

Error type

fn write<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 Reverse<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>, 

Sends words to the slave, ignoring all the incoming words

impl<T, E> WriteIterRead<u8> for Reverse<T> where
    T: WriteIterRead<SevenBitAddress, 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 Reverse<T> where
    T: WriteRead<SevenBitAddress, 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