Struct Handle

pub struct Handle { /* private fields */ }

An MCP device that has been opened. Supports I2C and GPIO operations.

Implementations

impl Handle

pub fn open_first(config: &Config) -> Result<Self>

A shortcut that just opens the first supported device that we can find.

Examples found in repository

examples/scan_bus.rs (line 21)

fn run() -> mcp2221::Result<()> {
    let mut config = mcp2221::Config::default();
    config.i2c_speed_hz = 400_000;
    // For talking to a peripheral we might want a higher timeout, but for
    // scanning the bus, a short timeout is good since it allows us to scan all
    // addresses more quickly.
    config.timeout = Duration::from_millis(10);
    let mut dev = mcp2221::Handle::open_first(&config)?;

    // Set GPIO pin 0 high. This is useful if your I2C bus goes through a level
    // shifter and you need to enable that level shifter in order to use the I2C
    // bus. It also serves as an example of using GPIO.
    let mut gpio_config = mcp2221::GpioConfig::default();
    gpio_config.set_direction(0, mcp2221::Direction::Output);
    gpio_config.set_value(0, true);
    dev.configure_gpio(&gpio_config)?;

    // Before we start, SDA and SCL should be high. If they're not, then either
    // the pull-up resistors are missing, the bus isn't properly connected or
    // something on the bus is holding them low. In any case, we won't be able
    // to operate.
    dev.check_bus()?;

    println!("{}", dev.get_device_info()?);

    for base_address in (0..=127).step_by(16) {
        for offset in 0..=15 {
            let address = base_address + offset;
            match dev.read(address, &mut [0u8]) {
                Ok(_) => print!("0x{:02x}", address),
                Err(_) => print!(" -- "),
            }
        }
        println!();
    }

    Ok(())
}

pub fn check_bus(&mut self) -> Result<()>

Can be called on startup to check that the bus is idle. Returns an error if either SCL or SDA is being held low by something on the bus.

Examples found in repository

examples/scan_bus.rs (line 35)

fn run() -> mcp2221::Result<()> {
    let mut config = mcp2221::Config::default();
    config.i2c_speed_hz = 400_000;
    // For talking to a peripheral we might want a higher timeout, but for
    // scanning the bus, a short timeout is good since it allows us to scan all
    // addresses more quickly.
    config.timeout = Duration::from_millis(10);
    let mut dev = mcp2221::Handle::open_first(&config)?;

    // Set GPIO pin 0 high. This is useful if your I2C bus goes through a level
    // shifter and you need to enable that level shifter in order to use the I2C
    // bus. It also serves as an example of using GPIO.
    let mut gpio_config = mcp2221::GpioConfig::default();
    gpio_config.set_direction(0, mcp2221::Direction::Output);
    gpio_config.set_value(0, true);
    dev.configure_gpio(&gpio_config)?;

    // Before we start, SDA and SCL should be high. If they're not, then either
    // the pull-up resistors are missing, the bus isn't properly connected or
    // something on the bus is holding them low. In any case, we won't be able
    // to operate.
    dev.check_bus()?;

    println!("{}", dev.get_device_info()?);

    for base_address in (0..=127).step_by(16) {
        for offset in 0..=15 {
            let address = base_address + offset;
            match dev.read(address, &mut [0u8]) {
                Ok(_) => print!("0x{:02x}", address),
                Err(_) => print!(" -- "),
            }
        }
        println!();
    }

    Ok(())
}

pub fn scl_is_high(&mut self) -> Result<bool>

pub fn sda_is_high(&mut self) -> Result<bool>

pub fn write_read_address( &mut self, device_address: u8, to_write: &[u8], to_read: &mut [u8], ) -> Result<()>

Sends START to device_address, then writes to_write. If to_read is non-empty, sends START again, then reads into to_read. Finally sends STOP.

pub fn configure_gpio(&mut self, commands: &GpioConfig) -> Result<()>

Examples found in repository

examples/scan_bus.rs (line 29)

fn run() -> mcp2221::Result<()> {
    let mut config = mcp2221::Config::default();
    config.i2c_speed_hz = 400_000;
    // For talking to a peripheral we might want a higher timeout, but for
    // scanning the bus, a short timeout is good since it allows us to scan all
    // addresses more quickly.
    config.timeout = Duration::from_millis(10);
    let mut dev = mcp2221::Handle::open_first(&config)?;

    // Set GPIO pin 0 high. This is useful if your I2C bus goes through a level
    // shifter and you need to enable that level shifter in order to use the I2C
    // bus. It also serves as an example of using GPIO.
    let mut gpio_config = mcp2221::GpioConfig::default();
    gpio_config.set_direction(0, mcp2221::Direction::Output);
    gpio_config.set_value(0, true);
    dev.configure_gpio(&gpio_config)?;

    // Before we start, SDA and SCL should be high. If they're not, then either
    // the pull-up resistors are missing, the bus isn't properly connected or
    // something on the bus is holding them low. In any case, we won't be able
    // to operate.
    dev.check_bus()?;

    println!("{}", dev.get_device_info()?);

    for base_address in (0..=127).step_by(16) {
        for offset in 0..=15 {
            let address = base_address + offset;
            match dev.read(address, &mut [0u8]) {
                Ok(_) => print!("0x{:02x}", address),
                Err(_) => print!(" -- "),
            }
        }
        println!();
    }

    Ok(())
}

pub fn get_gpio_config(&mut self) -> Result<GpioConfig>

pub fn get_pin_values(&mut self) -> Result<PinValues>

pub fn get_device_info(&mut self) -> Result<DeviceInfo>

Returns information about the device.

Examples found in repository

examples/scan_bus.rs (line 37)

fn run() -> mcp2221::Result<()> {
    let mut config = mcp2221::Config::default();
    config.i2c_speed_hz = 400_000;
    // For talking to a peripheral we might want a higher timeout, but for
    // scanning the bus, a short timeout is good since it allows us to scan all
    // addresses more quickly.
    config.timeout = Duration::from_millis(10);
    let mut dev = mcp2221::Handle::open_first(&config)?;

    // Set GPIO pin 0 high. This is useful if your I2C bus goes through a level
    // shifter and you need to enable that level shifter in order to use the I2C
    // bus. It also serves as an example of using GPIO.
    let mut gpio_config = mcp2221::GpioConfig::default();
    gpio_config.set_direction(0, mcp2221::Direction::Output);
    gpio_config.set_value(0, true);
    dev.configure_gpio(&gpio_config)?;

    // Before we start, SDA and SCL should be high. If they're not, then either
    // the pull-up resistors are missing, the bus isn't properly connected or
    // something on the bus is holding them low. In any case, we won't be able
    // to operate.
    dev.check_bus()?;

    println!("{}", dev.get_device_info()?);

    for base_address in (0..=127).step_by(16) {
        for offset in 0..=15 {
            let address = base_address + offset;
            match dev.read(address, &mut [0u8]) {
                Ok(_) => print!("0x{:02x}", address),
                Err(_) => print!(" -- "),
            }
        }
        println!();
    }

    Ok(())
}

Trait Implementations

impl Read for Handle

type Error = Error

Error type

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

Reads enough bytes from slave with address to fill buffer

impl Write for Handle

type Error = Error

Error type

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

Writes bytes to slave with address address

impl WriteRead for Handle

type Error = Error

Error type

fn write_read( &mut self, address: u8, bytes: &[u8], buffer: &mut [u8], ) -> Result<(), Self::Error>

Writes bytes to slave with address address and then reads enough bytes to fill buffer in a single transaction