[−][src]Crate xca9548a

This is a platform agnostic Rust driver for the TCA9548A and PCA9548A I2C switches/multiplexers, based on the embedded-hal traits.

This driver allows you to:

Enable one or multiple I2C channels. See select_channels().
Communicate with the slaves connected to the enabled channels transparently.
Split the device into slave (virtual) I2C devices (one per channel). See: split().

The devices

The TCA9548A and PCA9548 devices have eight bidirectional translating switches that can be controlled through the I2C bus. The SCL/SDA upstream pair fans out to eight downstream pairs, or channels. Any individual SCn/SDn channel or combination of channels can be selected, determined by the contents of the programmable control register. These downstream channels can be used to resolve I2C slave address conflicts. For example, if eight identical digital temperature sensors are needed in the application, one sensor can be connected at each channel: 0-7.

Datasheets

Usage examples (see also examples folder)

To use this driver, import this crate and an embedded_hal implementation, then instantiate the device.

Please find additional examples using hardware in this repository: driver-examples

Instantiating with the default address

Import this crate and an embedded_hal implementation, then instantiate the device:

extern crate linux_embedded_hal as hal;
extern crate xca9548a;

use hal::I2cdev;
use xca9548a::{Xca9548a, SlaveAddr};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let address = SlaveAddr::default();
let mut i2c_switch = Xca9548a::new(dev, address);

Providing an alternative address

extern crate linux_embedded_hal as hal;
extern crate xca9548a;

use hal::I2cdev;
use xca9548a::{Xca9548a, SlaveAddr};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let (a2, a1, a0) = (false, false, true);
let address = SlaveAddr::Alternative(a2, a1, a0);
let mut i2c_switch = Xca9548a::new(dev, address);

Selecting channel 0 (SD0/SC0 pins)

extern crate linux_embedded_hal as hal;
extern crate xca9548a;

use hal::I2cdev;
use xca9548a::{Xca9548a, SlaveAddr};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let address = SlaveAddr::default();
let mut i2c_switch = Xca9548a::new(dev, address);
i2c_switch.select_channels(0b0000_0001).unwrap();

Reading and writing to device connected to channel 0 (SD0/SC0 pins)

extern crate embedded_hal;
extern crate linux_embedded_hal as hal;
extern crate xca9548a;

use hal::I2cdev;
use embedded_hal::blocking::i2c::{ Read, Write };
use xca9548a::{ Xca9548a, SlaveAddr };

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let address = SlaveAddr::default();
let mut i2c_switch = Xca9548a::new(dev, address);
i2c_switch.select_channels(0b0000_0001).unwrap();

let slave_address = 0b010_0000; // example slave address
let data_for_slave = [0b0101_0101, 0b1010_1010]; // some data to be sent

// Read some data from a slave connected to channel 0 using the
// I2C switch just as a normal I2C device
let mut read_data = [0; 2];
i2c_switch.read(slave_address, &mut read_data).unwrap();

// Write some data to the slave
i2c_switch.write(slave_address, &data_for_slave).unwrap();

Splitting into individual I2C devices and passing them into drivers

Drivers usually take ownership of the I2C device. It does not matter if the slaves have the same address. Switching will be done automatically as necessary.

extern crate embedded_hal;
extern crate linux_embedded_hal as hal;
extern crate xca9548a;

use embedded_hal::blocking::i2c::{Read, Write, WriteRead};
use xca9548a::{Xca9548a, SlaveAddr};

/// Some driver defined in a different crate.
/// Defined here for completeness.
struct Driver<I2C> {
    i2c: I2C,
}

impl<I2C, E> Driver<I2C>
where I2C: Write<Error = E> + Read<Error = E> + WriteRead<Error = E> {
    pub fn new(i2c: I2C) -> Self {
        Driver { i2c }
    }
}

let dev = hal::I2cdev::new("/dev/i2c-1").unwrap();
let address = SlaveAddr::default();
let i2c_switch = Xca9548a::new(dev, address);
let parts = i2c_switch.split();

let my_driver = Driver::new(parts.i2c0);
let my_other_driver = Driver::new(parts.i2c1);

Splitting into individual I2C devices

It does not matter if the slaves have the same address. Switching will be done automatically as necessary.

extern crate embedded_hal;
extern crate linux_embedded_hal as hal;
extern crate xca9548a;

use embedded_hal::blocking::i2c::{ Read, Write };
use xca9548a::{ Xca9548a, SlaveAddr };

let dev = hal::I2cdev::new("/dev/i2c-1").unwrap();
let address = SlaveAddr::default();
let i2c_switch = Xca9548a::new(dev, address);
let mut parts = i2c_switch.split();

let slave_address = 0x20;
let data_for_slave = [0xAB, 0xCD];

// Write some data to the slave using normal I2C interface
parts.i2c0.write(slave_address, &data_for_slave).unwrap();

// Read some data from a slave connected to channel 1
let mut read_data = [0; 2];
parts.i2c1.read(slave_address, &mut read_data).unwrap();

Structs

I2cSlave	Slave I2C device
Parts	Slave I2C devices
Xca9548a	Device driver

Enums

Error	All possible errors in this crate
SlaveAddr	Possible slave addresses