Struct I2c

pub struct I2c<I2C: Instance> { /* private fields */ }

I2C abstraction

Implementations

impl<I2C: Instance> I2c<I2C>

pub fn use_dma<TX_STREAM, const TX_CH: u8, RX_STREAM, const RX_CH: u8>( self, tx_stream: TX_STREAM, rx_stream: RX_STREAM, ) -> I2CMasterDma<I2C, TxDMA<I2C, TX_STREAM, TX_CH>, RxDMA<I2C, RX_STREAM, RX_CH>>

where TX_STREAM: Stream, ChannelX<TX_CH>: Channel, Tx<I2C>: DMASet<TX_STREAM, TX_CH, MemoryToPeripheral>, RX_STREAM: Stream, ChannelX<RX_CH>: Channel, Rx<I2C>: DMASet<RX_STREAM, RX_CH, PeripheralToMemory>,

Converts blocking I2c to non-blocking I2CMasterDma that use tx_stream and rx_stream to send/receive data

pub fn use_dma_tx<TX_STREAM, const TX_CH: u8>( self, tx_stream: TX_STREAM, ) -> I2CMasterDma<I2C, TxDMA<I2C, TX_STREAM, TX_CH>, NoDMA>

where TX_STREAM: Stream, ChannelX<TX_CH>: Channel, Tx<I2C>: DMASet<TX_STREAM, TX_CH, MemoryToPeripheral>,

Converts blocking I2c to non-blocking I2CMasterDma that use tx_stream to only send data

pub fn use_dma_rx<RX_STREAM, const RX_CH: u8>( self, rx_stream: RX_STREAM, ) -> I2CMasterDma<I2C, NoDMA, RxDMA<I2C, RX_STREAM, RX_CH>>

where RX_STREAM: Stream, ChannelX<RX_CH>: Channel, Rx<I2C>: DMASet<RX_STREAM, RX_CH, PeripheralToMemory>,

Converts blocking I2c to non-blocking I2CMasterDma that use rx_stream to only receive data

impl<I2C: Instance> I2c<I2C>

pub fn new( i2c: I2C, pins: (impl Into<I2C::Scl>, impl Into<I2C::Sda>), mode: impl Into<Mode>, clocks: &Clocks, ) -> Self

pub fn release(self) -> (I2C, (I2C::Scl, I2C::Sda))

impl<I2C: Instance> I2c<I2C>

pub fn read( &mut self, addr: impl Into<Address>, buffer: &mut [u8], ) -> Result<(), Error>

pub fn write( &mut self, addr: impl Into<Address>, bytes: &[u8], ) -> Result<(), Error>

pub fn write_iter<B>( &mut self, addr: impl Into<Address>, bytes: B, ) -> Result<(), Error>

where B: IntoIterator<Item = u8>,

pub fn write_read( &mut self, addr: impl Into<Address>, bytes: &[u8], buffer: &mut [u8], ) -> Result<(), Error>

pub fn write_iter_read<B>( &mut self, addr: impl Into<Address>, bytes: B, buffer: &mut [u8], ) -> Result<(), Error>

where B: IntoIterator<Item = u8>,

pub fn transaction<'a>( &mut self, addr: impl Into<Address>, ops: impl Iterator<Item = Operation<'a>>, ) -> Result<(), Error>

pub fn transaction_slice( &mut self, addr: impl Into<Address>, ops_slice: &mut [Operation<'_>], ) -> Result<(), Error>

Trait Implementations

impl<I2C: Instance> ErrorType for I2c<I2C>

type Error = Error

Error type

impl<I2C: Instance> I2c<u16> for I2c<I2C>

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

Reads enough bytes from slave with address to fill read.

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

Writes bytes to slave with address address.

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

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

Execute the provided operations on the I2C bus.

impl<I2C: Instance> I2c for I2c<I2C>

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

Reads enough bytes from slave with address to fill read.

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

Writes bytes to slave with address address.

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

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

Execute the provided operations on the I2C bus.

impl<I2C: Instance> Transactional for I2c<I2C>

type Error = Error

Error type

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

Execute the provided operations on the I2C bus.

impl<I2C: Instance> WriteIter for I2c<I2C>

type Error = Error

Error type

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

where B: IntoIterator<Item = u8>,

Writes bytes to slave with address address

impl<I2C: Instance> WriteIterRead for I2c<I2C>

type Error = Error

Error type

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

where B: IntoIterator<Item = u8>,

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

impl<I2C: Instance> Read for I2c<I2C>

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<I2C: Instance> Write for I2c<I2C>

type Error = Error

Error type

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

Writes bytes to slave with address address

impl<I2C: Instance> WriteRead for I2c<I2C>

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