I2C issues (121 remote i/o error)

Ward The weird thing is that at the point where I only create a single instance of the PCA9685 class it worked fine. Once I created a second instance not a single ẁriteRegister() call succeeded anymore. Reverting back to only creating one instance of the class doesn't make a difference.

You mean now it no longer works even with just one instance? Have you tried a hard reboot (power off and back on)?

There is also another thing: the address you write to is actually specified in the ioctl(i2C_file, I2C_SLAVE, i2C_address) cal in I2c::initI2C_RW. I think that you could change that at any time. So, could you try to factor that out so that it gets called once before each transaction, and so that all your instances use an underlying basic object that only opens the file descriptor, but each call to write() is preceded by an ioctl()?

Also, do you get any relevant message if you run dmesg after the error occurs?

Here is an example of a project that was using two I2C sensors at the same time, if that helps to double check things. https://github.com/BelaPlatform/Bela/blob/master/examples/10-Instruments/d-box/DboxSensors.cpp

Hmmm actually I was thinking something more like:

I2CBasic::setFileHandleFrom(I2CBasic& i2c)
{
    i2C_file = i2c.i2C_file;
}

I2CBasic::setAddress(unsigned int address)
{
    i2C_address = address;
}

bool I2CBasic::writeRegister(unsigned address, unsigned reg)
{
        // target device as slave at stored address
        if (ioctl(i2C_file, I2C_SLAVE, i2C_address) < 0){
            cout << "I2C_SLAVE address " << i2C_address << " failed..." << endl;
            return(2);
        }	
	char buf[2] = { static_cast<char>(reg & 0xFF), static_cast<char>(val & 0xFF) };
	
	// Write a single byte
	if(write(i2C_file, buf, 2) != 2)
	{
		int err = errno;
		rt_printf("Failed to write! Register %i\tAdress %i\tError %i\n", static_cast<int>(reg), address, err);
		return false;
	}
	
	// Close I2C file
	if (closeI2C() > 0)
		return false;
	
	return true;
}

Then you would have your application code like:

I2CBasic i2cBasic1;
I2CBasic i2cBasic2;
unsigned int address1 = 40;
unsigned int address2 = 41;

bool setup(BelaContext* context, void*)
{
    // init the first one from scratch
    if(i2cBasic1.initI2C_RW(bus, address1, 0) > 0)
    {
         int err = errno;
        fprintf(stderr, "Something happened while initializing the I2c connection. \tError code %i\n", err);
		return false;
    }
    // the second instance re-uses the same open file as the first one
    i2cBasic2.setFileHandleFrom(i2cBasic1);
    // and we only sets the address
    i2cBasic2.setAddress(address2); 
    ...
    // ... so that each call to writeRegister will have the `ioctl()` (to set the register) followed by 
    // `write()`, with both objects acting on the same file handler
    if(!i2cBasic1.writeRegister(...))
      return false;
    ...
    if(!i2cBasic2.writeRegister(...))
        return false;
    return true;
}

This is a bit ugly, and could definitely be refactored, but just see if this helps in any way. The example I linked above (10-Instruments/d-box) actually successfully opens the /dev/i2c... file twice, once for each instance, so I am not sure this would help, but worth giving it a try.

so I got the boards, and I ran the code below and it works:

#include <Bela.h>
#include <pca9685.h>

PCA9685 pwm1;
PCA9685 pwm2;
PCA9685 pwm3;

bool setup(BelaContext* context, void* userData) {

	pwm1.begin(0x40);
	pwm2.begin(0x41);
	pwm3.begin(0x42);

	pwm1.setPWM(15, 0);
	pwm2.setPWM(15, 0);
	pwm3.setPWM(15, 0);
	usleep(1000000);
	pwm1.setPWM(15, 4000);
	pwm2.setPWM(15, 4000);
	pwm3.setPWM(15, 4000);
	usleep(1000000);
	for(unsigned int n = 0; n < 10; ++n)
	{
		pwm1.setPWM(15, 0);
		pwm2.setPWM(15, 4000);
		pwm3.setPWM(15, 4000);
		usleep(300000);
		pwm1.setPWM(15, 4000);
		pwm2.setPWM(15, 0);
		pwm3.setPWM(15, 4000);
		usleep(300000);
		pwm1.setPWM(15, 4000);
		pwm2.setPWM(15, 4000);
		pwm3.setPWM(15, 0);
		usleep(300000);
	}
	pwm1.setPWM(15, 4095);
	pwm2.setPWM(15, 4095);
	pwm3.setPWM(15, 4095);
	return true;
}

void render(BelaContext* context, void* userData) {
}

void cleanup(BelaContext* context, void* userData) {
}

see proof here:

The only problems I encountered were weak/wobbly "jumpers" for the addresses: I don't have a soldering iron here, so I just taped some stranded wire across the pads. Initially, I was cutting the plastic sleeve off. This proved to be fairly unreliable, that a given board would occasionally (often!) change address. When that happened while the program was running, I would then get the 121 error. However, even if one of the boards failed (because of wrong address), the others would still work, and when two boards were on the same address, you could just address them both in one go!
However, now that I leave the sleeve in place, as in the pic below, this is much more reliable:

I tried running the above also in an AuxiliaryTask, and it all works as expected. E.g.:

#include <Bela.h>
#include <pca9685.h>

PCA9685 pwm1;
PCA9685 pwm2;
PCA9685 pwm3;

void auxFunc(void*)
{
	pwm1.setPWM(15, 0);
	pwm2.setPWM(15, 0);
	pwm3.setPWM(15, 0);
	usleep(1000000);
	pwm1.setPWM(15, 4000);
	pwm2.setPWM(15, 4000);
	pwm3.setPWM(15, 4000);
	usleep(1000000);
	for(unsigned int n = 0; n < 10; ++n)
	{
		if(gShouldStop)
			return;
		pwm1.setPWM(15, 0);
		pwm2.setPWM(15, 4000);
		pwm3.setPWM(15, 4000);
		usleep(300000);
		pwm1.setPWM(15, 4000);
		pwm2.setPWM(15, 0);
		pwm3.setPWM(15, 4000);
		usleep(300000);
		pwm1.setPWM(15, 4000);
		pwm2.setPWM(15, 4000);
		pwm3.setPWM(15, 0);
		usleep(300000);
	}
	pwm1.setPWM(15, 4095);
	pwm2.setPWM(15, 4095);
	pwm3.setPWM(15, 4095);
}

bool setup(BelaContext* context, void* userData) {

	pwm1.begin(0x40);
	pwm2.begin(0x41);
	pwm3.begin(0x42);
	Bela_scheduleAuxiliaryTask(Bela_createAuxiliaryTask(auxFunc, 90, "i2c", NULL));
	return true;
}

void render(BelaContext* context, void* userData) {
}

void cleanup(BelaContext* context, void* userData) {
}

So, I am not sure what is the problem you are encountering, but I would suggest:
- check your hardware connections and the jumper
- make sure i2cdetect reliably detects the correct address. I run it like this watch -n0.2 i2cdetect -y -r 1 so it refreshes automatically every 0.2 seconds. Remember to stop this when running the Bela program, as it may interfere with that one, as both use the bus.
- make sure you use 0x if you are specifying the hex address (and viceversa, don't use it if you are not). Pretty basic, I know, but it got me a couple of times today!