Tutorial: Your First I3C Transaction with the Binho…

Tutorial: Your First I3C Transaction with the Binho Supernova

MIPI I3C is a newer bus protocol that can feel intimidating compared to I2C. Dynamic address assignment, Common Command Codes, in-band interrupts, HDR modes, the specification is dense. But the first practical step is simple: initialize the bus, assign an address to a target device, and perform a basic read transaction. Once you have done that, everything else builds incrementally.

This tutorial uses the Binho Supernova as an I3C controller to perform a first I3C transaction with a target device. We will use the Python SDK and assume you have the Supernova connected, a target I3C device (sensor, PMIC, or evaluation board), and Python 3.7+ installed.

I3C Basics You Need to Know

Before touching hardware, here are the four I3C concepts that matter for this tutorial:

Static vs Dynamic Addresses. I3C devices can have a static address (assigned by hardware, like I2C) or a dynamic address (assigned by the controller during bus initialization). Dynamic addressing is the I3C-native approach and is what we will use here.

ENTDAA (Enter Dynamic Address Assignment). This is the Common Command Code that the I3C controller broadcasts to discover target devices on the bus and assign each one a dynamic address. It is the I3C equivalent of an I2C bus scan, but it also assigns addresses in the process.

Provisioned ID (PID). Each I3C target device has a 48-bit Provisioned ID that uniquely identifies its manufacturer and part number. During ENTDAA, each target reports its PID, and the controller uses this to assign dynamic addresses.

SDR (Single Data Rate). The standard I3C communication mode, running at up to 12.5 MHz on a push-pull clock. This is the mode we will use for our first transaction.

Wiring

Connect the Supernova to your I3C target device:

Supernova Pin	Target Pin	Function
SDA	SDA	I3C data (bidirectional)
SCL	SCL	I3C clock
GND	GND	Common ground

The I3C bus requires pull-up resistors on SDA (typically 2 kOhm to VDD). SCL does not need a pull-up in I3C mode (it uses push-pull drive). Many I3C evaluation boards include the required pull-ups. If using a bare device, add a 2 kOhm pull-up on SDA to the target’s VDD supply.

Power the target device from its own supply. The Supernova does not provide target power.

Step 1: Install Dependencies

pip install binho

Step 2: Initialize the Supernova as I3C Controller

from binho import binhoHostAdapter

## Connect to Supernova
supernova = binhoHostAdapter.binhoHostAdapter()

## Configure as I3C controller
supernova.setOperationMode(0, 'I3C')
print("Supernova configured as I3C controller")

The Supernova initializes its I3C controller engine, which manages bus timing, address tables, and protocol state.

Step 3: Run Dynamic Address Assignment (ENTDAA)

ENTDAA is the process by which the I3C controller discovers target devices and assigns them dynamic addresses. The Supernova handles the ENTDAA protocol sequence automatically, you initiate it with a single API call.

## Run ENTDAA, discover and assign addresses to all targets
targets = supernova.i3cENTDAA()

if len(targets) == 0:
    print("No I3C targets found. Check wiring and power.")
else:
    for target in targets:
        print(f"Target found:")
        print(f"  Provisioned ID: {target['pid']}")
        print(f"  BCR: 0x{target['bcr']:02X}")
        print(f"  DCR: 0x{target['dcr']:02X}")
        print(f"  Dynamic Address: 0x{target['dynamic_addr']:02X}")

If your target device is wired correctly and powered, ENTDAA will discover it and assign a dynamic address (typically starting at 0x08). The output shows the device’s Provisioned ID (which identifies the manufacturer and part number), BCR (Bus Characteristics Register), DCR (Device Characteristics Register), and the assigned dynamic address.

Step 4: Read Data from the Target

With a dynamic address assigned, you can now perform I3C read and write transactions. The exact register addresses depend on your specific target device, consult its datasheet.

For a generic first read (reading the first 4 bytes from the device):

## Read 4 bytes from the target at its assigned dynamic address
target_addr = targets[0]['dynamic_addr']

data = supernova.i3cRead(target_addr, 4)
print(f"Read from 0x{target_addr:02X}: {[hex(b) for b in data]}")

For devices with register-based access (most sensors), you write the register address first, then read:

## Write register address, then read register value
register_addr = 0x00  # Device ID register (varies by device)
supernova.i3cWrite(target_addr, [register_addr])
reg_value = supernova.i3cRead(target_addr, 2)
print(f"Register 0x{register_addr:02X} = {[hex(b) for b in reg_value]}")

Step 5: Send a Common Command Code (CCC)

CCCs are broadcast or directed commands that manage the I3C bus. A useful CCC to try is GETPID (Get Provisioned ID), which reads the target’s 48-bit Provisioned ID:

## Send GETPID CCC to the target
pid_data = supernova.i3cSendCCC('GETPID', target_addr)
print(f"Provisioned ID: {[hex(b) for b in pid_data]}")

Other commonly used CCCs include GETBCR (read Bus Characteristics Register), GETDCR (read Device Characteristics Register), and GETSTATUS (read target status).

Troubleshooting

No targets found during ENTDAA. Check that the target device is powered and that SDA and SCL are connected correctly. Verify the SDA pull-up resistor is present. Some I3C devices require a specific power-on reset sequence before they respond to ENTDAA.

ENTDAA finds a device but reads return errors. Confirm the target device supports the I3C version your transaction assumes. Some early I3C devices have limited CCC support or require specific initialization sequences before data transfers work.

Intermittent communication errors. Check bus signal integrity. I3C’s push-pull SCL and open-drain SDA have specific impedance requirements. Long wires or breadboard connections can cause signal reflections that corrupt transactions.

What Comes Next

With a basic I3C transaction working, you can explore more advanced I3C features:

In-Band Interrupts: Configure the Supernova to monitor and handle IBIs from target devices
HDR-DDR mode: Transfer data at higher speeds using Double Data Rate encoding
Multi-target buses: Discover and communicate with multiple I3C targets on the same bus

For engineering teams in Bengaluru, Hyderabad, and Pune evaluating I3C for next-generation sensor platforms, this tutorial provides the foundation. The Supernova’s combination of I3C exerciser capability and the Python SDK makes it practical to explore I3C bus behavior interactively before committing to silicon or firmware architecture decisions.

Why Buy from GSAS

GSAS Micro Systems is the authorized Binho engineering partner in India. We provide the Supernova with INR invoicing and I3C-specific technical support. Our applications engineers in Bengaluru, Hyderabad, Chennai, Pune, Mumbai, and Delhi NCR assist with I3C bus architecture review, device bring-up, and integration into existing development workflows. Contact us for evaluation units or a hands-on I3C tutorial session.