Struct i2cdev::mock::MockI2CDevice

pub struct MockI2CDevice {
    pub regmap: I2CRegisterMap,
}

Mock I2C device exposing a register map

Fields

regmap: I2CRegisterMap

I2C register map

Implementations

impl MockI2CDevice

pub fn new() -> MockI2CDevice

Create a new mock I2C device

Trait Implementations

impl Default for MockI2CDevice

fn default() -> MockI2CDevice

Returns the “default value” for a type.

impl I2CDevice for MockI2CDevice

type Error = Error

Error type

fn read(&mut self, data: &mut [u8]) -> I2CResult<()>

Read data from the device to fill the provided slice

fn write(&mut self, data: &[u8]) -> I2CResult<()>

Write the provided buffer to the device

fn smbus_write_quick(&mut self, _bit: bool) -> I2CResult<()>

This sends a single bit to the device, at the place of the Rd/Wr bit

fn smbus_read_block_data(&mut self, _register: u8) -> I2CResult<Vec<u8>>

Read a block of up to 32 bytes from a device

fn smbus_write_block_data(
    &mut self,
    _register: u8,
    _values: &[u8]
) -> I2CResult<()>

Write a block of up to 32 bytes to a device

fn smbus_process_block(
    &mut self,
    _register: u8,
    _values: &[u8]
) -> I2CResult<Vec<u8>>

Select a register, send 1 to 31 bytes of data to it, and reads 1 to 31 bytes of data from it.

fn smbus_read_i2c_block_data(
    &mut self,
    _register: u8,
    _len: u8
) -> I2CResult<Vec<u8>>

Read a block of up to 32 bytes from a device

fn smbus_write_i2c_block_data(
    &mut self,
    _register: u8,
    _values: &[u8]
) -> I2CResult<()>

Write a block of up to 32 bytes from a device

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

Read a single byte from a device, without specifying a device register

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

Write a single byte to a device, without specifying a device register

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

Read a single byte from a device, from a designated register

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

Write a single byte to a specific register on a device

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

Read 2 bytes from a given register on a device (lsb first)

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

Write 2 bytes to a given register on a device (lsb first)

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

Select a register, send 16 bits of data to it, and read 16 bits of data

impl<'a> I2CTransfer<'a> for MockI2CDevice where
    MockI2CDevice: I2CDevice, 

fn transfer(
    &mut self,
    messages: &'a mut [Self::Message]
) -> Result<u32, Self::Error>

Issue the provided sequence of I2C transactions

type Error = Error

I2C transfer error type

type Message = MockI2CMessage<'a>

I2C transfer message type