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
88
89
90
91
92
93
94
95
96
97

use embedded_hal_compat::ForwardCompat;

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

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

struct Peripheral;

impl eh0_2::blocking::i2c::Write for Peripheral {
    type Error = ImplError;
    fn write(&mut self, _address: u8, _bytes: &[u8]) -> Result<(), Self::Error> {
        Ok(())
    }
}

impl eh0_2::blocking::i2c::Read for Peripheral {
    type Error = ImplError;
    fn read(&mut self, _address: u8, _buffer: &mut [u8]) -> Result<(), Self::Error> {
        Ok(())
    }
}

impl eh0_2::blocking::i2c::WriteRead for Peripheral {
    type Error = ImplError;
    fn write_read(
        &mut self,
        _address: u8,
        _bytes: &[u8],
        _buffer: &mut [u8],
    ) -> Result<(), Self::Error> {
        Ok(())
    }
}

impl eh0_2::blocking::i2c::WriteIter for Peripheral {
    type Error = ImplError;
    fn write<B>(&mut self, _address: u8, _bytes: B) -> Result<(), Self::Error>
    where
        B: IntoIterator<Item = u8>,
    {
        Ok(())
    }
}

impl eh0_2::blocking::i2c::WriteIterRead for Peripheral {
    type Error = ImplError;
    fn write_iter_read<B>(
        &mut self,
        _address: u8,
        _bytes: B,
        _buffer: &mut [u8],
    ) -> Result<(), Self::Error>
    where
        B: IntoIterator<Item = u8>,
    {
        Ok(())
    }
}

impl eh0_2::blocking::i2c::Transactional for Peripheral {
    type Error = ImplError;
    fn exec(
        &mut self,
        _address: u8,
        _operations: &mut [eh0_2::blocking::i2c::Operation],
    ) -> Result<(), Self::Error> {
        Ok(())
    }
}

impl eh0_2::blocking::i2c::TransactionalIter for Peripheral {
    type Error = ImplError;
    fn exec_iter<'a, O>(&mut self, _address: u8, _operations: O) -> Result<(), Self::Error>
    where
        O: IntoIterator<Item = eh0_2::blocking::i2c::Operation<'a>>,
    {
        Ok(())
    }
}

#[test]
fn can_forward() {
    let mut data = [];
    let periph_0_2 = Peripheral;
    let mut periph_1_0 = periph_0_2.forward();
    assert!(eh1_0::i2c::I2c::write(&mut periph_1_0, 0, &[]).is_ok());
    assert!(eh1_0::i2c::I2c::write_read(&mut periph_1_0, 0, &[], &mut data).is_ok());
    assert!(eh1_0::i2c::I2c::read(&mut periph_1_0, 0, &mut data).is_ok());
    assert!(eh1_0::i2c::I2c::transaction(&mut periph_1_0, 0, &mut []).is_ok());
}