embedded-hal-compat 0.13.0

Compatibility layer for interoperability between different embedded-hal versions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use embedded_hal_compat::ReverseCompat;

#[derive(Debug)]
enum ImplError {
    _Something,
}

impl eh1_0::spi::Error for ImplError {
    fn kind(&self) -> eh1_0::spi::ErrorKind {
        eh1_0::spi::ErrorKind::Other
    }
}

struct Peripheral;

impl eh1_0::spi::ErrorType for Peripheral {
    type Error = ImplError;
}

impl eh1_0::spi::SpiBus for Peripheral {
    fn read(&mut self, _words: &mut [u8]) -> Result<(), Self::Error> {
        Ok(())
    }
    fn write(&mut self, _words: &[u8]) -> Result<(), Self::Error> {
        Ok(())
    }
    fn transfer(&mut self, _read: &mut [u8], _write: &[u8]) -> Result<(), Self::Error> {
        Ok(())
    }
    fn transfer_in_place(&mut self, _words: &mut [u8]) -> Result<(), Self::Error> {
        Ok(())
    }
    fn flush(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}

#[test]
fn can_reverse() {
    let data = [];
    let periph_1_0 = Peripheral;
    let mut periph_0_2 = periph_1_0.reverse();
    assert!(eh0_2::blocking::spi::Write::write(&mut periph_0_2, &[]).is_ok());
    assert!(eh0_2::blocking::spi::Transfer::transfer(&mut periph_0_2, &mut []).is_ok());
    assert!(eh0_2::blocking::spi::WriteIter::write_iter(&mut periph_0_2, data).is_ok());
    assert!(eh0_2::spi::FullDuplex::send(&mut periph_0_2, 0).is_ok());
    assert_eq!(eh0_2::spi::FullDuplex::read(&mut periph_0_2).unwrap(), 0);
}

#[cfg(feature = "alloc")]
#[test]
fn can_perform_trasaction_reverse() {
    let mut read0 = [2; 3];
    let mut read1 = [4; 3];
    let periph_1_0 = Peripheral;
    let mut periph_0_2 = periph_1_0.reverse();

    let mut ops = [
        eh0_2::blocking::spi::Operation::Write(&[1; 5]),
        eh0_2::blocking::spi::Operation::Transfer(&mut read0),
        eh0_2::blocking::spi::Operation::Write(&[3; 7]),
        eh0_2::blocking::spi::Operation::Transfer(&mut read1),
    ];

    assert!(eh0_2::blocking::spi::Transactional::exec(&mut periph_0_2, &mut ops).is_ok());

    if let eh0_2::blocking::spi::Operation::Write(buf) = ops[0] {
        assert_eq!(buf, [1; 5]);
    } else {
        panic!();
    }
    if let eh0_2::blocking::spi::Operation::Transfer(ref buf) = ops[1] {
        assert_eq!(*buf, [2; 3]);
    } else {
        panic!();
    }
    if let eh0_2::blocking::spi::Operation::Write(buf) = ops[2] {
        assert_eq!(buf, [3; 7]);
    } else {
        panic!();
    }
    if let eh0_2::blocking::spi::Operation::Transfer(ref buf) = ops[3] {
        assert_eq!(*buf, [4; 3]);
    } else {
        panic!();
    }
}