Struct embedded_hal_spy::Spy

pub struct Spy<T, F> where
    F: Fn(DataWord),  { /* fields omitted */ }

embedded hal spy implemnets call backs for used traits

Intended use is chaining over an existing embedded_hal implementation sniffing all the data. Useful when preparing for a refacforing and want to collect actual data for unit test case.

Blocking SPI API hal::blocking::spi::Transfer will return DataWord::First at start of transfer, all data sent in DataWord::Byte(u8) DataWord::Response to indicate where transmit ends and response begins all recived bytes in DataWord::Byte(u8) ending with DataWord::Last

Usage:

   extern crate embedded_hal_spy;
   use embedded_hal_spy::DataWord;

   let mut spix = embedded_hal_spy::new(spi,
            |w|{
                match w {
                    DataWord::First => {
                        print!("data = [");
                    },
                    DataWord::Last =>  {println!("],"); },
                    DataWord::Response =>  { print!("],\r\n       ["); },

                    DataWord::Byte(num) => {
                        print!("{:x},",num);
                        },
                    _other => {},
                }
            }
     );

Trait Implementations

impl<T, F> Transfer<u8> for Spy<T, F> where
    T: Transfer<u8>,
    F: Fn(DataWord), 

type Error = T::Error

Error type

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

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

impl<T, F> Write<u8> for Spy<T, F> where
    T: Write<u8>,
    F: Fn(DataWord), 

Blocking write

type Error = T::Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<T, F> OutputPin for Spy<T, F> where
    T: OutputPin,
    F: Fn(DataWord), 

Digital OutputPin

type Error = T::Error

Error type

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

Drives the pin high

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

Drives the pin low

impl<T, F> StatefulOutputPin for Spy<T, F> where
    T: StatefulOutputPin,
    F: Fn(DataWord), 

fn is_set_high(&self) -> Result<bool, T::Error>

Is the pin in drive high mode?

fn is_set_low(&self) -> Result<bool, T::Error>

Is the pin in drive low mode?

impl<T, F> ToggleableOutputPin for Spy<T, F> where
    T: ToggleableOutputPin,
    F: Fn(DataWord), 

type Error = T::Error

Error type

fn toggle(&mut self) -> Result<(), T::Error>

Toggle pin output.

impl<T, F> InputPin for Spy<T, F> where
    T: InputPin,
    F: Fn(DataWord), 

Digital InputPin

type Error = T::Error

Error type

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?

impl<T, F> FullDuplex<u8> for Spy<T, F> where
    T: FullDuplex<u8>,
    F: Fn(DataWord), 

FullDuplex will return every data sent and read in DataWord::Byte(u8)

type Error = T::Error

An enumeration of SPI errors

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

Reads the word stored in the shift register

fn send(&mut self, w: u8) -> Result<(), Error<Self::Error>>

Sends a word to the slave