Skip to navigation
API referenceEmulation APIClasses

hololink::emulation::LII2CExpanderPeripheral

View as Markdown
#include <hololink/emulation/hsb_emulator.hpp>

Inherits from: hololink::emulation::I2CPeripheral (public)

Constructors

LII2CExpanderPeripheral

hololink::emulation::LII2CExpanderPeripheral::LII2CExpanderPeripheral() = default

Methods

i2c_transaction

I2CStatus hololink::emulation::LII2CExpanderPeripheral::i2c_transaction(
    uint16_t peripheral_address,
    const uint8_t *write_bytes,
    uint16_t write_size,
    uint8_t *read_bytes,
    uint16_t read_size
) override

python:

def i2c_transaction(self: hemu.I2CPeripheral, peripheral_address: int, write_bytes: bytes, write_size: int, read_bytes: bytearray, read_size: int) -> hemu.I2CStatus

perform an I2C transaction. This will be called by the I2CController when a transaction is requested.

write_bytes and read_bytes may alias (the I2C controller hands the same data buffer for both), so consume the write bytes before producing the read bytes.

Python override: write_bytes arrives as an immutable bytes copy of length write_size; read_bytes is a bytearray of length read_size to fill, e.g. read_bytes[0:2] = bytes([0x12, 0x34]); it is copied into the controller’s buffer when the override returns, so it must keep its length. An exception from the override fails the transaction (I2C_STATUS_FATAL_ERROR) and is reported through sys.unraisablehook. Calling i2c_transaction on a peripheral from Python takes (peripheral_address, write_bytes, read_bytes=None, write_size=None, read_size=None) where write_bytes is any byte buffer and read_bytes a writable byte buffer (e.g. bytearray(n)).

Returns: I2CStatus The status of the transaction.

Parameters

peripheral_address
uint16_t

The peripheral address to communicate with.

write_bytes
const uint8_t *

The bytes to write to the peripheral.

write_size
uint16_t

The size of the write bytes.

read_bytes
uint8_t *

Buffer the peripheral fills with the bytes read. The caller provides read_size bytes of storage; the peripheral overwrites them with its reply.

read_size
uint16_t

The number of bytes requested by the host.

attach_to_i2c

void hololink::emulation::LII2CExpanderPeripheral::attach_to_i2c(
    I2CController &i2c_controller,
    uint8_t i2c_bus_address
) override

python:

def attach_to_i2c(self: hemu.I2CPeripheral, i2c_controller: hemu.I2CController, bus_address: int)

attach the peripheral to the I2C controller. This should be called by client code before start() is called.

Parameters

i2c_controller
I2CController &

The I2C controller to attach to. Retrieved from HSBEmulator with get_i2c(controller_address).

bus_address
uint8_t

The bus address of the peripheral.

output_state

uint8_t hololink::emulation::LII2CExpanderPeripheral::output_state() const

start

virtual void hololink::emulation::LII2CExpanderPeripheral::start()

start the peripheral.

This will be called when I2CController itself starts and should not be done by the client code.

stop

virtual void hololink::emulation::LII2CExpanderPeripheral::stop()

stop the peripheral.

This will be called when the I2CController is stopped and should not be done by the client code.

Peripheral should release all resources in case a subsequent start() is called.

Member variables

NameTypeDescription
PERIPHERAL_ADDRESS static constexpruint16_t
output_state_uint8_t