En el mundo de la tecnología, la comunicación entre diferentes dispositivos es esencial para el funcionamiento adecuado de los sistemas. En este tutorial, exploraremos la comunicación I2C en el ESP32, analizando la configuración de los pines, las múltiples interfaces de bus y los periféricos compatibles. ¡Prepárate para adentrarte en el fascinante mundo de la comunicación digital con el ESP32! ¡Bienvenidos, nerds de la tecnología!

El ESP32 tiene dos interfaces de bus I2C que pueden servir como maestro o esclavo I2C. En este tutorial, veremos el protocolo de comunicación I2C con ESP32 usando el IDE de Arduino: cómo seleccionar pines I2C, conectar múltiples dispositivos I2C al mismo bus y cómo usar las dos interfaces de bus I2C.

En este tutorial cubriremos los siguientes conceptos:

• Conecte dispositivos I2C a ESP32
• Escanear la dirección I2C con ESP32
• Utilice diferentes pines I2C con ESP32 (cambie los pines I2C predeterminados)
• ESP32 con múltiples dispositivos I2C
  • Mismo autobús, diferentes direcciones.
  • la misma dirección
• ESP32 con dos interfaces de bus I2C
• ESP32 I2C Maestro y Esclavo (comunicación I2C entre dos ESP32)

Programamos el ESP32 con Arduino IDE. Por lo tanto, antes de continuar con este tutorial, debes tener instalado el complemento ESP32 en tu IDE de Arduino. Siga el siguiente tutorial para instalar ESP32 en el IDE de Arduino si aún no lo ha hecho.

• Instalación de la Placa ESP32 en el IDE Arduino (Instrucciones para Windows, Mac OS X y Linux)

Introducción al protocolo de comunicación ESP32 I2C

I²C significa Inter Iintegrado Circuit (pronunciado I-square-C) es un protocolo de comunicaciones síncrono multimaestro-multi-esclavo. Puedes conectarte:

• varios esclavos para un maestro: Por ejemplo, su ESP32 lee desde un sensor BME280 a través de I2C y escribe los valores del sensor en una pantalla OLED I2C.
• Varios maestros controlan el mismo esclavo: Por ejemplo, dos tarjetas ESP32 escriben datos en la misma pantalla OLED I2C.

A menudo utilizamos este protocolo con el ESP32 para comunicarnos con dispositivos externos como sensores y pantallas. En estos casos, el ESP32 es el chip maestro y los dispositivos externos son los esclavos.

Tenemos varios tutoriales sobre la interfaz ESP32 con dispositivos I2C:

• Pantalla OLED I2C de 0,96 pulgadas con ESP32
• Placa OLED ESP32 integrada
• Pantalla LCD I2C con ESP32
• BMP180 con ESP32
• BME280 con ESP32

Interfaces de bus ESP32 I2C

El ESP32 admite la comunicación I2C a través de sus dos interfaces de bus I2C, que pueden servir como maestro o esclavo I2C según la configuración del usuario. Según la hoja de datos de ESP32, las interfaces I2C de ESP32 admiten:

• Modo estándar (100 Kbit/s)
• Modo rápido (400 Kbit/s)
• Hasta 5MHz pero limitado por la fuerza de pull-up SDA
• Modo de direccionamiento de 7 bits/10 bits
• Modo de direccionamiento dual. Los usuarios pueden programar registros de comando para controlar las interfaces I²C, lo que les brinda más flexibilidad.

Conecte dispositivos I2C a ESP32

El protocolo de comunicación I2C utiliza dos cables para intercambiar información. Uno se utiliza para la señal del reloj (SCL) y el otro se utiliza para enviar y recibir datos (ASD).

Nota: En muchas placas de conexión, la línea SDA también puede denominarse SDI y la línea SCL como SCK.

Las líneas SDA y SCL están activas en nivel bajo, por lo que deben elevarse con resistencias. Los valores típicos son 4,7 kOhm para dispositivos de 5 V y 2,4 kOhm para dispositivos de 3,3 V.

La mayoría de los sensores que utilizamos en nuestros proyectos son placas de conexión que ya tienen resistencias integradas. Cuando se trabaja con este tipo de componentes electrónicos, normalmente no hay que preocuparse por esto.

Conectar un dispositivo I2C a un ESP32 suele ser tan sencillo como conectar GND a GND, SDA a SDA, SCL a SCL y una fuente de alimentación positiva a un periférico, normalmente de 3,3V (aunque esto depende del módulo utilizado).

dispositivo I2C	ESP32
ASD	SDA (el valor predeterminado es GPIO21)
SCL	SCL (el valor predeterminado es GPIO22)
Dimensiones	Dimensiones
VCC	normalmente 3,3 V o 5V

Cuando se utiliza el ESP32 con Arduino IDE, los pines I2C estándar GPIO22 (SCL) y GPIO21 (SDA), pero también puedes configurar tu código para usar otros pines.

Recomendaciones de literatura: Manual de referencia ESP32 GPIO

Escanear la dirección I2C con ESP32

Con la comunicación I2C, cada esclavo en el bus tiene su propia dirección, un número hexadecimal que permite al ESP32 comunicarse con cada dispositivo.

La dirección I2C generalmente se puede encontrar en la hoja de datos del componente. Sin embargo, si es difícil de determinar, es posible que necesite ejecutar un boceto del escáner I2C para averiguar la dirección I2C.

Puede utilizar el siguiente boceto para encontrar la dirección I2C de su dispositivo.

/*********
  Rui Santos
  Complete project details at https://randomnerdtutorials.com  
*********/

#include <Wire.h>
 
void setup() {
  Wire.begin();
  Serial.begin(115200);
  Serial.println("nI2C Scanner");
}
 
void loop() {
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for(address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address<16) {
        Serial.print("0");
      }
      Serial.println(address,HEX);
      nDevices++;
    }
    else if (error==4) {
      Serial.print("Unknow error at address 0x");
      if (address<16) {
        Serial.print("0");
      }
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0) {
    Serial.println("No I2C devices foundn");
  }
  else {
    Serial.println("donen");
  }
  delay(5000);          
}

Ver código sin formato

Obtendrá algo similar en su monitor serie. Este ejemplo específico es para una pantalla LCD I2C.

---

Utilice diferentes pines I2C con ESP32 (cambie los pines I2C predeterminados)

Con el ESP32 puedes configurar casi cualquier pin para que sea compatible con I2C, solo tienes que especificarlo en tu código.

Si está utilizando el ESP32 con el IDE de Arduino, utilice el Alambre.h Biblioteca para comunicación con dispositivos vía I2C. Con esta biblioteca inicializas I2C de la siguiente manera:

Wire.begin(I2C_SDA, I2C_SCL);

Por lo tanto, solo necesita tener los GPIO SDA y SCL deseados en el I2C_SDA Y I2C_SCL Variables.

Sin embargo, si utiliza bibliotecas para comunicarse con estos sensores, es posible que esto no funcione y que sea un poco difícil seleccionar otros pines. Esto se debe a que estas bibliotecas podrían sobrescribir sus pines si no pasa los suyos. cable Instancia al inicializar la biblioteca.

En estos casos es necesario mirar más de cerca. .cpp Biblioteca de archivos y aprende a crear los tuyos propios dos hilos Parámetro.

Por ejemplo, si miras el Biblioteca Adafruit BME280descubrirás que eres tuyo dos hilos Para el comenzar() Método.

El boceto de ejemplo para leer desde BME280 a través de otros pines, por ejemplo GPIO33 como SDA y y GPIO32 como SCL es el siguiente.

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-i2c-communication-arduino-ide/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

#define I2C_SDA 33
#define I2C_SCL 32

#define SEALEVELPRESSURE_HPA (1013.25)

TwoWire I2CBME = TwoWire(0);
Adafruit_BME280 bme;

unsigned long delayTime;

void setup() {
  Serial.begin(115200);
  Serial.println(F("BME280 test"));
  I2CBME.begin(I2C_SDA, I2C_SCL, 100000);

  bool status;

  // default settings
  // (you can also pass in a Wire library object like &Wire2)
  status = bme.begin(0x76, &I2CBME);  
  if (!status) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }

  Serial.println("-- Default Test --");
  delayTime = 1000;

  Serial.println();
}

void loop() { 
  printValues();
  delay(delayTime);
}

void printValues() {
  Serial.print("Temperature = ");
  Serial.print(bme.readTemperature());
  Serial.println(" *C");
  
  // Convert temperature to Fahrenheit
  /*Serial.print("Temperature = ");
  Serial.print(1.8 * bme.readTemperature() + 32);
  Serial.println(" *F");*/
  
  Serial.print("Pressure = ");
  Serial.print(bme.readPressure() / 100.0F);
  Serial.println(" hPa");

  Serial.print("Approx. Altitude = ");
  Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
  Serial.println(" m");

  Serial.print("Humidity = ");
  Serial.print(bme.readHumidity());
  Serial.println(" %");

  Serial.println();
}

Ver código sin formato

Echemos un vistazo a las partes relevantes sobre el uso de otros pines I2C.

Primero defina sus nuevos pines I2C en el I2C_SDA Y I2C_SCL Variables. En este caso utilizamos GPIO33 Y GPIO32.

#define I2C_SDA 33
#define I2C_SCL 32

Crea uno nuevo dos hilos instancia. En este caso dice I2CBMEEsto simplemente crea un bus I2C.

TwoWire I2CBME = TwoWire(0);

En el configuración()Inicialice la comunicación I2C con los pines que definió anteriormente. El tercer parámetro es la frecuencia del reloj.

I2CBME.begin(I2C_SDA, I2C_SCL, 400000);

Finalmente, inicialice un objeto BME280 con la dirección de su sensor y su dos hilos Objeto.

status = bme.begin(0x76, &I2CBME);

Luego puede utilizar los métodos habituales en su bme Objeto para consulta de temperatura, humedad y presión.

Nota: si la biblioteca que está utilizando tiene una declaración como cable.comenzar() En el archivo, es posible que necesites comentar esta línea para poder usar tus propios pines.

---

ESP32 con múltiples dispositivos I2C

Como se mencionó anteriormente, cada dispositivo I2C tiene su propia dirección. Por lo tanto, es posible ejecutar varios dispositivos I2C en el mismo bus.

Múltiples dispositivos I2C (mismo bus, diferentes direcciones)

Si tenemos varios dispositivos con diferentes direcciones, la configuración es bastante sencilla:

• Conecte ambos dispositivos periféricos con las líneas ESP32 SCL y SDA.
• En el código, haga referencia a cada dispositivo periférico por su dirección.

Considere el siguiente ejemplo, que recupera los valores del sensor de un sensor BME280 (a través de I2C) y muestra los resultados en una pantalla OLED I2C.

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-i2c-communication-arduino-ide/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

Adafruit_BME280 bme;

void setup() {
  Serial.begin(115200);

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  
  bool status = bme.begin(0x76);  
  if (!status) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
  
  delay(2000);
  display.clearDisplay();
  display.setTextColor(WHITE);
}

void loop() {
  display.clearDisplay();
  // display temperature
  display.setTextSize(1);
  display.setCursor(0,0);
  display.print("Temperature: ");
  display.setTextSize(2);
  display.setCursor(0,10);
  display.print(String(bme.readTemperature()));
  display.print(" ");
  display.setTextSize(1);
  display.cp437(true);
  display.write(167);
  display.setTextSize(2);
  display.print("C");
  
  // display humidity
  display.setTextSize(1);
  display.setCursor(0, 35);
  display.print("Humidity: ");
  display.setTextSize(2);
  display.setCursor(0, 45);
  display.print(String(bme.readHumidity()));
  display.print(" %"); 
  
  display.display();

  delay(1000);
}

Ver código sin formato

Dado que OLED y BME280 tienen direcciones diferentes, podemos usar fácilmente las mismas líneas SDA y SCL. La dirección de la pantalla OLED es Versión: y la dirección BME280 es Versión: 0x76.

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { 
  Serial.println(F("SSD1306 allocation failed"));
  for(;;);
}
  
bool status = bme.begin(0x76);  
if (!status) {
  Serial.println("Could not find a valid BME280 sensor, check wiring!");
  while (1);
}

Recomendaciones de literatura: Pantalla OLED ESP32 con Arduino IDE

Múltiples dispositivos I2C (misma dirección)

¿Pero qué pasa si tienes varios periféricos con la misma dirección? Por ejemplo, ¿varias pantallas OLED o múltiples sensores BME280? Hay varias soluciones.

• Cambie la dirección I2C del dispositivo.
• Utilice un multiplexor I2C.

Cambiar la dirección I2C

Muchas placas de conexión ofrecen la opción de cambiar la dirección I2C según el circuito. Esto se muestra, por ejemplo, mirando la siguiente pantalla OLED.

Al poner la resistencia en un lado o en el otro, puedes seleccionar diferentes direcciones I2C. Esto también sucede con otros componentes.

Usando un multiplexor I2C

Sin embargo, en este ejemplo anterior, sólo puedes tener dos pantallas I2C en el mismo bus: una con dirección 0x3C y otra con dirección 0x3D.

Además, a veces no es fácil cambiar la dirección I2C. Entonces, para tener varios dispositivos con la misma dirección en el mismo bus I2C, puede usar un multiplexor I2C como el TCA9548A, que le permite comunicarse con hasta 8 dispositivos con la misma dirección.

Tenemos un tutorial detallado que explica cómo conectar varios dispositivos con la misma dirección al ESP32 usando un multiplexor I2C: Instrucciones para multiplexores I2C TCA9548A: ESP32, ESP8266, Arduino.

---

ESP32 con dos interfaces de bus I2C

Para utilizar las dos interfaces de bus I2C del ESP32, necesita dos dos hilos Instancias.

TwoWire I2Cone = TwoWire(0);
TwoWire I2Ctwo = TwoWire(1)

Luego inicialice la comunicación I2C en los pines deseados con una frecuencia definida.

void setup() {
  I2Cone.begin(SDA_1, SCL_1, freq1);
  I2Ctwo.begin(SDA_2, SCL_2, freq2); 
}

Luego puede utilizar los métodos del Alambre.h Biblioteca para interactuar con las interfaces del bus I2C.

Una alternativa más sencilla es utilizar los predefinidos. Cable() Y Cable1() Objetos. Cable().comenzar() crea comunicación I2C en el primer bus I2C utilizando los pines y la frecuencia estándar. Para el Cable1.begin() Debes pasar los pines SDA y SCL que desees, así como la frecuencia.

setup(){
  Wire.begin(); //uses default SDA and SCL and 100000HZ freq
  Wire1.begin(SDA_2, SCL_2, freq);
}

Este método le permite utilizar dos buses I2C, uno de los cuales utiliza los parámetros predeterminados.

Para comprender mejor cómo funciona esto, veamos un ejemplo sencillo que lee la temperatura, la humedad y la presión de dos sensores BME280.

Cada sensor está conectado a un bus I2C diferente.

• Autobús I2C 1: usado GPIO27 (ADS) y GPIO26 (SCL);
• Autobús I2C 2: usado GPIO33 (ADS) y GPIO32 (SCL);

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-i2c-communication-arduino-ide/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

#define SDA_1 27
#define SCL_1 26

#define SDA_2 33
#define SCL_2 32

TwoWire I2Cone = TwoWire(0);
TwoWire I2Ctwo = TwoWire(1);

Adafruit_BME280 bme1;
Adafruit_BME280 bme2;

void setup() {
  Serial.begin(115200);
  Serial.println(F("BME280 test"));

  I2Cone.begin(SDA_1, SCL_1, 100000); 
  I2Ctwo.begin(SDA_2, SCL_2, 100000);

  bool status1 = bme1.begin(0x76, &I2Cone);  
  if (!status1) {
    Serial.println("Could not find a valid BME280_1 sensor, check wiring!");
    while (1);
  }
  
  bool status2 = bme2.begin(0x76, &I2Ctwo);  
  if (!status2) {
    Serial.println("Could not find a valid BME280_2 sensor, check wiring!");
    while (1);
  }
  
  Serial.println();
}

void loop() { 
  // Read from bme1
  Serial.print("Temperature from BME1= ");
  Serial.print(bme1.readTemperature());
  Serial.println(" *C");

  Serial.print("Humidity from BME1 = ");
  Serial.print(bme1.readHumidity());
  Serial.println(" %");

  Serial.print("Pressure from BME1 = ");
  Serial.print(bme1.readPressure() / 100.0F);
  Serial.println(" hPa");

  Serial.println("--------------------");

  // Read from bme2
  Serial.print("Temperature from BME2 = ");
  Serial.print(bme2.readTemperature());
  Serial.println(" *C");

  Serial.print("Humidity from BME2 = ");
  Serial.print(bme2.readHumidity());
  Serial.println(" %");

  Serial.print("Pressure from BME2 = ");
  Serial.print(bme2.readPressure() / 100.0F);
  Serial.println(" hPa");

  Serial.println("--------------------");
  
  delay(5000);
}

Ver código sin formato

Veamos las partes relevantes para usar las dos interfaces de bus I2C.

Defina los pines SDA y SCL que desea utilizar:

#define SDA_1 27
#define SCL_1 26

#define SDA_2 33
#define SCL_2 32

Crea dos dos hilos Objetos (dos interfaces de bus I2C):

TwoWire I2Cone = TwoWire(0);
TwoWire I2Ctwo = TwoWire(1);

Crea dos instancias del Adafruit_BME280 Biblioteca para interactuar con tus sensores: bme1 Y bme2.

Adafruit_BME280 bme1;
Adafruit_BME280 bme2;

Inicialice una comunicación I2C en los pines definidos y con la frecuencia definida:

I2Cone.begin(SDA_1, SCL_1, 100000); 
I2Ctwo.begin(SDA_2, SCL_2, 100000);

Luego inicialízalo bme1 Y bme2 Objetos con la dirección correcta y el bus I2C correcto. bme1 Usado I2Cono:

bool status = bme1.begin(0x76, &I2Cone);  

Y bme2 Usado I2Cdos:

bool status1 = bme2.begin(0x76, &I2Ctwo);

Ahora puedes usar los métodos del Adafruit_BME280 biblioteca en tu bme1 Y bme2 Objetos para leer temperatura, humedad y presión.

Otra alternativa

Para mayor comodidad, puede utilizar los predefinidos. Cable() Y Cable1() Objetos:

• Cable(): crea un bus I2C en los pines estándar GPIO21 (ADS) y GPIO22 (SCL)
• Cable1 (SDA_2, SCL_2, Frecuencia): Crea un bus I2C en el definido SDA_2 Y SCL_2 Pines con la frecuencia deseada.

Aquí está el mismo ejemplo pero con este método. Ahora uno de sus sensores usa los pines estándar y el otro GPIO32 Y GPIO33.

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-i2c-communication-arduino-ide/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

#define SDA_2 33
#define SCL_2 32

Adafruit_BME280 bme1;
Adafruit_BME280 bme2;

void setup() {
  Serial.begin(115200);
  Serial.println(F("BME280 test"));

  Wire.begin();
  Wire1.begin(SDA_2, SCL_2);

  bool status1 = bme1.begin(0x76);  
  if (!status1) {
    Serial.println("Could not find a valid BME280_1 sensor, check wiring!");
    while (1);
  }
  
  bool status2 = bme2.begin(0x76, &Wire1);  
  if (!status2) {
    Serial.println("Could not find a valid BME280_2 sensor, check wiring!");
    while (1);
  }
 
  Serial.println();
}

void loop() { 
  // Read from bme1
  Serial.print("Temperature from BME1= ");
  Serial.print(bme1.readTemperature());
  Serial.println(" *C");

  Serial.print("Humidity from BME1 = ");
  Serial.print(bme1.readHumidity());
  Serial.println(" %");
  
  Serial.print("Pressure from BME1 = ");
  Serial.print(bme1.readPressure() / 100.0F);
  Serial.println(" hPa");

  Serial.println("--------------------");
  
  // Read from bme2
  Serial.print("Temperature from BME2 = ");
  Serial.print(bme2.readTemperature());
  Serial.println(" *C");

  Serial.print("Humidity from BME2 = ");
  Serial.print(bme2.readHumidity());
  Serial.println(" %");
  
  Serial.print("Pressure from BME2 = ");
  Serial.print(bme2.readPressure() / 100.0F);
  Serial.println(" hPa");

  Serial.println("--------------------");
  delay(5000);
}

Ver código sin formato

Debería obtener las lecturas de ambos sensores en su monitor en serie.

ESP32 I2C Maestro y Esclavo (comunicación I2C entre dos ESP32)

Puede intercambiar datos entre dos tarjetas ESP32 utilizando el protocolo de comunicación I2C. Una tarjeta debe configurarse como esclava y la otra como dispositivo maestro.

Los datos que el dispositivo maestro puede solicitar se almacenan en la placa esclava.

Debes conectar ambas placas ESP32 a través de sus respectivos pines I2C. No olvides conectar los pines GND juntos.

La imagen anterior muestra el cableado de dos placas ESP32 DOIT V1. Los pines I2C estándar son GPIO 21 (SDA) y GPIO 22 (SCL). Si está utilizando un ESP32-C3, ESP32-S3 u otro modelo, los pines I2C estándar pueden ser diferentes. Verifique la configuración de pines de la placa que está utilizando. También puedes usar pines I2C personalizados.

Para obtener instrucciones completas sobre cómo intercambiar datos entre dos tarjetas ESP32 utilizando el protocolo de comunicación I2C, consulte el siguiente enlace:

• ESP32 I2C Maestro y Esclavo (comunicación I2C entre dos ESP32) – Arduino IDE

Envolver

En este tutorial aprendiste más sobre el protocolo de comunicación I2C con el ESP32. Esperamos que la información de este artículo le haya resultado útil.

Para obtener más información sobre los GPIO ESP32, lea nuestra guía de referencia: Referencia de configuración de pines ESP32: ¿Qué pines GPIO debería utilizar?

Obtenga más información sobre el ESP32 con nuestros recursos:

• Aprenda ESP32 con Arduino IDE (curso en vídeo + libro electrónico)
• Programación MicroPython con ESP32 y ESP8266 (libro electrónico)
• Más tutoriales de ESP32…

Gracias por leer.

Comunicación ESP32 I2C: pines configurados, múltiples interfaces de bus y periféricos

En este tutorial vamos a explorar el protocolo de comunicación I2C con el ESP32 utilizando el IDE de Arduino: cómo elegir los pines I2C, conectar múltiples dispositivos I2C al mismo bus y cómo utilizar las dos interfaces de bus I2C.

Conceptos que cubriremos en este tutorial:

1. Conectar dispositivos I2C con ESP32
2. Escaneo de direcciones I2C con ESP32
3. Utilizar diferentes pines I2C con ESP32 (cambiar los pines I2C predeterminados)
4. ESP32 con múltiples dispositivos I2C (mismo bus, diferentes direcciones)
5. ESP32 con múltiples dispositivos I2C (misma dirección)
6. Utilizar las dos interfaces de bus I2C del ESP32
7. ESP32 como maestro y esclavo I2C (comunicación I2C entre dos ESP32)

Para desarrollar este tutorial, necesitas tener el complemento ESP32 instalado en tu IDE de Arduino. Si aún no lo has hecho, sigue las instrucciones en el siguiente tutorial para instalar el ESP32 en el IDE de Arduino.

Instalación del complemento de ESP32 en Arduino IDE (instrucciones para Windows, Mac OS X y Linux)

Introducción al protocolo de comunicación I2C ESP32

El protocolo I²C es un protocolo de comunicación sincrónico, multi-maestro y multi-esclavo. Normalmente se utilizan dos cables para compartir información: uno para la señal de reloj (SCL) y otro para enviar y recibir datos (SDA).

Con el ESP32, puedes configurar casi cualquier pin para tener capacidades I2C. Al usar el IDE de Arduino con el ESP32, puedes inicializar la comunicación I2C de la siguiente manera:

Wire.begin(SDA, SCL);

Esto te permite configurar los pines SDA y SCL GPIO que desees. También puedes escanear las direcciones I2C en busca de dispositivos utilizando un código como el siguiente:

// Código para escanear dispositivos I2C
#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(115200);
  Serial.println("nEscáner I2C");
}

void loop() {
  byte error, address;
  int nDevices;
  Serial.println("Escaneando...");
  nDevices = 0;
  for (address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("Dispositivo I2C encontrado en dirección 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.println(address, HEX);
      nDevices++;
    }
    else if (error == 4) {
      Serial.print("Error desconocido en la dirección 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0) {
    Serial.println("No se encontraron dispositivos I2Cn");
  } else {
    Serial.println("Liston");
  }
  delay(5000);
}

Para conocer más detalles sobre cómo conectar múltiples dispositivos I2C, cambiar los pines predeterminados y utilizar las interfaces de bus I2C del ESP32, te recomendamos que consultes los tutoriales específicos mencionados en este artículo y nuestro Libro de Referencia de GPIO ESP32.

Con esta información, podrás ampliar tus conocimientos sobre la comunicación I2C con el ESP32 y sacar el máximo provecho de esta potente funcionalidad. ¡Esperamos que te resulte útil!