Struct I2c

pub struct I2c<I> { /* private fields */ }

A safe wrapper around an I2C device.

Implementations

impl I2c<File>

pub fn from_path<P: AsRef<Path>>(p: P) -> Result<Self>

Open an I2C device

impl<I> I2c<I>

pub fn new(device: I) -> Self

Creates a new I2C handle with the given file descriptor

pub fn into_inner(self) -> I

Consumes the I2C handle to return the inner file descriptor.

pub fn inner_ref(&self) -> &I

Borrows the inner file descriptor.

pub fn inner_mut(&mut self) -> &mut I

Mutably borrows the inner file descriptor.

impl<I: AsRawFd> I2c<I>

pub fn i2c_set_retries(&self, value: usize) -> Result<()>

Sets the number of times to retry communication before failing.

pub fn i2c_set_timeout(&self, duration: Duration) -> Result<()>

Sets a timeout for I2C operations

pub fn smbus_set_slave_address( &mut self, address: u16, tenbit: bool, ) -> Result<()>

Set the slave address to communicate with.

pub fn smbus_set_pec(&self, pec: bool) -> Result<()>

Enable or disable SMBus Packet Error Checking.

pub fn i2c_functionality(&self) -> Result<Functionality>

Retrieve the capabilities of the I2C device. These should be checked before attempting to use certain SMBus commands or I2C flags.

pub fn i2c_transfer_flags(&self) -> Result<(ReadFlags, WriteFlags)>

i2c_transfer capabilities of the I2C device. These should be checked before attempting to use any of the protocol mangling flags.

pub fn i2c_transfer(&mut self, messages: &mut [Message<'_>]) -> Result<()>

Executes a queue of I2C transfers, separated by repeat START conditions. Data buffers are truncated to the actual read length on completion.

See the I2C_RDWR ioctl for more information.

pub fn smbus_write_quick(&mut self, value: ReadWrite) -> Result<()>

Sends a single bit to the device, in the place of the Rd/Wr address bit.

pub fn smbus_read_byte(&mut self) -> Result<u8>

Reads a single byte from a device without specifying a register.

Some devices are so simple that this interface is enough; for others, it is a shorthand if you want to read the same register as in the previous SMBus command.

pub fn smbus_write_byte(&mut self, value: u8) -> Result<()>

Sends a single byte to a device.

pub fn smbus_read_byte_data(&mut self, command: u8) -> Result<u8>

Reads a single byte from a device from the designated register.

pub fn smbus_write_byte_data(&mut self, command: u8, value: u8) -> Result<()>

Writes a single byte to a device to the designated register.

pub fn smbus_read_word_data(&mut self, command: u8) -> Result<u16>

Reads a 16-bit word from the device register.

pub fn smbus_write_word_data(&mut self, command: u8, value: u16) -> Result<()>

Writes a 16-bit word to the device register.

pub fn smbus_process_call(&mut self, command: u8, value: u16) -> Result<u16>

Selects a device register, sends a 16-bit word to it, and read 16-bits of data in return.

pub fn smbus_read_block_data( &mut self, command: u8, value: &mut [u8], ) -> Result<usize>

Read up to 32 bytes from the designated device register.

Returns the amount of data read.

pub fn smbus_write_block_data( &mut self, command: u8, value: &[u8], ) -> Result<()>

Write up to 32 bytes to the designated device register.

pub fn smbus_block_process_call( &mut self, command: u8, write: &[u8], read: &mut [u8], ) -> Result<usize>

Sends up to 31 bytes of data to the designated device register, and reads up to 31 bytes in return.

This was introduced in SMBus 2.0

pub fn i2c_read_block_data( &mut self, command: u8, value: &mut [u8], ) -> Result<usize>

Reads a block of bytes from the designated device register.

Unlike smbus_read_block_data this does not receive a data length. This is limited to 32 bytes due to the use of the Linux SMBus interface. Use i2c_transfer() if more data is needed. write()+read() may also be an option, though will produce an I2C STOP condition between the transfers, which may be undesirable.

pub fn i2c_write_block_data(&mut self, command: u8, value: &[u8]) -> Result<()>

Writes a block of bytes from the designated device register.

Unlike smbus_write_block_data this does not transfer the data length. This is limited to 32 bytes due to the use of the Linux SMBus interface. Use i2c_transfer() or write() instead if more data is needed.

Trait Implementations

impl<I: AsRawFd> Address for I2c<I>

fn set_slave_address( &mut self, addr: u16, tenbit: bool, ) -> Result<(), Self::Error>

Sets the current slave to address.

impl<I: AsRawFd> AsRawFd for I2c<I>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<I: AsRawFd> BlockTransfer for I2c<I>

fn i2c_read_block_data( &mut self, command: u8, value: &mut [u8], ) -> Result<usize, Self::Error>

Reads a block of bytes from the designated device register.

fn i2c_write_block_data( &mut self, command: u8, value: &[u8], ) -> Result<(), Self::Error>

Writes a block of bytes to the designated device register.

impl<I: AsRawFd> BulkTransfer for I2c<I>

fn i2c_transfer_support( &mut self, ) -> Result<(ReadFlags, WriteFlags), Self::Error>

Specifies the flags that this implementation supports.

fn i2c_transfer( &mut self, messages: &mut [Message<'_>], ) -> Result<(), Self::Error>

Executes a queue of I2C transfers, separated by repeated START conditions. Data buffers are truncated to the actual read length on completion.

impl FromRawFd for I2c<File>

unsafe fn from_raw_fd(fd: RawFd) -> Self

Constructs a new instance of Self from the given raw file descriptor.

impl<I: IntoRawFd> IntoRawFd for I2c<I>

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.

impl<I: AsRawFd> Master for I2c<I>

type Error = Error

The error type returned by I2C operations.

impl<I: Read> Read for I2c<I>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<I: AsRawFd> Smbus for I2c<I>

fn smbus_write_quick(&mut self, value: bool) -> Result<(), Self::Error>

Sends a single bit to the device, in the place of the rd/wr address bit.

fn smbus_read_byte(&mut self) -> Result<u8, Self::Error>

Reads a single byte from a device without specifying a register.

fn smbus_write_byte(&mut self, value: u8) -> Result<(), Self::Error>

Sends a single byte to the device

fn smbus_read_byte_data(&mut self, command: u8) -> Result<u8, Self::Error>

Reads a byte from the designated register.

fn smbus_write_byte_data( &mut self, command: u8, value: u8, ) -> Result<(), Self::Error>

Writes a byte to the designated register.

fn smbus_read_word_data(&mut self, command: u8) -> Result<u16, Self::Error>

Reads a 16-bit word from the designated register.

fn smbus_write_word_data( &mut self, command: u8, value: u16, ) -> Result<(), Self::Error>

Writes a 16-bit word to the designated register.

fn smbus_process_call( &mut self, command: u8, value: u16, ) -> Result<u16, Self::Error>

Writes a 16-bit word to the specified register, then reads a 16-bit word in response.

fn smbus_read_block_data( &mut self, command: u8, value: &mut [u8], ) -> Result<usize, Self::Error>

Reads up to 32 bytes from the designated device register.

fn smbus_write_block_data( &mut self, command: u8, value: &[u8], ) -> Result<(), Self::Error>

Writes up to 32 bytes to the designated device register.

impl<I: AsRawFd> Smbus20 for I2c<I>

fn smbus_process_call_block( &mut self, command: u8, write: &[u8], read: &mut [u8], ) -> Result<usize, Self::Error>

Sends up to 31 bytes of data to the designated register, and reads up to 31 bytes in return.

impl<I: AsRawFd> SmbusPec for I2c<I>

fn smbus_set_pec(&mut self, pec: bool) -> Result<(), Self::Error>

Enables or disables SMBus Packet Error Checking

impl<I: Write> Write for I2c<I>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.