xca9548a 0.2.0

Platform-agnostic Rust driver for the TCA9548A and PCA9548A I2C switches/multiplexers.
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

extern crate embedded_hal;
extern crate embedded_hal_mock as hal;
use hal::i2c::{Mock as I2cMock, Transaction as I2cTrans};
extern crate xca9548a;
use xca9548a::{SlaveAddr, Xca9548a};

const DEV_ADDR: u8 = 0b111_0000;

fn new(transactions: &[I2cTrans]) -> Xca9548a<I2cMock> {
    Xca9548a::new(I2cMock::new(&transactions), SlaveAddr::default())
}

use embedded_hal::prelude::*;
const SLAVE_ADDR: u8 = 0b010_0000;
const SLAVE_WRITE_DATA: [u8; 2] = [0b0101_0101, 0b1010_1010];
const SLAVE_READ_DATA: [u8; 2] = [0b1001_1001, 0b0110_0110];

#[test]
fn can_select_channels() {
    let transactions = [I2cTrans::write(DEV_ADDR, vec![0x01])];
    let mut switch = new(&transactions);
    switch.select_channels(0x01).unwrap();
    switch.destroy().done();
}

#[test]
fn can_get_channel_status() {
    let transactions = [I2cTrans::read(DEV_ADDR, vec![0b0101_0101])];
    let mut switch = new(&transactions);
    let read_status = switch.get_channel_status().unwrap();
    assert_eq!(0b0101_0101, read_status);
    switch.destroy().done();
}

#[test]
fn can_write_to_slave() {
    let transactions = [
        I2cTrans::write(DEV_ADDR, vec![0x01]),
        I2cTrans::write(SLAVE_ADDR, SLAVE_WRITE_DATA.to_vec()),
    ];
    let mut switch = new(&transactions);
    switch.select_channels(0b0000_0001).unwrap();
    switch.write(SLAVE_ADDR, &SLAVE_WRITE_DATA).unwrap();
    switch.destroy().done();
}

#[test]
fn can_read_from_slave() {
    let transactions = [
        I2cTrans::write(DEV_ADDR, vec![0x01]),
        I2cTrans::read(SLAVE_ADDR, SLAVE_READ_DATA.to_vec()),
    ];
    let mut switch = new(&transactions);
    switch.select_channels(0b0000_0001).unwrap();

    let mut read_data = [0; 2];
    switch.read(SLAVE_ADDR, &mut read_data).unwrap();
    assert_eq!(read_data, SLAVE_READ_DATA);
    switch.destroy().done();
}
#[test]
fn can_write_read_from_slave() {
    let transactions = [
        I2cTrans::write(DEV_ADDR, vec![0x01]),
        I2cTrans::write_read(
            SLAVE_ADDR,
            SLAVE_WRITE_DATA.to_vec(),
            SLAVE_READ_DATA.to_vec(),
        ),
    ];
    let mut switch = new(&transactions);
    switch.select_channels(0b0000_0001).unwrap();

    let mut read_data = [0; 2];
    switch
        .write_read(SLAVE_ADDR, &SLAVE_WRITE_DATA, &mut read_data)
        .unwrap();
    assert_eq!(read_data, SLAVE_READ_DATA);
    switch.destroy().done();
}

#[test]
fn can_split_and_communicate_with_slave() {
    let slave_read_data_2 = [0xAB, 0xCD];
    let transactions = [
        I2cTrans::write(DEV_ADDR, vec![0x01]),
        I2cTrans::write(SLAVE_ADDR, SLAVE_WRITE_DATA.to_vec()),
        I2cTrans::write(DEV_ADDR, vec![0x02]),
        I2cTrans::read(SLAVE_ADDR, SLAVE_READ_DATA.to_vec()),
        I2cTrans::write(DEV_ADDR, vec![0x04]),
        I2cTrans::write_read(
            SLAVE_ADDR,
            SLAVE_WRITE_DATA.to_vec(),
            slave_read_data_2.to_vec(),
        ),
    ];
    let switch = new(&transactions);
    {
        let mut read_data_1 = [0; 2];
        let mut read_data_2 = [0; 2];
        let mut parts = switch.split();
        parts.i2c0.write(SLAVE_ADDR, &SLAVE_WRITE_DATA).unwrap();
        parts.i2c1.read(SLAVE_ADDR, &mut read_data_1).unwrap();
        parts
            .i2c2
            .write_read(SLAVE_ADDR, &SLAVE_WRITE_DATA, &mut read_data_2)
            .unwrap();
        assert_eq!(read_data_1, SLAVE_READ_DATA);
        assert_eq!(read_data_2, slave_read_data_2);
    }
    switch.destroy().done();
}

#[test]
fn when_split_only_change_channel_if_necessary() {
    let transactions = [
        I2cTrans::write(DEV_ADDR, vec![0x01]),
        I2cTrans::write(SLAVE_ADDR, SLAVE_WRITE_DATA.to_vec()),
        I2cTrans::read(SLAVE_ADDR, SLAVE_READ_DATA.to_vec()),
    ];
    let switch = new(&transactions);
    {
        let mut read_data = [0; 2];
        let mut parts = switch.split();
        parts.i2c0.write(SLAVE_ADDR, &SLAVE_WRITE_DATA).unwrap();
        parts.i2c0.read(SLAVE_ADDR, &mut read_data).unwrap();
        assert_eq!(read_data, SLAVE_READ_DATA);
    }
    switch.destroy().done();
}