Struct atsamd_hal::sercom::i2c::I2c

pub struct I2c<C: AnyConfig> { /* private fields */ }

Abstraction over a I2C peripheral, allowing to perform I2C transactions.

Implementations

impl<C: AnyConfig> I2c<C>

pub fn data_ptr(&self) -> *mut Word

Obtain a pointer to the DATA register. Necessary for DMA transfers.

pub fn read_flags(&self) -> Flags

Read the interrupt flags

pub fn clear_flags(&mut self, flags: Flags)

Clear interrupt status flags

pub fn enable_interrupts(&mut self, flags: Flags)

Enable interrupts for the specified flags.

pub fn disable_interrupts(&mut self, flags: Flags)

Disable interrupts for the specified flags.

pub fn read_status(&self) -> Status

Read the status flags

pub fn clear_status(&mut self, status: Status)

Clear the status flags

pub fn reconfigure<F>(&mut self, update: F)where
    F: FnOnce(&mut SpecificConfig<C>),

Reconfigure the I2C peripheral.

Calling this method will temporarily disable the SERCOM peripheral, as some registers are enable-protected. This may interrupt any ongoing transactions.

use atsamd_hal::sercom::i2c::I2c;
i2c.reconfigure(|c| c.set_run_in_standby(false));

pub fn disable(self) -> C

Disable the I2C peripheral and return the underlying Config

Trait Implementations

impl<P: PadSet> AsRef<Config<P>> for I2c<Config<P>>

fn as_ref(&self) -> &Config<P>

Converts this type into a shared reference of the (usually inferred) input type.

impl<C: AnyConfig> Read<u8> for I2c<C>

type Error = Error

Error type

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

Reads enough bytes from slave with address to fill buffer

impl<C: AnyConfig> Write<u8> for I2c<C>

type Error = Error

Error type

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

Writes bytes to slave with address address

impl<C: AnyConfig> WriteRead<u8> for I2c<C>

type Error = Error

Error type

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