Struct stm32f4xx_hal::i2c::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> I2c<I2C>

where I2C: Instance,

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: u8, buffer: &mut [u8]) -> Result<(), Error>

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

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

where B: IntoIterator<Item = u8>,

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

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

where B: IntoIterator<Item = u8>,

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

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

Trait Implementations

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

type Error = Error

Error type

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

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

Reads enough bytes from slave with address to fill read.

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

Writes bytes to slave with address address.

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

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

Execute the provided operations on the I2C bus.

impl<I2C> Transactional for I2c<I2C>

where I2C: Instance,

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> WriteIter for I2c<I2C>

where I2C: Instance,

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> WriteIterRead for I2c<I2C>

where I2C: Instance,

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> Read for I2c<I2C>

where I2C: Instance,

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

where I2C: 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<I2C> WriteRead for I2c<I2C>

where I2C: Instance,

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