Comunicación I2C entre dos Arduinos: maestro-esclavo y struct
Comunicación I2C entre dos Arduinos paso a paso: conexión maestro-esclavo, resistencias pull-up, Wire.onReceive y onRequest, direcciones, structs y ESP32.
La comunicación I2C entre dos Arduinos es una de las formas más prácticas de conectarlos: solo usa dos cables de datos (SDA y SCL) y una tierra común, y se arma en unas cuantas líneas con la librería Wire que ya trae Arduino. Una de las placas es el controlador (antes llamado maestro) y siempre es quien inicia la conversación; la otra es el destino (esclavo), que tiene una dirección y escucha lo que le escriben o responde cuando le piden datos. Como en los mismos dos cables pueden ir decenas de destinos, el I2C es muy útil en proyectos donde una placa principal maneja varios Arduinos auxiliares.
En este artículo conectamos paso a paso dos Arduino Uno por I2C: tabla de conexiones y pull-up, cómo elegir la dirección, las funciones Wire.onReceive y Wire.onRequest, envío de un byte, intercambio de datos en ambos sentidos con un struct, varios Arduinos en el mismo bus, comunicación con un ESP32 y una Raspberry Pi Pico a través de un convertidor de nivel, y una comparación entre I2C y UART. Si quieres repasar primero lo básico del I2C y el código escáner, revisa ¿Qué es I2C?.

¿Cómo funcionan el controlador y el destino (maestro-esclavo) en I2C?
En I2C todos los dispositivos se conectan en paralelo a las mismas dos líneas. SCL es la línea de reloj y siempre la genera el controlador; SDA es la línea de datos y se usa en los dos sentidos. Para empezar un mensaje, el controlador genera una condición de "start" y luego envía la dirección de 7 bits del destino junto con el bit de lectura o escritura. El destino que tiene esa dirección responde con un ACK (recibido), bajando la línea a LOW un instante al final de cada byte; si nadie tiene esa dirección, la línea se queda en HIGH y eso se llama NACK. Por eso, en I2C el controlador sabe al momento si el mensaje llegó. La regla más importante es esta: el destino no puede hablar por su cuenta. Aunque tenga un dato nuevo, espera a que el controlador le pregunte; el controlador tiene que consultarlo cada cierto tiempo. En la documentación de Arduino estos papeles se llaman "controller" y "peripheral", y en la versión nueva del estándar I2C "controller" y "target"; significan lo mismo que el maestro y el esclavo de los códigos antiguos.
Conexión: los cables I2C entre dos Arduinos
| Arduino A (controlador) | Conexión | Arduino B (destino) | Nota |
|---|---|---|---|
| A4 (SDA) | Directa | A4 (SDA) | No se cruzan |
| A5 (SCL) | Directa | A5 (SCL) | No se cruzan |
| GND | Directa | GND | Obligatoria: referencia común |
| 5V | Opcional | 5V | Solo si la placa B se alimenta desde la A |
| SDA y SCL | Con 4,7 kΩ a 5V | - | Basta un par de resistencias para todo el bus |
| Placa | SDA | SCL | Nota |
|---|---|---|---|
| Arduino Uno / Nano | A4 | A5 | En el Uno R3, SDA y SCL junto a AREF son el mismo bus |
| Arduino Mega 2560 | D20 | D21 | Trae resistencias pull-up de 10 kΩ en la placa |
| Arduino Leonardo / Micro | D2 | D3 | Pines distintos a los del Uno |
| ESP32 | GPIO 21 | GPIO 22 | 3,3 V; con Wire.begin(sda, scl) puedes elegir otros pines |
| Raspberry Pi Pico | GP4 (I2C0) | GP5 (I2C0) | 3,3 V; en MicroPython puedes elegir otros pares de pines |
Resistencias pull-up: ¿cuándo y de qué valor?
Los dispositivos del bus I2C solo pueden bajar la línea a LOW; lo que la sube a HIGH son las resistencias pull-up. En las placas AVR de Arduino, Wire.begin() activa en SDA y SCL unas resistencias pull-up internas de unos 20–50 kΩ. Con dos Uno y cables cortos a 100 kHz eso casi siempre funciona, pero son resistencias débiles para I2C; mientras más largo el cable, más lento sube la señal y empiezan los errores. Para un bus confiable agrega una resistencia de 4,7 kΩ de SDA a 5V y otra de SCL a 5V. El límite inferior viene de la corriente de 3 mA que se permite en LOW: R(mín) = (5 V - 0,4 V) / 3 mA ≈ 1,5 kΩ. El superior lo fija la capacitancia del bus: a 100 kHz, para un bus de 200 pF, R(máx) ≈ 1000 ns / (0,8473 × 200 pF) ≈ 5,9 kΩ. Para los cálculos usa la herramienta Ley de Ohm, y para entender el pull-up, Resistencias pull-up y pull-down.
| Situación | Pull-up recomendada | Nota |
|---|---|---|
| Dos Uno, cable de menos de 30 cm, 100 kHz | 4,7 kΩ (las internas suelen funcionar) | El arreglo más común |
| Cable de 50 cm a 1 m o 400 kHz | 2,2 kΩ | Aun así, deja el cable lo más corto posible |
| Hay un Arduino Mega en el bus | Puede no hacer falta otra | Las de 10 kΩ del Mega quedan en paralelo con las demás |
| Hay módulos con pull-up (OLED, RTC, LCD) | Calcula la resistencia total en paralelo | El total no debe bajar de 1,5 kΩ |
| Arduino con ESP32 o Pico | Las del convertidor de nivel, a cada lado | No los conectes directo; mira la sección de abajo |
Elección de dirección: ¿cuál usar?
La dirección del Arduino destino la eliges tú con Wire.begin(dirección). En el espacio de 7 bits, las direcciones 0x00–0x07 y 0x78–0x7F están reservadas, así que el rango que puedes usar es 0x08–0x77, es decir, de 8 a 119 en decimal. Si en el bus hay otros módulos, elige un valor que no choque con sus direcciones; lo más seguro es conectar todo y correr el escáner I2C para ver qué direcciones están ocupadas. Estas son las direcciones de los módulos más comunes:
| Dirección | Módulos que suelen usarla |
|---|---|
| 0x27 / 0x3F | LCD I2C con PCF8574 |
| 0x3C / 0x3D | Pantalla OLED SSD1306 |
| 0x68 | RTC DS1307 y DS3231, MPU-6050 |
| 0x76 / 0x77 | BMP280 y BME280 |
| 0x40 | Controlador de servos PCA9685, INA219 |
| 0x48 | ADC ADS1115 |
| 0x57 | MAX30102, EEPROM AT24C32 de los módulos RTC |
| 0x08–0x0F | Casi siempre libre; un buen rango para destinos Arduino |
Ejemplo 1: enviar un byte del controlador al destino
En el primer ejemplo, la placa A lee un potenciómetro en A0, divide el valor entre 4 para dejarlo en 0–255 y lo envía 10 veces por segundo como un solo byte a la dirección 8. La placa B recibe ese byte y ajusta el brillo del LED en D9. Sube primero el código del controlador a la placa A y después el del destino a la placa B. La librería Wire viene con el Arduino IDE; no tienes que instalarla. Código del controlador:
1// Denetleyici (master): potansiyometre değerini hedefe gönderir / Controller (master): sends the pot value to the target
2#include <Wire.h>
3
4const byte TARGET_ADDR = 8; // hedef kartın adresi / address of the target board
5
6void setup() {
7 Wire.begin(); // adres verilmedi = denetleyici / no address = controller
8 Serial.begin(9600);
9}
10
11void loop() {
12 byte value = analogRead(A0) / 4; // 0-1023 -> 0-255
13 Wire.beginTransmission(TARGET_ADDR);
14 Wire.write(value);
15 byte status = Wire.endTransmission(); // 0 = başarılı / 0 = success
16 if (status != 0) {
17 Serial.print(F("I2C hatasi / error: "));
18 Serial.println(status); // 2 = adres yanıt vermedi / 2 = no ACK on address
19 }
20 delay(100);
21}Código del destino que vas a subir a la placa B:
1// Hedef (slave): gelen baytla LED parlaklığını ayarlar / Target (slave): sets the LED brightness from the received byte
2#include <Wire.h>
3
4const byte MY_ADDR = 8; // bu kartın adresi / this board's address
5const int LED_PIN = 9; // PWM pini / PWM pin
6
7volatile byte received = 0;
8volatile bool newData = false;
9
10void onReceiveEvent(int howMany) { // kesme içinde çalışır: kısa tut / runs inside an interrupt: keep it short
11 for (int i = 0; i < howMany; i++) received = Wire.read(); // son bayt kalır / keep the last byte
12 newData = true;
13}
14
15void setup() {
16 Wire.begin(MY_ADDR); // adresle başlat = hedef / start with an address = target
17 Wire.onReceive(onReceiveEvent);
18 pinMode(LED_PIN, OUTPUT);
19 Serial.begin(9600);
20}
21
22void loop() {
23 if (newData) {
24 newData = false;
25 analogWrite(LED_PIN, received);
26 Serial.println(received); // Serial'ı kesmenin dışında kullan / use Serial outside the interrupt
27 }
28}El código del destino tiene dos puntos clave. El primero es Wire.begin(8): la placa que se inicia con una dirección se vuelve destino. El segundo es Wire.onReceive(): cuando el controlador envía datos, la librería Wire llama sola a esta función y le pasa como parámetro la cantidad de bytes recibidos. Guardamos el valor en una variable volatile y solo levantamos la bandera de "hay dato nuevo"; ajustar el LED y escribir en el Monitor Serie se hace dentro de loop(). En el controlador, el valor que devuelve Wire.endTransmission() te dice qué pasó con el mensaje:
| Valor de endTransmission() | Significado | ¿Qué hacer? |
|---|---|---|
| 0 | Éxito, el destino confirmó cada byte | - |
| 1 | Los datos no caben en el búfer (más de 32 bytes) | Divide el mensaje en partes |
| 2 | No llegó ACK a la dirección | Revisa la dirección, los cables, la GND y que el destino esté encendido |
| 3 | No llegó ACK a un byte de datos | El destino está ocupado o recibió una longitud inesperada |
| 4 | Otro error | Puede haber ruido en el bus o faltar la pull-up |
| 5 | Tiempo de espera agotado | El bus se trabó; activa la recuperación con setWireTimeout() |
onReceive y onRequest: cuidados dentro de la interrupción
- Que sean cortas: Las dos funciones corren dentro de la interrupción de I2C. No uses delay(), Serial.print() ni cálculos largos; guarda el dato en una variable y sal.
- Usa volatile: Declara como volatile las banderas que cambian en la interrupción y se leen en loop(); si no, el compilador podría no ver el cambio. Para más detalles, revisa Interrupciones en Arduino.
- En onRequest escribe todo de una vez: Cuando el controlador pide datos, pon todos los bytes en el búfer con un solo Wire.write(arreglo, longitud). Ten los datos listos de antemano; leer un sensor dentro de onRequest hace esperar al controlador.
- Límite de 32 bytes: El búfer de Wire en AVR es de 32 bytes. Divide los datos más largos en varios mensajes o, si de verdad lo necesitas, usa UART.
- Revisa la longitud: Compara la cantidad de bytes que llega a onReceive con la que esperas; si llegan de más o de menos, léelos y descártalos.
- Prepara la respuesta antes: Actualiza las variables del reporte antes de que la placa destino empiece una tarea larga; así el controlador siempre encuentra una respuesta lista.
Ejemplo 2: comunicación en ambos sentidos con un struct
En los proyectos reales se necesita más de un byte: el controlador manda una orden y el destino devuelve un reporte con varios valores. En lugar de partir los valores byte por byte, es más legible y rápido definir un struct y enviarlo tal cual. En el ejemplo de abajo, el controlador ajusta el LED y su brillo con una orden de 2 bytes y luego, con Wire.requestFrom(), le pide al destino un reporte de 7 bytes: el valor del potenciómetro (uint16_t), el estado del botón (uint8_t) y el tiempo que lleva encendido el destino (uint32_t). Las estructuras tienen que ser idénticas en las dos placas. Código del controlador:
1// Denetleyici: komut gönderir, rapor ister / Controller: sends a command, requests a report
2#include <Wire.h>
3
4struct __attribute__((packed)) Command { // denetleyici -> hedef / controller -> target (2 bayt / bytes)
5 uint8_t ledOn;
6 uint8_t brightness;
7};
8
9struct __attribute__((packed)) Report { // hedef -> denetleyici / target -> controller (7 bayt / bytes)
10 uint16_t potValue;
11 uint8_t buttonPressed;
12 uint32_t uptimeMs;
13};
14
15const byte TARGET_ADDR = 8;
16
17void setup() {
18 Wire.begin();
19 Wire.setClock(100000); // standart hız 100 kHz / standard mode 100 kHz
20 Wire.setWireTimeout(25000, true); // hat takılırsa 25 ms'de kurtul / recover if the bus hangs for 25 ms
21 Serial.begin(9600);
22}
23
24void loop() {
25 Command cmd;
26 cmd.ledOn = 1;
27 cmd.brightness = (millis() / 20) % 256; // yavaşça artan parlaklık / slowly rising brightness
28
29 Wire.beginTransmission(TARGET_ADDR);
30 Wire.write((const uint8_t*)&cmd, sizeof(cmd));
31 byte err = Wire.endTransmission();
32
33 Report r;
34 byte n = Wire.requestFrom(TARGET_ADDR, (byte)sizeof(Report));
35 if (err == 0 && n == sizeof(Report)) {
36 Wire.readBytes((uint8_t*)&r, sizeof(r));
37 Serial.print(F("Pot: "));
38 Serial.print(r.potValue);
39 Serial.print(F(" Buton / button: "));
40 Serial.print(r.buttonPressed);
41 Serial.print(F(" Sure / uptime ms: "));
42 Serial.println(r.uptimeMs);
43 } else {
44 while (Wire.available()) Wire.read(); // yarım veriyi at / drop partial data
45 Serial.println(F("Hedef yanit vermedi / target not responding"));
46 }
47 delay(200);
48}Código de la placa destino; las definiciones de las estructuras son exactamente iguales a las del controlador:
1// Hedef: komutu uygular, istenince rapor gönderir / Target: applies the command, sends a report on request
2#include <Wire.h>
3
4struct __attribute__((packed)) Command { // denetleyicideki yapının aynısı / same struct as on the controller
5 uint8_t ledOn;
6 uint8_t brightness;
7};
8
9struct __attribute__((packed)) Report {
10 uint16_t potValue;
11 uint8_t buttonPressed;
12 uint32_t uptimeMs;
13};
14
15const byte MY_ADDR = 8;
16const int LED_PIN = 9;
17const int BUTTON_PIN = 2;
18
19Command cmd;
20Report report;
21volatile bool newCmd = false;
22
23void onReceiveEvent(int howMany) {
24 if (howMany != sizeof(Command)) { // beklenmeyen uzunluk: at / unexpected length: discard
25 while (Wire.available()) Wire.read();
26 return;
27 }
28 Wire.readBytes((uint8_t*)&cmd, sizeof(cmd));
29 newCmd = true;
30}
31
32void onRequestEvent() { // denetleyici veri istedi / the controller asked for data
33 Wire.write((const uint8_t*)&report, sizeof(report)); // tek seferde yaz / write it in one go
34}
35
36void setup() {
37 pinMode(LED_PIN, OUTPUT);
38 pinMode(BUTTON_PIN, INPUT_PULLUP);
39 Wire.begin(MY_ADDR);
40 Wire.onReceive(onReceiveEvent);
41 Wire.onRequest(onRequestEvent);
42}
43
44void loop() {
45 uint16_t pot = analogRead(A0);
46 uint8_t pressed = (digitalRead(BUTTON_PIN) == LOW);
47 uint32_t now = millis();
48
49 noInterrupts(); // kopyalarken onRequest araya girmesin / keep onRequest out while copying
50 report.potValue = pot;
51 report.buttonPressed = pressed;
52 report.uptimeMs = now;
53 Command c = cmd;
54 bool fresh = newCmd;
55 newCmd = false;
56 interrupts();
57
58 if (fresh) analogWrite(LED_PIN, c.ledOn ? c.brightness : 0);
59}En el código del destino, la función registrada con Wire.onRequest() envía la estructura del reporte tal cual cuando el controlador pide datos. El reporte en sí se actualiza dentro de loop(). Mientras se actualiza, detenemos las interrupciones un instante con noInterrupts(); así, si el controlador pregunta justo en ese momento, no recibe un valor mitad viejo y mitad nuevo. La orden recibida también se copia a una variable local dentro de la misma protección. En el controlador, la línea Wire.setWireTimeout(25000, true) evita que el bus se quede trabado para siempre si se afloja un cable o se cuelga el destino: si no hay respuesta en 25 ms, Wire se reinicia solo.
Conectar varios Arduinos al mismo bus
La gran ventaja del I2C sobre el UART es que en los mismos dos cables caben muchos destinos. Dale a cada placa destino una dirección distinta (por ejemplo 8, 9 y 10), une todas las SDA, todas las SCL y todas las GND, y usa un solo par de resistencias pull-up para todo el bus. El controlador puede recorrer en orden un arreglo de direcciones para mandarle órdenes a cada placa y pedirle su reporte. Mientras más largo es el bus, más capacitancia tiene; deja las placas cerca, mantén el largo total del cable en unas cuantas decenas de centímetros y, si hace falta, fija la velocidad en 100 kHz. En el mismo bus también puedes usar módulos como una LCD I2C o una OLED; mientras sus direcciones no choquen, todo funciona junto sin problema.
I2C entre Arduino y ESP32: conversión de nivel
El Arduino Uno trabaja a 5 V y el ESP32 a 3,3 V, y los pines del ESP32 no toleran 5 V. Como en el Uno Wire.begin() conecta las pull-up internas a 5 V, unir las dos placas directamente sube los pines del ESP32 a 5 V. Al revés también hay problema: si subes el bus solo a 3,3 V, las entradas I2C del Uno piden al menos 0,7 × 5 V = 3,5 V para leer HIGH, y 3,3 V queda por debajo. La solución correcta es un convertidor de nivel bidireccional BSS138 con resistencias pull-up a cada lado: el lado HV va al 5V y a A4/A5 del Uno, el lado LV al 3V3 y a los GPIO 21/22 del ESP32, y las GND quedan en común. Para la conexión detallada revisa Convertidor de nivel lógico. El ESP32 también puede funcionar como destino desde la versión 2.0.1 del core, pero preparar los datos justo en el momento de onRequest es más difícil en el ESP32; por eso el arreglo con menos problemas es el ESP32 como controlador y el Uno como destino. El código de abajo lee el mismo reporte del Uno destino del Ejemplo 2:
1// ESP32 denetleyici, Arduino Uno hedeften rapor okur / ESP32 controller reads the report from an Arduino Uno target
2#include <Wire.h>
3
4struct __attribute__((packed)) Report { // Uno'daki yapıyla birebir aynı / exactly the same as on the Uno
5 uint16_t potValue;
6 uint8_t buttonPressed;
7 uint32_t uptimeMs;
8};
9
10const uint8_t TARGET_ADDR = 8;
11
12void setup() {
13 Serial.begin(115200);
14 Wire.begin(21, 22); // SDA = GPIO 21, SCL = GPIO 22 (seviye dönüştürücü üzerinden / through a level shifter)
15 Wire.setClock(100000);
16}
17
18void loop() {
19 Report r;
20 uint8_t n = Wire.requestFrom(TARGET_ADDR, (uint8_t)sizeof(Report));
21 if (n == sizeof(Report)) {
22 Wire.readBytes((uint8_t*)&r, sizeof(r));
23 Serial.printf("Pot: %u Buton / button: %u Sure / uptime: %lu ms\n",
24 (unsigned int)r.potValue, (unsigned int)r.buttonPressed, (unsigned long)r.uptimeMs);
25 } else {
26 Serial.println("Uno yanit vermedi / Uno not responding");
27 }
28 delay(500);
29}Controlador I2C con Raspberry Pi Pico (MicroPython)
La Raspberry Pi Pico también trabaja a 3,3 V, así que se conecta al Uno de la misma manera, a través de un convertidor de nivel. MicroPython no tiene structs como C, pero el módulo struct hace el mismo trabajo: el formato "<HBI" significa un uint16_t, un uint8_t y un uint32_t en little-endian y sin relleno, y coincide exactamente con el reporte de 7 bytes del Uno. El código primero escanea el bus y muestra las direcciones que encuentra, y luego manda una orden al Uno destino y lee su reporte. Si apenas empiezas con la Pico, arranca con ¿Qué es la Raspberry Pi Pico?.
1from machine import I2C, Pin
2import struct, time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000) # seviye dönüştürücü üzerinden / through a level shifter
5print("Bulunan adresler / found:", [hex(a) for a in i2c.scan()])
6
7while True:
8 i2c.writeto(8, bytes([1, 128])) # Command: ledOn = 1, brightness = 128
9 data = i2c.readfrom(8, 7) # Report: 7 bayt / 7 bytes
10 pot, button, uptime = struct.unpack("<HBI", data) # küçük endian, dolgusuz / little-endian, no padding
11 print("Pot:", pot, "Buton:", button, "ms:", uptime)
12 time.sleep(0.5)¿I2C o UART? Comparación
| Característica | I2C | UART |
|---|---|---|
| Cables | SDA, SCL y GND (directos) | TX, RX y GND (cruzados) |
| Número de dispositivos | Un controlador y hasta 112 direcciones | Solo dos dispositivos |
| ¿Quién inicia la conversación? | Solo el controlador | Cualquiera de los dos, cuando quiera |
| Velocidad típica | 100 kHz o 400 kHz | 9600–115200 baudios |
| Distancia | Dentro de la placa y cables cortos (hasta 1 m) | Algunos metros; con RS-485, mucho más |
| Confirmación de entrega | Sí (ACK y NACK) | No; tienes que agregar tu propia verificación |
| Tamaño de mensaje (Wire) | Búfer de 32 bytes | Flujo continuo de bytes |
| Hardware en el Arduino Uno | A4 y A5 | D0 y D1 (compartidos con el USB) o SoftwareSerial |
En resumen: elige I2C si las placas están en la misma caja, si una placa principal va a manejar varias auxiliares y si quieres estar seguro de que el mensaje llegó. Si las placas están a varios metros, si los dos lados necesitan enviar datos cuando quieran o si hay un flujo largo y continuo de datos, conviene más UART; los detalles están en Comunicación serie UART. Si necesitas muchísima velocidad, la tercera opción es SPI.
Errores comunes y cómo solucionarlos
- endTransmission() devuelve 2: El destino no responde en esa dirección. Revisa que la dirección sea la misma en los dos códigos, que SDA y SCL no estén invertidos, que la GND esté conectada y que el código del destino esté cargado; confirma la dirección con el escáner I2C.
- Cruzar SDA y SCL como en UART: En I2C, SDA va a SDA y SCL a SCL; con la conexión cruzada no se encuentra ningún dispositivo.
- El programa se congela dentro de onReceive: En la función de interrupción se usó Serial.print(), delay() o se empezó otra comunicación con Wire. En la función solo copia el dato y haz el trabajo en loop().
- Los valores llegan revueltos o recorridos: Las definiciones del struct son distintas en las dos placas, se usó un tipo como int cuyo tamaño cambia según la placa o falta packed. Usa tipos de tamaño fijo y la misma definición.
- Errores al azar cuando el cable es más largo: Las pull-up internas no alcanzan. Agrega resistencias externas de 4,7 kΩ o 2,2 kΩ, acorta el cable y deja la velocidad en 100 kHz.
- Al conectar el ESP32 el bus no funciona o el ESP32 se calienta: Se conectaron 5 V y 3,3 V directamente. Pon en medio un convertidor de nivel bidireccional.
Comunicar dos Arduinos por I2C es la forma más fácil de dividir un proyecto grande en partes pequeñas e independientes: una placa maneja la pantalla y al usuario mientras las demás leen sensores o mueven motores. Primero comprueba la conexión con el ejemplo de un byte y luego pasa al ejemplo en ambos sentidos con struct. En la app BlueGrays encontrarás, con diagramas y código paso a paso, los proyectos de comunicación en un sentido y en ambos sentidos entre 2 Arduinos, la LCD I2C, la calculadora I2C, la LCD I2C con ESP32 y el reloj con RTC DS1307.
Preguntas frecuentes
¿Cómo se comunican dos Arduinos por I2C?
Se conectan directamente los pines A4 (SDA), A5 (SCL) y GND de las dos placas. Una se inicia como controlador con Wire.begin() y la otra como destino con una dirección, por ejemplo Wire.begin(8). El controlador envía datos con beginTransmission, write y endTransmission y los pide con requestFrom; el destino responde con las funciones onReceive y onRequest.
¿Es obligatorio poner resistencias pull-up en I2C?
Sí; como las líneas I2C son de drenador abierto, el nivel HIGH lo dan las resistencias pull-up. Las pull-up internas del Arduino suelen funcionar con dos placas y cables cortos, pero para un bus confiable se recomienda poner 4,7 kΩ de SDA y de SCL a 5V.
¿Cuántos Arduinos se pueden conectar a un bus I2C?
Con direcciones de 7 bits se pueden usar 112 direcciones, de 0x08 a 0x77, así que en teoría caben 112 destinos. En la práctica el límite lo ponen la capacitancia total del bus y el largo de los cables; con unas cuantas placas y cables cortos no tendrás problemas.
¿El Arduino esclavo puede mandar datos al maestro por su cuenta?
No. En I2C la comunicación siempre la inicia el controlador; el destino solo responde con onRequest cuando le preguntan. Si el destino necesita avisar que tiene un dato nuevo, el controlador lo consulta cada cierto tiempo o el destino pone en LOW un pin de interrupción aparte para alertarlo.
¿Se puede conectar un Arduino y un ESP32 por I2C directamente?
No es recomendable. El Uno trabaja a 5 V y el ESP32 a 3,3 V, y las pull-up internas del Uno suben los pines del ESP32 a 5 V. Usa un convertidor de nivel bidireccional como el BSS138 y deja al ESP32 como controlador y al Uno como destino.
¿Qué diferencia hay entre I2C y UART en Arduino?
El I2C junta muchos dispositivos en el mismo bus con dos cables y direcciones, y confirma con ACK que cada byte llegó, pero solo el controlador inicia la conversación. El UART solo une dos dispositivos, sus cables van cruzados y cualquiera de los dos puede enviar datos cuando quiera. Para varias placas a poca distancia conviene I2C; para cables largos y flujo continuo de datos, UART.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Comunicación unidireccional entre 2 Arduino
Haces que dos Arduino hablen por un solo cable: pulsas el botón de uno y se enciende el LED del otro, vuelves a pulsar y se apaga.

Comunicación bidireccional entre 2 Arduino
Dos Arduino se conectan con cables y hablan entre sí: pulsas el botón de uno y se enciende la luz del otro, lo pulsas otra vez y se apaga.

Uso de la pantalla LCD con I2C
Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

Calculadora Arduino I2C
Se trata de un proyecto de calculadora basado en Arduino que realiza operaciones de suma, resta, multiplicación y división utilizando un teclado de membrana 4x4 y una pantalla LCD 16x2 I2C. Gracias a I2C, la conexión de la pantalla se realiza con sólo 2 cables, reduciendo así el desorden de cables y manteniendo más pines abiertos para su uso. También dispone de entrada de números decimales y soporte de números negativos.

Pantalla LCD I2C para ESP32 (16x2)
En este proyecto conectamos una pantalla LCD de caracteres 16x2 al ESP32 por I2C para mostrar texto. Con I2C bastan 2 pines de datos (SDA y SCL), en lugar de los 6+ pines de una conexión paralela clásica. El código escribe un mensaje fijo en la primera línea y un contador que sube cada segundo en la segunda. Al arrancar, un escáner I2C muestra la dirección de la pantalla en el Serial Monitor (normalmente 0x27 o 0x3F).

Reloj digital con ESP32 y RTC DS1307 (I2C + LCD)
En este proyecto, mostramos la hora y la fecha en una pantalla LCD I2C de 16x2 mediante el módulo de reloj en tiempo real (RTC) DS1307. El DS1307 es un RTC con batería de respaldo que conserva la hora incluso si el ESP32 se apaga. Ambos módulos comparten la misma línea I2C (SDA/SCL), por lo que aprendemos a controlar varios dispositivos con solo dos cables de señal. Con este proyecto conocerás el protocolo I2C, el funcionamiento de los módulos RTC y la visualización dinámica en pantallas LCD.

Juego de Raquetas - SSD1306
Una pelota, dos palas y tú: juegas al tenis de mesa, uno de los primeros videojuegos de la historia, en una pequeña pantalla OLED.

Reloj y calendario de matriz de puntos (MAX7219, DS1307)
Un panel luminoso para tu mesa o tu pared que muestra la hora y la fecha con texto en movimiento.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

