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

impl<C: AnyConfig> I2c<C>

pub fn init_dma_transfer(&mut self) -> Result<I2cBusReady, Error>

Initialize the bus to start receiving with DMA.

In reality, this function only checks whether or not the I2C bus is ready to accept a new transaction. A call to init_dma_transfer should immediately be followed by a call to send_with_dma or receive_with_dma.

// Assume `i2c` is a fully configured `I2c`, and `chan0` a fully configured `dmac::Channel`.
let token = i2c.init_dma_transfer()?;
i2c.send_with_dma(ADDRESS, token, buf_src, chan0, |_| {});

pub fn receive_with_dma<Ch, B, W>( self, address: u8, _ready_token: I2cBusReady, buf: B, channel: Ch, waker: W ) -> Transfer<Channel<Ch::Id, Busy>, BufferPair<Self, B>, W>

where Ch: AnyChannel<Status = Ready>, B: Buffer<Beat = Word> + 'static, W: FnOnce(CallbackStatus) + 'static,

Transform an I2c into a DMA Transfer) and start receiving into the provided buffer. The buffer length must be 255 bytes or shorter.

It is recommended that you check for errors after the transfer is complete by calling read_status.

pub fn send_with_dma<Ch, B, W>( self, address: u8, _ready_token: I2cBusReady, buf: B, channel: Ch, waker: W ) -> Transfer<Channel<Ch::Id, Busy>, BufferPair<B, Self>, W>

where Ch: AnyChannel<Status = Ready>, B: Buffer<Beat = Word> + 'static, W: FnOnce(CallbackStatus) + 'static,

Transform an I2c into a DMA Transfer) and start sending the provided buffer. The buffer length must be 255 bytes or shorter.

It is recommended that you check for errors after the transfer is complete by calling read_status.

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> Buffer for I2c<C>

type Beat = u8

DMAC beat size

fn dma_ptr(&mut self) -> *mut Self::Beat

Pointer to the buffer. If the buffer is incrementing, the address should point to one past the last beat transfer in the block.

fn incrementing(&self) -> bool

Return whether the buffer pointer should be incrementing or not

fn buffer_len(&self) -> usize

Buffer length in beats

impl<C: AnyConfig> ErrorType for I2c<C>

type Error = Error

Error type

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

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

Execute the provided operations on the I2C bus.

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

Writes bytes to slave with address address.

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

Reads enough bytes from slave with address to fill read.

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 read in a single transaction.

impl<C: AnyConfig> Read 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 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 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