How to use i2cdev with third party libs?

[dizcza]

I'd like to port an ssd1306 driver from elsewhere, for example from here https://github.com/nopnop2002/esp-idf-ssd1306, in my project that already uses i2cdev. Rewriting all the commands to be completely i2cdev-friendly is tedious.

How should one use i2cdev with other i2c libs?

I thought to wrap everything in

typedef struct {
    i2c_dev_t i2c_dev;
    ...
} SSD1306_t;

    // only once
    i2c_dev_create_mutex(&dev->i2c_dev)

    // function body
    I2C_DEV_TAKE_MUTEX(&dev->i2c_dev);
    SEMAPHORE_TAKE(dev->i2c_dev.port);

    // custom i2c commands

    SEMAPHORE_GIVE(dev->i2c_dev.port);
    I2C_DEV_GIVE_MUTEX(&dev->i2c_dev);

but SEMAPHORE_TAKE and SEMAPHORE_GIVE are hidden in i2cdev.c.

[UncleRus]

Hi!
You don't need to call internal macros. Just use common interface of i2cdev, i2c_dev_read...() and i2c_dev_write...() functions.
The nopnop's driver is not the best choice for porting to i2cdev: it has too many low-level i2c calls. You can port other driver, such as suggested in #74 or use an already ported driver: https://github.com/UncleRus/esp-idf-lib/tree/ssd1306/components/ssd1306

[riwalker]

Thank you for the code, much appreciated, and works great (and helpful as we use the other library parts already)
Are there any more examples (vs the provided graphic image) of how to use this library for TEXT on a SSSD1306 ?

[dizcza]

Just use common interface of i2cdev, i2c_dev_read...() and i2c_dev_write...() functions

That's what I mean tedious to do. Just have a look at the original

static bool I2CDefaultWriteBytes( int Address, bool IsCommand, const uint8_t* Data, size_t DataLength ) {
    i2c_cmd_handle_t* CommandHandle = NULL;
    static uint8_t ModeByte = 0;

    NullCheck( Data, return false );

    if ( ( CommandHandle = i2c_cmd_link_create( ) ) != NULL ) {
        ModeByte = ( IsCommand == true ) ? SSD1306_I2C_COMMAND_MODE: SSD1306_I2C_DATA_MODE;

        ESP_ERROR_CHECK_NONFATAL( i2c_master_start( CommandHandle ), return false );
            ESP_ERROR_CHECK_NONFATAL( i2c_master_write_byte( CommandHandle, ( Address << 1 ) | I2C_MASTER_WRITE, true ), return false );
            ESP_ERROR_CHECK_NONFATAL( i2c_master_write_byte( CommandHandle, ModeByte, true ), return false );
            ESP_ERROR_CHECK_NONFATAL( i2c_master_write( CommandHandle, ( uint8_t* ) Data, DataLength, true ), return false );
        ESP_ERROR_CHECK_NONFATAL( i2c_master_stop( CommandHandle ), return false );

        ESP_ERROR_CHECK_NONFATAL( i2c_master_cmd_begin( I2CPortNumber, CommandHandle, pdMS_TO_TICKS( 1000 ) ), return false );
        i2c_cmd_link_delete( CommandHandle );
    }

    return true;
}

and i2cdev rewritten version

static bool I2CDefaultWriteBytes(int Address, bool IsCommand,
                                 const uint8_t *Data, size_t DataLength) {

  NullCheck(Data, return false);
  ESP_ERROR_CHECK_NONFATAL(i2c_dev_take_mutex(&dev), return false);
  ESP_ERROR_CHECK_NONFATAL(
      i2c_dev_write_reg(&dev,
                        (IsCommand == true) ? SSD1306_I2C_COMMAND_MODE
                                            : SSD1306_I2C_DATA_MODE,
                        Data, DataLength),
      do {
        i2c_dev_give_mutex(&dev);
        return false;
      } while (0));
  ESP_ERROR_CHECK_NONFATAL(i2c_dev_give_mutex(&dev), return false);
  return true;
}

Clearly, not an obvious substitution for an outsider who is not into i2cdev. Especially in the case of I2C calls flooding as it's in nopnop's repo.

I had a look at https://github.com/UncleRus/esp-idf-lib/tree/ssd1306/components/ssd1306 and found no functions to draw text. Also, it's not clear in which state the code is - is it plug and play or proof of concept.

[UncleRus]

Clearly, not an obvious substitution for an outsider who is not into i2cdev.

This looks more than obvious to me, but you are probably right.
Suggest how to make it more obvious. Maybe describe in the documentation, give examples of porting ...

Also, it's not clear in which state the code is - is it plug and play or proof of concept.

This is a stable and working driver tested with all protocols (I2C, SPI3, SPI4). It was not merged into the master due to the decision not to include display drivers in this repo. Yes, it does not work with fonts, but you can add this functionality yourself or, for example, use this driver as a backend for the HAGL library, which can draw text.

[dizcza]

This looks more than obvious to me, but you are probably right.
Suggest how to make it more obvious. Maybe describe in the documentation, give examples of porting ...

I suggest adding the example I shown above in FAQ. It's descriptive and shows how to do the porting.

Still, it'd be nice to have a semaphore lock accessible as I suggested in the first comment. Wrapping everything in mutex and semahore lock will ensure that no change has been made to the original raw i2c calls.

[UncleRus]

Excellent! Could you do a PR?

[dizcza]

Which solution would you like to see - adding how-to into FAQ or making the macros public? In the latter case, two public functions - taking and releasing the semaphore given the port - will be added.

[UncleRus]

Both of it. And please see CONTRIBUTING.md before creating a PR

[dizcza]

I'm having trouble porting this lib https://github.com/nopnop2002/esp-idf-24c/blob/master/components/at24c/at24c.c to i2cdev. I think it's a good example to add in the PR too.

The one-byte-address functions are rewritten in:

static esp_err_t ReadReg8(EEPROM_t * dev, int chip_addr, uint8_t data_addr, uint8_t * data)
{
    esp_err_t err = i2c_dev_take_mutex(&dev->i2c_dev);
    if (err != ESP_OK) {
        return err;
    }
    dev->i2c_dev.addr = chip_addr;
    err = i2c_dev_read_reg(&dev->i2c_dev, data_addr, data, 1);
    i2c_dev_give_mutex(&dev->i2c_dev);
    if (err != ESP_OK) {
        ESP_LOGW(TAG, "ReadReg8 %s", esp_err_to_name(err));
    }
    return err;
}

static esp_err_t WriteReg8(EEPROM_t * dev, int chip_addr, uint8_t data_addr, uint8_t data)
{
    esp_err_t err = i2c_dev_take_mutex(&dev->i2c_dev);
    if (err != ESP_OK) {
        return err;
    }
    dev->i2c_dev.addr = chip_addr;
    err = i2c_dev_write_reg(&dev->i2c_dev, data_addr, &data, 1);
    i2c_dev_give_mutex(&dev->i2c_dev);
    usleep(1000*2);
    if (err != ESP_OK) {
        ESP_LOGW(TAG, "WriteReg8 %s", esp_err_to_name(err));
    }
    return err;
}

but I don't know how to rewrite ReadReg16 and WriteReg16 functions because they operate on the two-bytes address.

[dizcza]

I think I understood the pattern.

static esp_err_t ReadReg16(EEPROM_t * dev, int chip_addr, uint16_t data_addr, uint8_t * data)
{
    esp_err_t err = i2c_dev_take_mutex(&dev->i2c_dev);
    if (err != ESP_OK) {
        return err;
    }
	uint8_t high_addr = (data_addr >> 8) & 0xff;
	uint8_t low_addr = data_addr & 0xff;
	uint8_t addr16[] = {high_addr, low_addr};
	err = i2c_dev_read(&dev->i2c_dev, addr16, 2, data, 1);
    i2c_dev_give_mutex(&dev->i2c_dev);
    if (err != ESP_OK) {
        ESP_LOGW(TAG, "ReadReg16 %s", esp_err_to_name(err));
    }
	return err;
}

static esp_err_t WriteReg16(EEPROM_t * dev, int chip_addr, uint16_t data_addr, uint8_t data)
{
    esp_err_t err = i2c_dev_take_mutex(&dev->i2c_dev);
    if (err != ESP_OK) {
        return err;
    }
    uint8_t high_addr = (data_addr >> 8) & 0xff;
    uint8_t low_addr = data_addr & 0xff;
    uint8_t addr16[] = {high_addr, low_addr};
    err = i2c_dev_write(&dev->i2c_dev, addr16, 2, &data, 1);
    i2c_dev_give_mutex(&dev->i2c_dev);
    if (err != ESP_OK) {
        ESP_LOGW(TAG, "WriteReg16 %s", esp_err_to_name(err));
    }
    return err;
}

[riwalker]

anyone ? TEXT + FONT example ? please help
(with the already ported driver: https://github.com/UncleRus/esp-idf-lib/tree/ssd1306/components/ssd1306)?

[riwalker]

I figured it out, took 2 days, wrote the module as an extension to the existing graphic display

[Ketaries]

Hi ! I would be interested to see how you did this, would you mind sharing your implementation ? Thanks in advance.