Struct apollo3::iom::Iom

pub struct Iom<'a> { /* private fields */ }

Implementations

impl<'a> Iom<'_>

pub fn new0() -> Iom<'a>

pub fn new1() -> Iom<'a>

pub fn new2() -> Iom<'a>

pub fn new3() -> Iom<'a>

pub fn new4() -> Iom<'a>

pub fn new5() -> Iom<'a>

pub fn handle_interrupt(&self)

Trait Implementations

impl<'a> I2CMaster<'a> for Iom<'a>

fn set_master_client(&self, i2c_master_client: &'a dyn I2CHwMasterClient)

fn enable(&self)

fn disable(&self)

fn write_read( &self, addr: u8, data: &'static mut [u8], write_len: usize, read_len: usize ) -> Result<(), (Error, &'static mut [u8])>

fn write( &self, addr: u8, data: &'static mut [u8], len: usize ) -> Result<(), (Error, &'static mut [u8])>

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

impl<'a> SMBusMaster<'a> for Iom<'a>

fn smbus_write_read( &self, addr: u8, data: &'static mut [u8], write_len: usize, read_len: usize ) -> Result<(), (Error, &'static mut [u8])>

Write data then read data via the I2C Master device in an SMBus compatible way.

fn smbus_write( &self, addr: u8, data: &'static mut [u8], len: usize ) -> Result<(), (Error, &'static mut [u8])>

Write data via the I2C Master device in an SMBus compatible way.

fn smbus_read( &self, addr: u8, buffer: &'static mut [u8], len: usize ) -> Result<(), (Error, &'static mut [u8])>

Read data via the I2C Master device in an SMBus compatible way.

impl<'a> SpiMaster<'a> for Iom<'a>

type ChipSelect = &'a GpioPin<'a>

Chip select is an associated type because different SPI buses may have different numbers of chip selects. This allows peripheral implementations to define their own type.

fn init(&self) -> Result<(), ErrorCode>

Initialize this SPI interface. Call this once before invoking any other operations. Return values are:

fn set_client(&self, client: &'a dyn SpiMasterClient)

Change the callback handler for read_write_bytes calls.

fn is_busy(&self) -> bool

Return whether the SPI peripheral is busy with read_write_bytes call.

fn read_write_bytes( &self, write_buffer: &'static mut [u8], read_buffer: Option<&'static mut [u8]>, len: usize ) -> Result<(), (ErrorCode, &'static mut [u8], Option<&'static mut [u8]>)>

Perform an asynchronous read/write operation, whose completion is signaled by invoking SpiMasterClient on the client. Write-only operations may pass None for read_buffer, while read-write operations pass Some for read_buffer.

fn write_byte(&self, val: u8) -> Result<(), ErrorCode>

Synchronously write a single byte on the bus. Not for general use because it is blocking: intended for debugging. Return values:

fn read_byte(&self) -> Result<u8, ErrorCode>

Synchronously write a 0 and read a single byte from the bus. Not for general use because it is blocking: intended for debugging. Return values:

fn read_write_byte(&self, val: u8) -> Result<u8, ErrorCode>

Synchronously write and read a single byte. Not for general use because it is blocking: intended for debugging. Return values:

fn specify_chip_select(&self, cs: Self::ChipSelect) -> Result<(), ErrorCode>

Specify which chip select to use. Configuration settings (rate, polarity, phase) are chip-select specific and are stored for that chip select.

fn set_rate(&self, rate: u32) -> Result<u32, ErrorCode>

Set the clock/data rate for the current chip select. Return values:

fn get_rate(&self) -> u32

Return the current chip select’s clock rate.

fn set_polarity(&self, polarity: ClockPolarity) -> Result<(), ErrorCode>

Set the bus polarity (whether idle is high or low) for the current chip select. Return values:

fn get_polarity(&self) -> ClockPolarity

Return the current bus polarity.

fn set_phase(&self, phase: ClockPhase) -> Result<(), ErrorCode>

Set the bus phase for the current chip select (whether data is sent/received on leading or trailing edges).

fn get_phase(&self) -> ClockPhase

Get the current bus phase for the current chip select.

fn hold_low(&self)

Hold the chip select line low after a read_write_bytes completes. This allows a client to make one long SPI read/write with multiple calls to read_write_bytes.

fn release_low(&self)

Raise the chip select line after a read_write_bytes completes. This will complete the SPI operation.