Aprender

Pines I2C del ESP32, pines personalizados y un segundo bus

Intermedio

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
ESP32-C3: un BME280 y un BMP280 en un mismo bus I2Cen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Dos sensores, dos direcciones, un solo par de cables en GPIO 8 y 9.

El ESP32 no tiene pines I2C fijos. Sus controladores I2C llegan a las patillas a través de la matriz GPIO, así que Wire.begin() usa los pines predeterminados de la placa y Wire.begin(sda, scl) usa cualquier par que tú indiques. En el ESP32 DevKit clásico los predeterminados son GPIO 21 para SDA y GPIO 22 para SCL. El chip tiene dos controladores I2C, así que puede manejar dos buses separados a la vez.

El circuito de arriba es un ESP32-C3 con dos sensores de presión en sus pines predeterminados, GPIO 8 y 9: un BME280 en la dirección 0x76 y un BMP280 en 0x77. Imprimió "0x76: BME280, id 0x60" y "0x77: BMP280, id 0x58", dos dispositivos compartiendo dos cables porque sus direcciones son distintas. Abajo están los pines predeterminados de cada ESP32, los pines personalizados y un segundo bus para cuando dos dispositivos tienen la misma dirección.

Los pines I2C predeterminados de cada ESP32

SDA y SCL son constantes que el núcleo define para cada placa, y Wire.begin() sin argumentos las usa. Impresas en cada placa aquí, fueron 21 y 22 en el ESP32 clásico, 8 y 9 en el ESP32-C3 y el ESP32-S3, y 23 y 22 en el ESP32-C6. Son los pines que asumen la mayoría de los tutoriales de módulos, y los primeros que conviene probar.

Con una OLED SSD1306 y un módulo LCD en los GPIO 21 y 22 del DevKit, el escáner de abajo imprimió "Wire: found 0x27" y "Wire: found 0x3C". Los mismos dos módulos movidos a los GPIO 16 y 17 imprimieron "Wire: nothing" hasta que Wire.begin() pasó a ser Wire.begin(16, 17), y entonces volvió a encontrar ambos.

Los pines I2C predeterminados, los que usa Wire.begin() sin argumentos
PlacaSDASCL
ESP32 (el DevKit clásico)GPIO 21GPIO 22
ESP32-C3GPIO 8GPIO 9
ESP32-S3GPIO 8GPIO 9
ESP32-C6GPIO 23GPIO 22
Un escáner I2C en pines personalizados
#include <Wire.h>

void scan(TwoWire &bus, const char *name) {
  int found = 0;
  for (byte address = 1; address < 127; address++) {
    bus.beginTransmission(address);
    if (bus.endTransmission() == 0) {
      Serial.print(name);
      Serial.print(": found 0x");
      if (address < 16) Serial.print("0");
      Serial.println(address, HEX);
      found++;
    }
  }
  if (found == 0) {
    Serial.print(name);
    Serial.println(": nothing");
  }
}

void setup() {
  Serial.begin(115200);
  Wire.begin(16, 17);   // SDA, SCL
  scan(Wire, "Wire");
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Qué pines pueden ser SDA y SCL

En Wire.begin(sda, scl) los datos van primero, que es el orden contrario al de otras bibliotecas, así que un módulo que responde en los pines predeterminados pero no en los tuyos muchas veces solo está intercambiado. GPIO 33 y 32 también funcionaron. Ambas líneas son de drenaje abierto, así que cada pin necesita un controlador de salida: con SCL en el GPIO 34, un pin de solo entrada, el escaneo no encontró nada.

Deja fuera los GPIO 6 a 11, que son la flash, los GPIO 1 y 3, que son el puerto serie USB, y los pines de configuración 0, 2, 5, 12 y 15, que las resistencias pull-up de un módulo pueden mantener en el nivel equivocado al encender. En Mokxi, Wire es software que controla los dos pines, igual en todas las placas, en lugar de un modelo del controlador I2C del ESP32, así que muestra qué pines y direcciones funcionan, y su temporización es propia. Un escaneo de las 126 direcciones tomó 18314 microsegundos a los 100 kHz predeterminados y 9241 después de Wire.setClock(400000).

Dos dispositivos con la misma dirección: un segundo bus I2C

Dos módulos idénticos en un mismo bus responden a la misma dirección al mismo tiempo, y el sketch no puede distinguirlos. Dos OLED SSD1306 en los GPIO 21 y 22 imprimieron solo "Wire: found 0x3C". Algunos módulos tienen un jumper para una segunda dirección; cuando no lo tienen, o cuando necesitas más módulos de los que hay direcciones, dale al segundo su propio bus.

El núcleo del ESP32 llama Wire1 al segundo controlador. El Wire.h de Mokxi todavía no declara Wire1, y un sketch que lo usa se detiene con use of undeclared identifier 'Wire1'; did you mean 'Wire'?. Crear tu propio bus funciona en ambos: TwoWire I2Ctwo = TwoWire(1); y I2Ctwo.begin(25, 26, 400000), con SDA, SCL y el reloj. Con una OLED en cada bus, el escaneo imprimió "Wire: found 0x3C" e "I2Ctwo: found 0x3C".

Una biblioteca que toma un bus lo toma como puntero cuando se crea el objeto. Con Adafruit_SSD1306 right(128, 64, &I2Ctwo, -1); ambas pantallas arrancaron: cada begin(SSD1306_SWITCHCAPVCC, 0x3C) imprimió 1. Las bibliotecas que solo usan Wire no pueden llegar a un segundo bus, lo cual conviene verificar antes de conectar uno.

Dos OLED en 0x3C en dos buses
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

TwoWire I2Ctwo = TwoWire(1);
Adafruit_SSD1306 left(128, 64, &Wire, -1);
Adafruit_SSD1306 right(128, 64, &I2Ctwo, -1);

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  I2Ctwo.begin(25, 26);
  Serial.println(left.begin(SSD1306_SWITCHCAPVCC, 0x3C));
  Serial.println(right.begin(SSD1306_SWITCHCAPVCC, 0x3C));
  left.clearDisplay();
  left.setTextColor(SSD1306_WHITE);
  left.setTextSize(2);
  left.print("Wire");
  left.display();
  right.clearDisplay();
  right.setTextColor(SSD1306_WHITE);
  right.setTextSize(2);
  right.print("I2Ctwo");
  right.display();
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Resistencias pull-up y módulos de 5 V

Las líneas de I2C solo son llevadas a nivel bajo por los dispositivos; una resistencia hacia la alimentación las lleva a nivel alto. La mayoría de las placas de desarrollo traen las suyas, casi siempre de 4.7 k o 10 k, y por eso dos módulos en un bus normalmente funcionan sin más. Las pull-up internas del ESP32 son de decenas de kiloohms, demasiado débiles para cualquier cosa que no sea un bus corto a 100 kHz. Con un chip suelto y sin módulo, agrega 4.7 k de cada línea a 3.3 V.

Los pines del ESP32 no toleran 5 V. Un módulo alimentado con 5 V lleva SDA y SCL hasta 5 V a través de sus propias resistencias, así que aliméntalo con 3.3 V cuando funcione así, como ocurre con la mayoría de los OLED y sensores, o pon un desplazador de nivel entre él y la placa.

Abre este circuito en el editor. ESP32-C3: un BME280 y un BMP280 en un solo bus I2C, cableado tal como corre en la parte de arriba de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Cuáles son los pines I2C de un ESP32?

GPIO 21 (SDA) y GPIO 22 (SCL) en el ESP32 DevKit clásico, GPIO 8 y 9 en el C3 y el S3, y GPIO 23 y 22 en el C6. Cualquier otro pin de salida funciona con Wire.begin(sda, scl).

¿Cómo uso dos buses I2C en un ESP32?

Declara un segundo bus con TwoWire I2Ctwo = TwoWire(1); inícialo con I2Ctwo.begin(sda, scl) y pasa &I2Ctwo a la biblioteca del dispositivo que está en él. El núcleo también lo predeclara como Wire1.

¿Puedo conectar varios dispositivos I2C a un ESP32?

Sí, en los mismos dos cables, siempre que cada uno tenga una dirección distinta. Dos dispositivos con la misma dirección necesitan un segundo bus o un jumper de dirección.

¿Necesito resistencias pull-up para I2C en un ESP32?

Sí, pero la mayoría de los módulos ya las traen. Para un chip suelto, agrega 4.7 k de SDA y SCL a 3.3 V; las pull-up internas son demasiado débiles para confiar en ellas.

¿Por qué mi escáner I2C de ESP32 no encuentra nada?

Revisa primero los pines: el módulo está en pines distintos de los que nombra Wire.begin(), SDA y SCL están intercambiados, o uno es un pin de solo entrada. Luego la alimentación y la tierra.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.