I2C communication does not work with IDF but it does with Arduino

PlatformIO IDE
, ,
1

Good day esteemed.

Currently, I am attempting to set up a capacitive keyboard (Integrated CY8CMBR3116) with I2C communication to an ESP32-S3, which I am programming using IDF libraries through PlatformIO in Visual Studio Code. I am encountering an issue with I2C communication. I configure the I2C and send the write and read frames as indicated in the datasheet (see Figure 19, 20, and 21), but it never writes or allows me to read the registers of this controller (SEE CODE 1). On the other hand, I have code in Arduino (SEE CODE 2), which does work for me. I only did this to verify since I am currently programming everything on ESP32-S3 with IDF and would like to continue with it.

Could you assist me with “CODE 1” in case I have some error that I am not aware of that might affect the writing and reading of CY8CMBR3116 registers?

image
image694Ă—511 67.1 KB

CODE1 (configurations):

#define I2C_MASTER_NUM          I2C_NUM_0
#define I2C_MASTER_SCL_IO       GPIO_NUM_19
#define I2C_MASTER_SDA_IO       GPIO_NUM_18
#define I2C_MASTER_FREQ_HZ      10000
#define CY8CMBR3116_ADDR        0x37
#define GPO_OUTPUT_STATE        0x80
#define SENSOR_EN               0x00
#define BUTTON_LBR              0x1F
#define SENSITIVITY0            0x08
#define SENSITIVITY1            0x09
#define SENSITIVITY2            0x0A
#define SENSITIVITY3            0x0B
#define BUTTON_STAT             0xAA
#define CTRL_CMD                0x86
#define SAVE_CHECK_CRC          0x02
#define SW_RESET                0xFF
#define DEVICE_ID               0x90
#define BUZZER_CFG              0x3E
#define SLIDER_CFG              0x5D
#define SPO_CFG                 0x4C
#define GPIO_INT_CY8CMBR3116    GPIO_NUM_41
#define GPIO_INT_CY8CMBR3116_MASK           (1ULL<<GPIO_NUM_41)
//Definicion de flag para las INT
#define ESP_INTR_FLAG_DEFAULT       0



*******************************WRITE*******************************
void configureCY8CMBR3116(void)
{
    // Configurar el CY8CMBR3116 para detectar teclas presionadas
    unsigned char configData[128] = {
    0xFFu, 0xFFu, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x80u, 0x80u, 0x80u, 0x80u,
    0x80u, 0x80u, 0x80u, 0x80u, 0x80u, 0x80u, 0x80u, 0x80u,
    0x80u, 0x80u, 0x80u, 0x80u, 0x03u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x80u,
    0x05u, 0x00u, 0x00u, 0x02u, 0x00u, 0x02u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x1Eu, 0x1Eu, 0x00u,
    0x00u, 0x1Eu, 0x1Eu, 0x00u, 0x00u, 0x00u, 0x01u, 0x01u,
    0x00u, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu,
    0xFFu, 0x00u, 0x00u, 0x00u, 0x14u, 0x03u, 0x01u, 0x58u,
    0x00u, 0x37u, 0x06u, 0x00u, 0x00u, 0x0Au, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x88u, 0x95u
};
    esp_err_t ret=-1;
    i2c_cmd_handle_t cmd;

    while(ret==-1){

        ret=0;
            
        cmd = i2c_cmd_link_create();
        ret=i2c_master_start(cmd);
        ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        //ret=i2c_master_write_byte(cmd, SENSOR_EN, true);
        //ret=i2c_master_write_byte(cmd, 0x00, true);
        //ret=i2c_master_stop(cmd);
        //ret=i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 100 / portTICK_PERIOD_MS);
        //i2c_cmd_link_delete(cmd);



        //cmd = i2c_cmd_link_create();
        ret=i2c_master_start(cmd);
        ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        ret=i2c_master_write_byte(cmd, SENSOR_EN, true);
        //ret=i2c_master_write_byte(cmd, 0x00, true);
        //ret=i2c_master_stop(cmd);
        //ret=i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS);
        //i2c_cmd_link_delete(cmd);



        //cmd = i2c_cmd_link_create();
        //ret=i2c_master_start(cmd);
        //ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        //ret=i2c_master_write_byte(cmd, SENSOR_EN, true);
        ret=i2c_master_write(cmd, &configData[0], 31, true);
        //ret=i2c_master_stop(cmd);


        //ret=i2c_master_start(cmd);
        //ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        //ret=i2c_master_write_byte(cmd, BUTTON_LBR, true);
        ret=i2c_master_write(cmd, &configData[31], 31, true);
        //ret=i2c_master_stop(cmd);


        //ret=i2c_master_start(cmd);
        //ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        //ret=i2c_master_write_byte(cmd, BUZZER_CFG, true);
        ret=i2c_master_write(cmd, &configData[62], 31, true);
        //ret=i2c_master_stop(cmd);


        //ret=i2c_master_start(cmd);
        //ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        //ret=i2c_master_write_byte(cmd, SLIDER_CFG, true);
        ret=i2c_master_write(cmd, &configData[93], 31, true);
        //ret=i2c_master_stop(cmd);



        //ret=i2c_master_start(cmd);
        //ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        //ret=i2c_master_write_byte(cmd, 0x7C, true);
        ret=i2c_master_write(cmd, &configData[124], 4, true);
        ret=i2c_master_stop(cmd);
        //ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 100 / portTICK_PERIOD_MS);


        

        ret=i2c_master_start(cmd);
        ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        ret=i2c_master_write_byte(cmd, CTRL_CMD, true);
        ret=i2c_master_write_byte(cmd,SAVE_CHECK_CRC, true);
        //ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 200 / portTICK_PERIOD_MS);
        //ret=i2c_master_stop(cmd);
        //ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 100 / portTICK_PERIOD_MS);


        vTaskDelay(200 / portTICK_PERIOD_MS);



        ret=i2c_master_start(cmd);
        ret=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        ret=i2c_master_write_byte(cmd, CTRL_CMD, true);
        ret=i2c_master_write_byte(cmd,SW_RESET, true);
        //ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 200 / portTICK_PERIOD_MS);
        ret=i2c_master_stop(cmd);

        if(ret==ESP_OK){
            printf("Transmission SW_RESET CHECK OKEY");
        }

        //vTaskDelay(200 / portTICK_PERIOD_MS);
        
        i2c_cmd_link_delete(cmd);

        if(ret==-1){
            printf("ERROR CONFIG I2C\n");
        }
        vTaskDelay(2000 / portTICK_PERIOD_MS);
    }



    return;
}




*******************************READ*******************************
void readKeypadState(void *pvParameters)
{

    uint8_t rx_data[10];
    esp_err_t ret2=0;
    // uint8_t command[126] = {0x01};
    vTaskDelay(2000 / portTICK_PERIOD_MS);
    configureCY8CMBR3116();
    vTaskDelay(2000 / portTICK_PERIOD_MS); // Espera un segundo antes de enviar nuevamente
    i2c_cmd_handle_t cmd;


    while (1)
    {
/*
        cmd2 = i2c_cmd_link_create();
        ret2=i2c_master_start(cmd2);
        ret2=i2c_master_write_byte(cmd2, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        ret2=i2c_master_write_byte(cmd2, BUTTON_STAT, true); // DirecciĂłn del registro SENSITIVITY0
        ret2=i2c_master_stop(cmd2);
        
        ret2=i2c_master_read(cmd2, &rx_data[0], 2, true);

        i2c_cmd_link_delete(cmd2);


*/
        //Ubico el puntero en el registro BUTTON_STAT
        cmd = i2c_cmd_link_create();
        ret2=i2c_master_start(cmd);
        ret2=i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_WRITE, true);
        ret2=i2c_master_write_byte(cmd, BUTTON_STAT, true);  // Dirección del registro SENSOR_EN (cualquier registro de lectura servirá)
        ret2=i2c_master_start(cmd);
        i2c_master_write_byte(cmd, (CY8CMBR3116_ADDR << 1) | I2C_MASTER_READ, true);
        i2c_master_read(cmd, rx_data, sizeof(rx_data), I2C_MASTER_ACK);
        i2c_master_stop(cmd);
        //i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 1000 / portTICK_PERIOD_MS);
        i2c_cmd_link_delete(cmd);
        


        for(int j=0;j<10;j++)
            printf("ESTADO TECLADO%d: %u\n",j,rx_data[j]);

        if(ret2==-1){
            printf("ERROR READ I2C\n");
        }

        

        vTaskDelay(1000 / portTICK_PERIOD_MS); // Espera un segundo antes de enviar nuevamente
    }
    
}









*******************************PIN CONFIG*******************************
static esp_err_t i2c_master_init(void)
{
    i2c_config_t confi2c;
    confi2c.mode = I2C_MODE_MASTER;
    confi2c.sda_io_num = I2C_MASTER_SDA_IO;
    confi2c.scl_io_num = I2C_MASTER_SCL_IO;
    confi2c.sda_pullup_en = GPIO_PULLUP_ENABLE;
    confi2c.scl_pullup_en = GPIO_PULLUP_ENABLE;
    confi2c.master.clk_speed = I2C_MASTER_FREQ_HZ; // Velocidad del reloj I2C en Hz
    confi2c.clk_flags = 0;
    i2c_param_config(I2C_MASTER_NUM, &confi2c);
    i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, 0, 0, 0);

    return ESP_OK;
}













void app_main()
{
    Init_Pulsador_OFF();
    i2c_master_init();

    // Inicializacion del Queue para las interrupciones
    gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));

    xTaskCreate(INTERRUPTION_TASK, "INTERRUPTION_TASK", 2048, NULL, 6, NULL);
    // Crea la tarea para leer el estado de las teclas capacitivas
    xTaskCreate(readKeypadState, "read_task", configMINIMAL_STACK_SIZE * 3, NULL, 7, NULL);
}

CODE 2:



#define SLAVE_ADDR  0x37
#define REGMAP_ORIGIN        0x00  
#define BUTTON_LBR          0x1F
#define BUZZER_CFG          0x3E
#define SLIDER_CFG          0x5D
#define CTRL_CMD            0x86
#define SAVE_CHECK_CRC          0x02
#define SW_RESET                0xFF

*******************************WRITE*******************************
void configCY8CMBR3102()
{
  int writeerr = 0;
  
  //Write dummy data
  Wire.beginTransmission(x); // transmit to device #0x37
  Wire.write(REGMAP_ORIGIN);          // sends Offset byte 
  Wire.write(00);
  Wire.endTransmission();    // stop transmitting
  
  Wire.beginTransmission(SLAVE_ADDR); // transmit to device #0x37
  Wire.write(REGMAP_ORIGIN);          // sends Offset byte 
  Wire.write(00);
  Wire.endTransmission();    // stop transmitting
  
  //Arduino function can send only 31 bytes of data
  //So whole frame is send in chunks
  //from [0] to [30]
  Wire.beginTransmission(SLAVE_ADDR); 
  Wire.write(REGMAP_ORIGIN);      //0     
  size_t sendedSize = Wire.write(&configData[0],31);        
  Wire.endTransmission();   
  
  writeerr = Wire.getWriteError();
  
  if(writeerr == 0) {
     Serial.print("First packet sended\n");
  }

  //from [31] to [61]
  Wire.beginTransmission(SLAVE_ADDR);
  Wire.write(BUTTON_LBR);         //31
  sendedSize = Wire.write(&configData[31],31);
  Wire.endTransmission(); 

  writeerr = Wire.getWriteError();
  
  if(writeerr == 0) {
     Serial.print("Second packet sended\n");
  }

  //from [62] to [92]
  Wire.beginTransmission(SLAVE_ADDR);
  Wire.write(BUZZER_CFG);          //62 
  sendedSize = Wire.write(&configData[62],31);
  Wire.endTransmission();

  writeerr = Wire.getWriteError();
  
  if(writeerr == 0) {
     Serial.print("Third packet sended\n");
  }

  //from [93] to [123]
  Wire.beginTransmission(SLAVE_ADDR);
  Wire.write(SLIDER_CFG);         //93
  sendedSize = Wire.write(&configData[93],31);
  Wire.endTransmission();

  writeerr = Wire.getWriteError();
  
  if(writeerr == 0) {
     Serial.print("Fourth packet sended\n");
  }

  //from [124] to [127]
  Wire.beginTransmission(SLAVE_ADDR); 
  Wire.write(0x7C);         //124
  sendedSize = Wire.write(&configData[124],4);        
  Wire.endTransmission();    

  writeerr = Wire.getWriteError();
  
  if(writeerr == 0) {
     Serial.print("Fifth packet sended\n");
  }

  /*
  Write 0x02 to 0x86 
  Info from datasheet
  The device calculates a CRC checksum over the configuration data in this register map and
  compares the result with the content of CONFIG_CRC. If the two values match, the device saves
  the configuration and the CRC checksum to nonvolatile memory.
  */
  Wire.beginTransmission(SLAVE_ADDR); // transmit to device #0x37
  Wire.write(CTRL_CMD);
  Wire.write(SAVE_CHECK_CRC);
  Wire.endTransmission();    // stop transmitting
  
  delay(200);

  //Reset
  Wire.beginTransmission(SLAVE_ADDR); 
  Wire.write(CTRL_CMD);
  Wire.write(SW_RESET);
  Wire.endTransmission();    // stop transmitting
  
  delay(200);
}








*******************************READ*******************************
void ReadAndDisplaySensorStatus()
{
  char readedData[2] = {0x00};

  Wire.beginTransmission(SLAVE_ADDR);
  Wire.write(BUTTON_STATUS);        
  Wire.endTransmission();
  
  int i=0;


  Wire.requestFrom(SLAVE_ADDR, 2); //2 bytes for whole BUTTON_STATUS
  while(Wire.available())  
  { 
    readedData[i] = Wire.read();
    Serial.print("Hex: 0x"); 
    Serial.print(readedData[i], HEX); 
    Serial.print("\n"); 
    i++;
  }
  Wire.endTransmission();
      
  DisplaySensorStatus(&readedData[0]); 
  delay(1000);
  
}






void setup()
{
  Wire.begin(18,19);  
  Serial.begin(115200);  // start serial for output
  //For single chip is need to be call only once.
  //If do not change configuration 
  configCY8CMBR3102();
  Serial.print("Device configurated\n");
}

void loop()
{
   ReadAndDisplaySensorStatus();
  delay(50);
}
2

Do you have one of those cheap $10 logic analyzers? Hook it up to the I2C lines, capture the I2C traffic with each of the firmwares, compare the differences. If the sent and receive data match, you know the error is in the retrieval or interpretations of the result. If there’s a difference in sent data (and thus probably also received data), you will know exactly which transaction is wrong and can investigate there.

1 Like
3

Yes, that’s the next thing I’m going to try. However, I wanted to know if I have any conceptual errors in setting up the register write and read functions. Tanks

4

You solved? It would be very useful for me too. I’m provonda but I have the same problems as you. A thousand thanks

5

Are you using the same Integrated CY8CMBR3116?

6

Yes, the same device.

7

I ended up implementing it with the Arduino framework because I couldn’t get it to work properly with IDF.

I implemented it a while ago, here is what I did.
Best regards.

Code:
/// @brief Este array es automaticamente definido utilizando la aplicacion EZ-Click 2.0 de Cypress
/// @param I2C_address 0x37
/// @param State_Timeout 60 segundos (tiempo antes de entrar en modo bajo consumo)
/// @param GPO_drive_mode Open Drain Low
/// @param GPO_logic_level Active low
/// @param Host_Interrupt_PIN HI/BUZ/GPO7
/// @param Buzzer none
/// @param Shield OFF
/// @param Guard_sensor ON
/// @param GPIO_host_control OFF
/// @param Auto_reset_period 5
/// @param LED_duration 0
/// @param EMC_noise_immunity ON
/// @param Automatic_thrshold OFF
/// @param Supply_voltage 1.8-5.5
/// @param Debounce 5 (tiempo entre presiones)
/// @param Number_of_Sliders 0
/// @param Number_of_Proximidity_Sensors 0
/// @param IIR_filter ON
/// @param Median_filter ON
/// @param Scan_period 250ms (No muy alto, sino cuando sale del modo “Timeout” tarda mucho en reconocer nuevamente)
/// @param BOTTOM_ENABLE ALL ON (Except PAD)
/// @param Sensitibity 200 (definir segun material que se coloque en frente del teclado)
/// @param FSS ALL OFF (Esto es para que solo se detecte un boton a la vez)
/// @param Finger_Threshold ALL 200 (menos sensibles)
/// @see https://www.infineon.com/dgdl/Infineon-EZ-Click_User_Guide_001-90407_C-Software-v01_00-EN.pdf?fileId=8ac78c8c7d0d8da4017d0f69a4505cf1&da=t#page=16&zoom=100,64,176

unsigned char configData[128] = {
0xFFu, 0xFEu, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x55u, 0x55u, 0x54u, 0x55u, 0x64u, 0x64u, 0x64u, 0x64u,
0x64u, 0x64u, 0x64u, 0x64u, 0x7Fu, 0x64u, 0x64u, 0x64u,
0x64u, 0x64u, 0x64u, 0x64u, 0x04u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x80u,
0x05u, 0x00u, 0x00u, 0x02u, 0x00u, 0x02u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x1Eu, 0x1Eu, 0x00u,
0x00u, 0x1Eu, 0x1Eu, 0x00u, 0x00u, 0x00u, 0x01u, 0x01u,
0x00u, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu,
0xFFu, 0x00u, 0x00u, 0x00u, 0x14u, 0x03u, 0x01u, 0x5Au,
0x00u, 0x37u, 0x06u, 0x00u, 0x00u, 0x3Cu, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x65u, 0xA0u
};

/// @brief Configuracion Inicial para teclado con IC CY8CMBR3116
/// @param configData datos de configuracion.
/// @see unsigned char configData[128]
void ConfigCY8CMBR3116(void)
{
int writeerr = 0;

//Write dummy data
Wire.beginTransmission(SLAVE_ADDR_TECLADO1); // transmit to device #0x37
Wire.write(REGMAP_ORIGIN); // sends Offset byte
Wire.write(00);
Wire.endTransmission(); // stop transmitting

Wire.beginTransmission(SLAVE_ADDR_TECLADO1); // transmit to device #0x37
Wire.write(REGMAP_ORIGIN); // sends Offset byte
Wire.write(00);
Wire.endTransmission(); // stop transmitting

//This function send only 31 bytes of data
//So whole frame is send in chunks
//from [0] to [30]
Wire.beginTransmission(SLAVE_ADDR_TECLADO1);
Wire.write(REGMAP_ORIGIN); //0
size_t sendedSize = Wire.write(&configData[0],31);
Wire.endTransmission();

writeerr = Wire.getWriteError();

if(writeerr == 0) {
Serial.print(“First packet sended\n”);
}

//from [31] to [61]
Wire.beginTransmission(SLAVE_ADDR_TECLADO1);
Wire.write(BUTTON_LBR); //31
sendedSize = Wire.write(&configData[31],31);
Wire.endTransmission();

writeerr = Wire.getWriteError();

if(writeerr == 0) {
Serial.print(“Second packet sended\n”);
}

//from [62] to [92]
Wire.beginTransmission(SLAVE_ADDR_TECLADO1);
Wire.write(BUZZER_CFG); //62
sendedSize = Wire.write(&configData[62],31);
Wire.endTransmission();

writeerr = Wire.getWriteError();

if(writeerr == 0) {
Serial.print(“Third packet sended\n”);
}

//from [93] to [123]
Wire.beginTransmission(SLAVE_ADDR_TECLADO1);
Wire.write(SLIDER_CFG); //93
sendedSize = Wire.write(&configData[93],31);
Wire.endTransmission();

writeerr = Wire.getWriteError();

if(writeerr == 0) {
Serial.print(“Fourth packet sended\n”);
}

//from [124] to [127]
Wire.beginTransmission(SLAVE_ADDR_TECLADO1);
Wire.write(0x7C); //124
sendedSize = Wire.write(&configData[124],4);
Wire.endTransmission();

writeerr = Wire.getWriteError();

if(writeerr == 0) {
Serial.print(“Fifth packet sended\n”);
}

/*
Write 0x02 to 0x86
Info from datasheet
The device calculates a CRC checksum over the configuration data in this register map and
compares the result with the content of CONFIG_CRC. If the two values match, the device saves
the configuration and the CRC checksum to nonvolatile memory.
*/
Wire.beginTransmission(SLAVE_ADDR_TECLADO1); // transmit to device #0x37
Wire.write(CTRL_CMD);
Wire.write(SAVE_CHECK_CRC);
Wire.endTransmission(); // stop transmitting

delay(200);

//Reset
Wire.beginTransmission(SLAVE_ADDR_TECLADO1);
Wire.write(CTRL_CMD);
Wire.write(SW_RESET);
Wire.endTransmission(); // stop transmitting

delay(200);

return;
}

/// @brief COnfiguracion de pines I2C
/// @param I2C_MASTER_SDA pin 35 para datos
/// @param I2C_MASTER_SCL pin 36 para clock
/// @param I2C_MASTER_FREQ_HZ frecuencia de 100khz
void Config_PIN_I2C(void){
Wire.begin(I2C_MASTER_SDA,I2C_MASTER_SCL);
Wire.setClock(I2C_MASTER_FREQ_HZ);
digitalWrite(I2C_MASTER_SDA, LOW); // Desactivar pull-up
digitalWrite(I2C_MASTER_SCL, LOW); // Desactivar pull-up
Serial.begin(115200); // start serial for output

return;
}