Bela, python and I2C

moscardo

Hi,

for a project I'm working on, I need to read a relatively high number of analog sensors (24) and make an appropriate sonification. I will connect all of these sensors to some ADC and connect those on the I2C bus.

My idea is to collect all of these data using python (and maybe crunch them a little) and then transmit them to sclang via OSC for sclang to create the related sonification.

So my question is: how can I read the I2C bus using python on my Bela? Is there some preinstalled module I can use?

My Bela is a rev.C3. The ADC converter I'm using are the Adafruit ADS7830 (). In the future I will also need to use some I2C mux like the Adafruit PCA9546;

Thank you so much for your support
n

giuliomoro

Have you considered using the Bela multiplexer capelet? https://learn.bela.io/products/accessories/multiplexer/ That gives you enough channels and it's already supported within Supercollider.

moscardo

Thank you so much @giuliomoro ,

yes I've considered tu use the capelet however, we have a number of limitations in terms of both space and aesthetics that force me to keep the form factors in a certain way, and I cannot further enlarge the stack of cards.

In addition, the convenience of using a single I2C bus helps me in terms of cable organization and significantly reduces their quantity, at least those that converge on the Bela.

In addiotion to that I will still need to use the I2C bus to read IMU modules, so I cannot do without this communication interface.

So I return to the question I asked a moment ago:

how can I read the I2C bus using python on my Bela? Is there some preinstalled module I can use?

giuliomoro

I don't know how you'd go about doing that with python. I2c is exposed via the i2c-dev driver, so anything that can open files and use ioctls should do and I assume there are plenty of libraries available.

Now, I have to ask what's so important about doing it in python? It you are sampling the inputs at a reasonably high rate, it adds overhead and latency. You could probably write something simple enough in C++ that sends OSC to Supercollider.

Something like this should be a good starting point, and you only need to fill in the sensor-specific stuff.

#include <vector>
#include <string>
#include <unistd.h>

#define OSCPKT_OSTREAM_OUTPUT
#include "oscpkt.hh"
#include <iostream> // needed for udp.hh
#include "udp.hh"

#include <signal.h>
int shouldStop = 0;

void interrupt_handler(int var)
{
	shouldStop = true;
}

static oscpkt::UdpSocket gSock;
static int sendOscFloats(const std::string& address, float* values, unsigned int size);

int main(int argc, char** argv)
{
	int i2cBus = -1;
	gSock.connectTo("localhost", 1234);

	signal(SIGINT, interrupt_handler);
	std::vector<float> values;
	values.resize(numSensors);
	// TODO: initialise sensors and multiplexers
	while(!shouldStop) {
		for(unsigned int n = 0; n < values.size(): ++n) {
			float val;
			// TODO: read sensor n into val
			values[n] = val
		}
		sendOscFloats("/adc", values.data(), values.size());
		usleep(100000); // reduce to increase rate
	}
	return 0;
}

int sendOsc(const oscpkt::Message& msg)
{
	oscpkt::PacketWriter pw;
	pw.addMessage(msg);
	bool ok = gSock.sendPacket(pw.packetData(), pw.packetSize());
	if(!ok) {
		fprintf(stderr, "could not send\n");
		return -1;
	}
	return 0;
}

int sendOscFloats(const std::string& address, float* values, unsigned int size)
{
	if(!size)
		return 0;
	oscpkt::Message msg(address);
	for(unsigned int n = 0; n < size; ++n)
		msg.pushFloat(values[n]);
	return sendOsc(msg);
}

moscardo

Thank you so much @giuliomoro,

The fact is that I'm not that fluent in C++ and, in some ways, I feel more comfortable with Python, not to mention that I'm working with some colleagues at the same time and Python is mostly the common language for us.

However, I'll try to study what you've shared with me to understand how to proceed in general.

Thank you very much for your support,
talk to you soon.
n

moscardo

At the end I've installed smbus2 (for python2) in order to make the python script communicate with devices on the I2C bus.

My colleagues and I end up with a code like the one below:

# first sketch to test I2C communication
# In this test I'm using:
# * an Adafruit PCA9546 4-Channel I2C Multiplexer;
# * an Adafruit ADS7830 8-Channel 8-Bit ADC with I2C;

import time
from smbus2 import SMBus

# ADC single channel read registers
SINGLE_CH0 = 0x08
SINGLE_CH1 = 0x0C

# ADC power down slection bits
POWER_DOWN_BETWEEN_CONVERSIONS = 0x00
INTERNAL_REF_OFF_ADC_ON        = 0x01
INTERNAL_REF_ON_ADC_OFF        = 0x02
INTERNAL_REF_ON_ADC_ON         = 0x03 # default


def readADCSingle(bus, addr, ch, pd=INTERNAL_REF_ON_ADC_ON):
    cmd = 0
    if ch % 2 == 0:
        cmd = cmd | (SINGLE_CH0 + (ch // 2))
    else:
        cmd = cmd | (SINGLE_CH1 + ((ch - 1) // 2))

    cmd = cmd << 4
    cmd = cmd | (pd << 2)

    return bus.read_byte_data(addr, cmd)


with SMBus(1) as bus:

    # select I2C bus from I2C mux breakout board (PCA9546A)
    I2C_BUS = 0
    bus.write_byte(0x70, 1 << I2C_BUS)

    # read analog values from a specific ADC
    ADC_ADDR = 0x48

    while True:
        adc_values = []
        for i in range(8):
            adc_values.append( readADCSingle( bus, ADC_ADDR, i ) )

        #print adc_values
        print '\t'.join(map(str, adc_values))

        #wait some time between readings
        time.sleep(0.01)