Struct i2c_linux::I2c

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

A safe wrapper around an I2C device.

Methods

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.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn inner_ref(&self) -> &I

Borrows the inner file descriptor.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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> Master for I2c<I>

type Error = Error

The error type returned by I2C operations.

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> 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: 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<I: AsRawFd> AsRawFd for I2c<I>

fn as_raw_fd(&self) -> RawFd

Extracts the 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 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: 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.

unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Creates a "by reference" adaptor for this instance of Read.

Important traits for Bytes<R>

impl<R> Iterator for Bytes<R> where
    R: Read,  type Item = Result<u8, Error>;

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

Important traits for Chain<T, U>

impl<T, U> Read for Chain<T, U> where
    T: Read,
    U: Read, 

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

Creates an adaptor which will chain this stream with another.

Important traits for Take<T>

impl<T> Read for Take<T> where
    T: Read, 

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

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

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

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

Write a buffer into this object, returning how many bytes were written.

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

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

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

Attempts to write an entire buffer into this write.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Creates a "by reference" adaptor for this instance of Write.