Struct I2c

pub struct I2c<C: AnyConfig, D = NoneT> { /* private fields */ }

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

Implementations

impl<C, S> I2c<C>

where C: AnyConfig<Sercom = S>, S: Sercom,

pub fn into_future<I>(self, _interrupts: I) -> I2cFuture<C>

where I: Binding<S::Interrupt, InterruptHandler<S>>,

Turn an I2c into an I2cFuture

impl<C: AnyConfig, D> I2c<C, D>

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 with_dma_channel<Chan: AnyChannel<Status = Ready>>( self, channel: Chan, ) -> I2c<C, Chan>

Attach a DMA channel to this I2c. Its embedded_hal::i2c::I2c implementation will use DMA to carry out its transactions.

impl<C, D, S> I2c<C, D>

where C: AnyConfig, D: AnyChannel<Status = S>, S: ReadyChannel,

pub fn take_dma_channel(self) -> (I2c<C, NoneT>, D)

Reclaim the DMA channel. Any subsequent I2C operations will no longer use DMA.

Trait Implementations

impl<C: AnyConfig, D> AsMut<I2c<C, D>> for I2cFuture<C, D>

fn as_mut(&mut self) -> &mut I2c<C, D>

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

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, D> AsRef<I2c<C, D>> for I2cFuture<C, D>

fn as_ref(&self) -> &I2c<C, D>

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

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

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, D, S> I2c for I2c<C, D>

where C: AnyConfig<Sercom = S>, S: Sercom, D: AnyChannel<Status = Ready>,

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