Wire i2c slave code works on SAMD, but not on RP2040

[charkster]

Hi, I wrote Arduino code to make a MCU appear as an I2C slave device with a 256 byte register map. This works great for SAMD MCUs, but the same .ino code does not work on RP2040. It looks like has to do with the Wire library buffer. The code below works for my Adafruit QT PY SAMD21 board (I do not need to explicitly define the SDA and SCL pins, they are in the board file). It also works fine on my Adafruit ItsyBits SAMD51 board.
I have tried this code on Pico and Xiao RP2040, and get identical results... slave ID is ACKed, but reading back written data is not at the expected address.

I'm using version 4.4.2 of your Raspberry Pi Pico/RP2040/RP2350 board library, and I use a RP2040 MicroPython I2C master (which drives the I2C master cycles identically for the SAMD slave). I have looked at the cycles with a logic analyzer and everything looks as expected.

Any ideas as to why the Pico handles the code below differently would be appreciated.
Thx

#include <Wire.h>
volatile uint8_t address;
volatile uint8_t memory_map [256]; // array is initialize all low values

#define SLAVE_ID 0x3C

void setup()
{
  Wire.begin(SLAVE_ID);         // join i2c bus with slave_id SLAVE_ID
  Wire.onReceive(receiveEvent); // register write to slave
  Wire.onRequest(requestEvent); // register read from slave
}

void loop()
{
  delay(100);
}

// function that executes when the master writes data to this slave
void receiveEvent(int bytes)
{
  address = Wire.read(); // read first byte to determine address
  while (Wire.available())
  {
    memory_map[address++] = Wire.read();
  }

}

// function that executes when the master reads from this slave
void requestEvent()
{
  address = Wire.read(); // read first byte to determine address
  Wire.write(memory_map[address++]);
  for (int i = 0; i < 32; i++) // this is needed for multibyte reads, up to 32 bytes
  {
    Wire.write(memory_map[address++]);
  }
}

[earlephilhower]

The SAMD51 and RP2040 have completely different I2C hardware blocks so low-level operations will be different between them. They're also being driven internally by massively different speeds of processor so race conditions which don't show up in one can appear in the other. There's also obviously setup/hold timing to verify.

That said, since this needs some other HW and SW only you have, your best step is to see where the issue is manifesting. For example, after writing some series of registers, were they all written in the right spot? You can dump the register state in the loop every second or something and have a test run in the master randomly writing things and keeping track of what it thinks should be in the slave Pico. You can then just eyeball the 2 states after a test and see. The TalkingToMyself example does something like this via loopback wires using 2 cores and 2 I2C interfaces. And you can load known patterns in the slave Pico and randomly read out and compare in the master...

[charkster]

Thanks for the quick response @earlephilhower . Your suggestions helped me to find the root cause. The Wire.onRequest() call appears to be clearing the buffer on the RP2040 (it doesn't clear on the SAMD implementation). The workaround is very simple... just don't use the buffer when an I2C read cycle is detected... have the address stay at the same value from the write cycle's Wire.onReceive(). I am testing the fix on my SAMD and other MCU boards, to see if this implementation works for all my boards.
Thank you again!
-charkster

Here is the fixed version (updated to support a 16bit address, 64k bytes):

#include <Wire.h>
volatile uint8_t  address_upper;
volatile uint8_t  address_lower;
volatile uint16_t address;
volatile uint8_t  memory_map [65536]; // array is initialize all low values

#define SLAVE_ID 0x3c

void setup()
{
  Wire1.setSDA(6);
  Wire1.setSCL(7);
  Wire1.begin(SLAVE_ID);         // join i2c bus with slave_id SLAVE_ID
  Wire1.onReceive(receiveEvent); // register write to slave
  Wire1.onRequest(requestEvent); // register read from slave
}

void loop()
{
  delay(100);
}

// function that executes when the master writes data to this slave
void receiveEvent(int bytes)
{
  address_upper = Wire1.read(); // first byte is upper
  address_lower = Wire1.read(); // second byte is lower
  address = (address_upper << 8) | address_lower;
  while (Wire1.available())
  {
    memory_map[address++] = Wire1.read(); // third byte and higher are write data
  }
}

// function that executes when the master reads from this slave
void requestEvent()
{
  Wire1.write(memory_map[address++]); // address previously defined in the receiveEvent
  for (int i = 0; i < 32; i++) // this is needed for multibyte reads, up to 32 bytes
  {
    Wire1.write(memory_map[address++]); // total buffer size is 32 bytes including address
  }
}