Struct rp2040_hal::i2c::I2C

pub struct I2C<I2C, Pins, Mode = Controller> { /* private fields */ }

I2C peripheral

Implementations

impl<T: SubsystemReset + Deref<Target = Block>, Sda: PinId + BankPinId, Scl: PinId + BankPinId> I2C<T, (Pin<Sda, FunctionI2C>, Pin<Scl, FunctionI2C>), Controller>

pub fn new_controller(
    i2c: T,
    sda_pin: Pin<Sda, FunctionI2C>,
    scl_pin: Pin<Scl, FunctionI2C>,
    freq: HertzU32,
    resets: &mut RESETS,
    system_clock: HertzU32
) -> Selfwhere
    Sda: SdaPin<T>,
    Scl: SclPin<T>,

Configures the I2C peripheral to work in controller mode

impl<T, Sda, Scl> I2C<T, (Pin<Sda, FunctionI2C>, Pin<Scl, FunctionI2C>), Peripheral>where
    T: SubsystemReset + Deref<Target = I2CBlock>,
    Sda: PinId + BankPinId,
    Scl: PinId + BankPinId,

pub fn new_peripheral_event_iterator(
    i2c: T,
    sda_pin: Pin<Sda, FunctionI2C>,
    scl_pin: Pin<Scl, FunctionI2C>,
    resets: &mut RESETS,
    addr: u16
) -> I2CPeripheralEventIterator<T, (Pin<Sda, FunctionI2C>, Pin<Scl, FunctionI2C>)> where
    Sda: SdaPin<T>,
    Scl: SclPin<T>,

Configures the I2C peripheral to work in peripheral mode

The bus MUST be idle when this method is called.

impl<Block, Sda, Scl, Mode> I2C<Block, (Pin<Sda, FunctionI2C>, Pin<Scl, FunctionI2C>), Mode>where
    Block: SubsystemReset + Deref<Target = I2CBlock>,
    Sda: PinId + BankPinId,
    Scl: PinId + BankPinId,
    Mode: I2CMode,

pub fn free(
    self,
    resets: &mut RESETS
) -> (Block, (Pin<Sda, FunctionI2C>, Pin<Scl, FunctionI2C>))

Releases the I2C peripheral and associated pins

impl<Block: Deref<Target = I2CBlock>, PINS, Mode> I2C<Block, PINS, Mode>

pub fn rx_fifo_used(&self) -> u8

Number of bytes currently in the RX FIFO

pub fn rx_fifo_free(&self) -> u8

Remaining capacity in the RX FIFO

pub fn rx_fifo_empty(&self) -> bool

RX FIFO is empty

pub fn tx_fifo_used(&self) -> u8

Number of bytes currently in the TX FIFO

pub fn tx_fifo_free(&self) -> u8

Remaining capacity in the TX FIFO

pub fn tx_fifo_full(&self) -> bool

TX FIFO is at capacity

impl<Sda: PinId + BankPinId, Scl: PinId + BankPinId> I2C<I2C0, (Pin<Sda, FunctionI2C>, Pin<Scl, FunctionI2C>)>

pub fn i2c0<F, SystemF>(
    i2c: I2C0,
    sda_pin: Pin<Sda, FunctionI2C>,
    scl_pin: Pin<Scl, FunctionI2C>,
    freq: F,
    resets: &mut RESETS,
    system_clock: SystemF
) -> Selfwhere
    F: Into<HertzU32>,
    Sda: SdaPin<I2C0>,
    Scl: SclPin<I2C0>,
    SystemF: Into<HertzU32>,

Configures the I2C peripheral to work in master mode

impl<Sda: PinId + BankPinId, Scl: PinId + BankPinId> I2C<I2C1, (Pin<Sda, FunctionI2C>, Pin<Scl, FunctionI2C>)>

pub fn i2c1<F, SystemF>(
    i2c: I2C1,
    sda_pin: Pin<Sda, FunctionI2C>,
    scl_pin: Pin<Scl, FunctionI2C>,
    freq: F,
    resets: &mut RESETS,
    system_clock: SystemF
) -> Selfwhere
    F: Into<HertzU32>,
    Sda: SdaPin<I2C1>,
    Scl: SclPin<I2C1>,
    SystemF: Into<HertzU32>,

Configures the I2C peripheral to work in master mode

Trait Implementations

impl<T: Deref<Target = Block>, PINS> Read<u8> for I2C<T, PINS, Controller>

type Error = Error

Error type

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

Reads enough bytes from slave with address to fill buffer

impl<T: Deref<Target = Block>, PINS> Write<u8> for I2C<T, PINS, Controller>

type Error = Error

Error type

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

Writes bytes to slave with address address

impl<T: Deref<Target = Block>, PINS> WriteRead<u8> for I2C<T, PINS, Controller>

type Error = Error

Error type

fn write_read(&mut self, addr: u8, tx: &[u8], rx: &mut [u8]) -> Result<(), Error>

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