How to use Rpi3 to receive I2C data from Arduino-based sensors

Question

I am trying to format data from several Arduino-based systems so my Rpi3 can display it as a web page. But the Rpi3 seems to only work as an I2C master, and the Arduinos have little memory in which to store data.

The sensors include weather and a solar panel sun tracker. Arduino has no problem sending out the data to other Arduinos. The only device on my I2C bus with the memory to do the data logging is the Rpi3.

It looks like the alternative is to do some kind of polling but then I am faced with the question of how often to poll each device, etc. And the Arduinos then would have to spend much more time looking for the requests. My Arduino programs utilize specific delay() times (like when they are moving the solar panels) so interrupts would be a problem in maintaining proper timing.

If there is a solution whereby I can have the Rpi3 waiting for data to come in, then I can handle the programming to do the rest.

So my question is: Is there a good way to set up the Rpi3 to wait for the data and process it as it comes in?

Answer 1

pigpio (from V57) now supports the Raspberry Pi acting as a I2C slave device.

The core function is the C bsc_xfer.

The Python wrapper bsc_i2c provides an I2C slave interface.

As a test between a Pi3 and an Arduino Pro Mini I used the following code.

On the Pi3.

#!/usr/bin/env python

import time
import pigpio

I2C_ADDR=9

def i2c(id, tick):
   global pi

   s, b, d = pi.bsc_i2c(I2C_ADDR)

   if b:

      print(d[:-1])

pi = pigpio.pi()

if not pi.connected:
    exit()

# Respond to BSC slave activity

e = pi.event_callback(pigpio.EVENT_BSC, i2c)

pi.bsc_i2c(I2C_ADDR) # Configure BSC as I2C slave

time.sleep(600)

e.cancel()

pi.bsc_i2c(0) # Disable BSC peripheral

pi.stop()

On the Arduino Pro Mini.

// This example code is in the public domain.


#include <Wire.h>

void setup()
{
   Wire.begin(); // join i2c bus as master
}

char str[17];

int x = 0;

void loop()
{
   sprintf(str, "Message %7d\n", x);
   if (++x > 9999999) x=0;

   Wire.beginTransmission(9); // transmit to device #9
   Wire.write(str);           // sends 16 bytes
   Wire.endTransmission();    // stop transmitting

   delay(50);
}

So the Arduino is sending 20 16-byte messages per second (16 is the slave receive FIFO size so it is a sensible maximum message size).

The Python was executing on a Linux laptop networked with the Pi.

Over a 600 second period the Arduino sent 11526 messages. The Python saw 11018 (95.6%).

The missing messages could be detected by the gap between successive message numbers which should always be 1. The actual gap counts were

  count gap
  10855 1
      9 2
     20 3
     95 4
     32 5
      1 6
      3 7
      1 8
      2 9

The performance seems perfectly reasonable to me for a userland solution. Occasionally there will be inconvenient reschedules. I'd expect better figures if the Python was running on the local Pi.

I repeated the test on a local Pi and all the sent messages were received error free (100%).

Answer 2

Is there a good way to set up the Rpi3 to wait for the data and process it as it comes in?

Probably not via I2C [normatively; see joan's answer], although you could try and see what happens if you request information from a slave allowing an indeterminant amount of time for the request to complete, then just implement things on the Arduino such that you assume such a request is always pending (which it could be if this works, and you do the pi side implementation appropriately). It may be that such requests will fail quickly, but that could be leveraged by making requests at intervals and only processing the ones that don't throw an error.

Otherwise you'd have to poll (sucessfully) for information at intervals, but that would lead to this:

the Arduinos then would have to spend much more time looking for the requests. My Arduino programs utilize specific delay() times (like when they are moving the solar panels) so interrupts would be a problem in maintaining proper timing.

Regarding which I'd say if your ISR just sets a volatile boolean indicating a request is ready, then you handle that outside the ISR in your main loop, the ISR is unlikely to take more than a few microseconds to execute, which I doubt is going to create any timing problems for you moving solar panels.

However, doing things the other way around should not be hard if you are determined to avoid any possible interference. When new data is ready, send an interrupt to the Pi using a non I2C pin; the Arduino could then wait for the request, which should be very quick, reply, and continue on.