raspberrypi i2ctarget transactions are spread across multiple requests

[anecdata]

CircuitPython version and board name

Adafruit CircuitPython 10.0.0-alpha.6-2-gc6e4d72cd3 on 2025-05-21; Pimoroni Pico Plus 2 W with rp2350b
(adafruit-circuitpython-pimoroni_pico_plus2w-en_US-20250521-main-PR10366-c6e4d72.uf2)

Code/REPL

raspberrypi i2ctarget code (only reads):

import board
from i2ctarget import I2CTarget

I2C_ADDRESS = 0x40

# Pico Plus 2 W
with I2CTarget(scl=board.GP5, sda=board.GP4, addresses=(I2C_ADDRESS,)) as device:
    while True:
        req = device.request(timeout=-1)  # Zero means wait forever, a negative value means check once
        if not req:
            continue
        with req as r:
            inbuf = r.read(-1)  # n – Number of bytes to read (negative means all)
            print(f"READ {len(inbuf)} {inbuf}")

I2C Controller code (only writes):

import time
import board

I2C_ADDRESS = 0x40

# UnexpectedMaker FeatherS3
i2c = board.STEMMA_VERTICAL_I2C()

while True:
    outbuf = bytearray(b'abcd')
    print(f"WRITE {outbuf} ", end="")
    while not i2c.try_lock():
        pass
    try:
        i2c.writeto(I2C_ADDRESS, outbuf)
        print(f"written")
    except Exception:
        print(f"not written")
    i2c.unlock()

    time.sleep(2)

Behavior

I2C Controller output:

WRITE bytearray(b'abcd') written
WRITE bytearray(b'abcd') written
WRITE bytearray(b'abcd') written
WRITE bytearray(b'abcd') written

i2ctarget output:

READ 2 bytearray(b'ab')
READ 2 bytearray(b'cd')
READ 1 bytearray(b'a')
READ 3 bytearray(b'bcd')
READ 1 bytearray(b'a')
READ 3 bytearray(b'bcd')
READ 1 bytearray(b'a')
READ 3 bytearray(b'bcd')

Description

Using post-alpha.6 firmware that incorporates the i2ctarget request deinit fix for raspberrypi. i2ctarget code works as expected on atmel-samd, even with very large transaction payloads. raspberrypi handles 1 or 2 bytes OK, but anything larger gets split across multiple requests unpredictably. The end result is that it's impossible to delineate separate transactions.

Additional information

No response

[anecdata]

This more elaborate version runs fine on atmel-samd, and should(?) run on raspberrypi. Very large variable-sized payloads, and CRC checking to verify that what's written is what's read.

atmel-samd i2ctarget (only reads):

code.py

import time
import binascii
import board
import busio
from i2ctarget import I2CTarget

I2C_ADDRESS = 0x40

# Feather M4 Express
with I2CTarget(scl=board.SCL, sda=board.SDA, addresses=(I2C_ADDRESS, 0x41)) as device:
    print(f"{time.monotonic_ns()} START 0x{I2C_ADDRESS:02X}")
    while True:
        req = device.request(timeout=-1)  # Zero means wait forever, a negative value means check once
        if not req:
            print(f"{time.monotonic_ns()}", end="\r")
            continue
        with req:
            print()
            if not req.is_read:  # incoming request is a write  # req.is_restart == False
                inbuf = req.read(n=-1)  # n – Number of bytes to read (negative means all)
 
                body = inbuf[0:len(inbuf)-8]
                crc_calc = f"{binascii.crc32(body):08x}".encode()
                crc_read = inbuf[len(inbuf)-8:len(inbuf)]
                if crc_calc == crc_read:
                    print(f"{time.monotonic_ns()} 🟢 READ {len(inbuf)} {crc_calc} {crc_read} {inbuf}")
                else:
                    print(f"{time.monotonic_ns()} 🟠 READ {req.address} {len(inbuf)} {crc_calc} {crc_read} {inbuf}")

I2C Controller (only writes):

code.py

import time
import random
import binascii
import board

I2C_ADDRESS = 0x40

# UnexpectedMaker FeatherS3
i2c = board.STEMMA_VERTICAL_I2C()

while True:
    outbuf = bytearray()
    data_length = random.randrange(0, 500)
    for _ in range(0, data_length):
        outbuf.extend(f"{random.randrange(0, 256):02X}".encode())
    crc = f"{binascii.crc32(outbuf):08x}".encode()
    outbuf.extend(crc)
    print(f"WRITE {outbuf} ", end="")
    while not i2c.try_lock():
        pass
    try:
        i2c.writeto(I2C_ADDRESS, outbuf)
        print(f"written")
    except Exception:
        print(f"not written")
    i2c.unlock()

    time.sleep(2)

i2ctarget:

output

34928829895030
34928906677252 🟢 READ 794 b'29e59ddd' bytearray(b'29e59ddd') bytearray(b'E3E860EA30C96C08F71ECEC17D667606434FD3D4C02A4B221455FB4991FAA0D10A2E569D825C48D22334F50095F61D362481DA7779CA23BCC14EC65E794FF1D2EDB47FDEC2D37D1D99C33BA435899EA501F805D32EA663B3268CDD63700B55BE1D75A479C93B43E808073E3EEB3E440F17011F6EA29DD1454426CF44C96EC8A84927E2922F5FEF7FBD7E73C9EE3C90B16FEBB7956ADDF36F24212EF5242E29F948FFBD476AF723C5CB9F2080C15071E47F056934A6AD532875AFFC9D8473FF6B25E6D9D11723E871CEB40E53853C7DFA11344BED8EEA4E3B5CA2CF665B256754C86D52EAEB6346017602C05B40E2B646A2CFADB6B04083920A66E7E30B94EEBF7B6932D15DB5434E247D9CB9AB4FDA90404B7730D5DB2FCF0F1EAAFBEBE2120EC269C6738FFA05D78F3C70B54A75EDA78651C676AD27D31DA579B7260782F2931A633AD618215D258C1C380FBE82289EBE0762330F430775BADB53C605A56DF024D47877C7A16499DF58B0E804A31512C1449791BBA04F3EF0B472D3AE8B7AFFC7B28D252FAC223E4829e59ddd')
34929311706545
34929321838386 🟢 READ 104 b'd8e1c65e' bytearray(b'd8e1c65e') bytearray(b'18A124B71FAB49141AA7E67D883C8DDC1675C34AEDCDC0C8EDA940D48BC36D43DAAFD925084D396382AC0927B1671474d8e1c65e')
34930941955574

[anecdata]

I've tried typical variations on the timeout kwarg in the I2CTarget request. Also typical variations on the n (number of bytes to read) kwarg in the request read. Same behavior for all variations.