Struct I2c

pub struct I2c<'d, Dm: DriverMode> { /* private fields */ }

I2C driver

I2C initialization and communication with the device

let mut i2c = I2c::new(
    peripherals.I2C0,
    Config::default(),
)?
.with_sda(peripherals.GPIO1)
.with_scl(peripherals.GPIO2);

let mut data = [0u8; 22];
i2c.write_read(DEVICE_ADDR, &[0xaa], &mut data)?;

Implementations

impl<'d, Dm> I2c<'d, Dm>

where Dm: DriverMode,

pub fn apply_config(&mut self, config: &Config) -> Result<(), ConfigError>

Applies a new configuration.

Errors

A ConfigError variant will be returned if bus frequency or timeout passed in config is invalid.

pub fn with_sda( self, sda: impl Peripheral<P = impl PeripheralOutput> + 'd, ) -> Self

Connect a pin to the I2C SDA signal.

This will replace previous pin assignments for this signal.

pub fn with_scl( self, scl: impl Peripheral<P = impl PeripheralOutput> + 'd, ) -> Self

Connect a pin to the I2C SCL signal.

This will replace previous pin assignments for this signal.

pub fn write<A: Into<I2cAddress>>( &mut self, address: A, buffer: &[u8], ) -> Result<(), Error>

Writes bytes to slave with address address

i2c.write(DEVICE_ADDR, &[0xaa])?;

pub fn read<A: Into<I2cAddress>>( &mut self, address: A, buffer: &mut [u8], ) -> Result<(), Error>

Reads enough bytes from slave with address to fill buffer

let mut data = [0u8; 22];
i2c.read(DEVICE_ADDR, &mut data)?;

Errors

The corresponding error variant from Error will be returned if the passed buffer has zero length.

pub fn write_read<A: Into<I2cAddress>>( &mut self, address: A, write_buffer: &[u8], read_buffer: &mut [u8], ) -> Result<(), Error>

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

let mut data = [0u8; 22];
i2c.write_read(DEVICE_ADDR, &[0xaa], &mut data)?;

Errors

The corresponding error variant from Error will be returned if the passed buffer has zero length.

pub fn transaction<'a, A: Into<I2cAddress>>( &mut self, address: A, operations: impl IntoIterator<Item = &'a mut Operation<'a>>, ) -> Result<(), Error>

Execute the provided operations on the I2C bus.

Transaction contract:

• Before executing the first operation an ST is sent automatically. This is followed by SAD+R/W as appropriate.

• Data from adjacent operations of the same type are sent after each other without an SP or SR.

• Between adjacent operations of a different type an SR and SAD+R/W is sent.

• After executing the last operation an SP is sent automatically.

• If the last operation is a Read the master does not send an acknowledge for the last byte.

• ST = start condition

• SAD+R/W = slave address followed by bit 1 to indicate reading or 0 to indicate writing

• SR = repeated start condition

• SP = stop condition

let mut data = [0u8; 22];
i2c.transaction(
    DEVICE_ADDR,
    &mut [Operation::Write(&[0xaa]), Operation::Read(&mut data)]
)?;

Errors

The corresponding error variant from Error will be returned if the buffer passed to an Operation has zero length.

impl<'d> I2c<'d, Blocking>

pub fn new( i2c: impl Peripheral<P = impl Instance> + 'd, config: Config, ) -> Result<Self, ConfigError>

Create a new I2C instance.

Errors

A ConfigError variant will be returned if bus frequency or timeout passed in config is invalid.

pub fn set_interrupt_handler(&mut self, handler: InterruptHandler)

Available on crate feature unstable only.

Registers an interrupt handler for the peripheral.

Note that this will replace any previously registered interrupt handlers.

You can restore the default/unhandled interrupt handler by using [crate::DEFAULT_INTERRUPT_HANDLER]

Panics

Panics if passed interrupt handler is invalid (e.g. has priority None)

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn listen(&mut self, interrupts: impl Into<EnumSet<Event>>)

Available on crate feature unstable only.

Listen for the given interrupts

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn unlisten(&mut self, interrupts: impl Into<EnumSet<Event>>)

Available on crate feature unstable only.

Unlisten the given interrupts

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn interrupts(&mut self) -> EnumSet<Event>

Available on crate feature unstable only.

Gets asserted interrupts

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn clear_interrupts(&mut self, interrupts: EnumSet<Event>)

Available on crate feature unstable only.

Resets asserted interrupts

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn into_async(self) -> I2c<'d, Async>

Configures the I2C peripheral to operate in asynchronous mode.

impl<'d> I2c<'d, Async>

pub fn into_blocking(self) -> I2c<'d, Blocking>

Configure the I2C peripheral to operate in blocking mode.

pub async fn write_async<A: Into<I2cAddress>>( &mut self, address: A, buffer: &[u8], ) -> Result<(), Error>

Writes bytes to slave with address address

pub async fn read_async<A: Into<I2cAddress>>( &mut self, address: A, buffer: &mut [u8], ) -> Result<(), Error>

Reads enough bytes from slave with address to fill buffer

Errors

The corresponding error variant from Error will be returned if the passed buffer has zero length.

pub async fn write_read_async<A: Into<I2cAddress>>( &mut self, address: A, write_buffer: &[u8], read_buffer: &mut [u8], ) -> Result<(), Error>

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

Errors

The corresponding error variant from Error will be returned if the passed buffer has zero length.

pub async fn transaction_async<'a, A: Into<I2cAddress>>( &mut self, address: A, operations: impl IntoIterator<Item = &'a mut Operation<'a>>, ) -> Result<(), Error>

Execute the provided operations on the I2C bus as a single transaction.

Transaction contract:

• Before executing the first operation an ST is sent automatically. This is followed by SAD+R/W as appropriate.

• Data from adjacent operations of the same type are sent after each other without an SP or SR.

• Between adjacent operations of a different type an SR and SAD+R/W is sent.

• After executing the last operation an SP is sent automatically.

• If the last operation is a Read the master does not send an acknowledge for the last byte.

• ST = start condition

• SAD+R/W = slave address followed by bit 1 to indicate reading or 0 to indicate writing

• SR = repeated start condition

• SP = stop condition

Errors

The corresponding error variant from Error will be returned if the buffer passed to an Operation has zero length.

Trait Implementations

impl<'d, Dm: Debug + DriverMode> Debug for I2c<'d, Dm>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Dm: DriverMode> ErrorType for I2c<'_, Dm>

type Error = Error

Error type

impl<'d, Dm: DriverMode> Format for I2c<'d, Dm>

where PeripheralRef<'d, AnyI2c>: Format, PhantomData<Dm>: Format, Config: Format, PeripheralGuard: Format, PinGuard: Format,

fn format(&self, f: Formatter<'_>)

Writes the defmt representation of self to fmt.

impl I2c for I2c<'_, Async>

async fn transaction( &mut self, address: u8, operations: &mut [EhalOperation<'_>], ) -> Result<(), Self::Error>

Execute the provided operations on the I2C bus as a single transaction.

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

Reads enough bytes from slave with address to fill buffer.

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

Writes bytes to slave with address address.

async fn write_read( &mut self, address: A, write: &[u8], read: &mut [u8], ) -> Result<(), Self::Error>

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

impl<Dm: DriverMode> I2c for I2c<'_, Dm>

fn transaction( &mut self, address: u8, operations: &mut [Operation<'_>], ) -> Result<(), Self::Error>

Execute the provided operations on the I2C bus.

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

Reads enough bytes from slave with address to fill read.

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

Writes bytes to slave with address address.

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

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

impl InterruptConfigurable for I2c<'_, Blocking>

Available on crate feature unstable only.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

fn set_interrupt_handler(&mut self, handler: InterruptHandler)

Registers an interrupt handler for the peripheral.

impl<Dm: DriverMode> SetConfig for I2c<'_, Dm>

Available on crate feature unstable only.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

type Config = Config

The configuration type used by this driver.

type ConfigError = ConfigError

The error type that can occur if set_config fails.

fn set_config(&mut self, config: &Self::Config) -> Result<(), Self::ConfigError>

Set the configuration of the driver.