Struct I2c

pub struct I2c<'d, DM: Mode, T = AnyI2c> { /* private fields */ }

I2C driver

Implementations

impl<'d, T, DM: Mode> I2c<'d, DM, T>

where T: Instance,

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

Applies a new configuration.

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

Connect a pin to the I2C SDA signal.

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

Connect a pin to the I2C SCL signal.

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

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

Create a new I2C instance This will enable the peripheral but the peripheral won’t get automatically disabled when this gets dropped.

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

where T: Instance,

pub fn new_typed(i2c: impl Peripheral<P = T> + 'd, config: Config) -> Self

Create a new I2C instance This will enable the peripheral but the peripheral won’t get automatically disabled when this gets dropped.

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

Configures the I2C peripheral to operate in asynchronous mode.

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

Writes bytes to slave with address address

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

Reads enough bytes from slave with address to fill buffer

pub fn write_read( &mut self, address: u8, 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

pub fn transaction<'a>( &mut self, address: u8, 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

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

where T: Instance,

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

Configure the I2C peripheral to operate in blocking mode.

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

Writes bytes to slave with address address

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

Reads enough bytes from slave with address to fill buffer

pub async fn write_read( &mut self, address: u8, 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

pub async fn transaction<'a>( &mut self, address: u8, 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

Trait Implementations

impl<T, DM: Mode> ErrorType for I2c<'_, DM, T>

type Error = Error

Error type

impl<T> I2c for I2c<'_, Async, T>

where T: Instance,

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<T, DM: Mode> I2c for I2c<'_, DM, T>

where T: Instance,

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<T> InterruptConfigurable for I2c<'_, Blocking, T>

where T: Instance,

fn set_interrupt_handler(&mut self, handler: InterruptHandler)

Set the interrupt handler

impl<T: Instance, DM: Mode> SetConfig for I2c<'_, DM, T>

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.

impl<T> Read for I2c<'_, Blocking, T>

where T: Instance,

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<T> Write for I2c<'_, Blocking, T>

where T: Instance,

type Error = Error

Error type

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

Writes bytes to slave with address address

impl<T> WriteRead for I2c<'_, Blocking, T>

where T: Instance,

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