¿Qué es I2C? SDA, SCL, resistencias pull-up y escáner Arduino

I2C (Inter-Integrated Circuit) es un protocolo de comunicación serie que permite a un microcontrolador hablar con decenas de sensores, pantallas y módulos usando solo dos cables de señal (SDA y SCL). Se pronuncia «I-cuadrado-C» y en algunas hojas de datos aparece como IIC o TWI (Two Wire Interface). La pantalla LCD I2C, la pantalla OLED, el acelerómetro MPU6050, el sensor de presión BMP280 y el módulo de reloj DS1307 que usas en tus proyectos con Arduino funcionan con este protocolo; puedes conectarlos todos en paralelo a los mismos dos cables y llegar a cada uno con su propia dirección.

En esta guía aprenderás cómo funciona I2C a nivel eléctrico, qué significan las direcciones, por qué las resistencias pull-up son imprescindibles y cómo calcular su valor. Después verás paso a paso una tabla de pines para Arduino Uno, ESP32 y Raspberry Pi Pico, un código escáner I2C que encuentra todos los dispositivos del bus, un ejemplo para leer registros sin librería y soluciones a problemas habituales como los conflictos de dirección.

¿Qué es I2C y cómo funciona?

I2C fue desarrollado en 1982 por Philips (hoy NXP) para que los chips de una misma placa se comunicaran con pocos cables. En el bus hay dos papeles: el controlador (antes llamado maestro), que inicia cada transferencia y genera el reloj, y los dispositivos destino (antes esclavos), que le responden. En los proyectos con Arduino el controlador casi siempre es el Arduino, el ESP32 o la Pico, mientras que los sensores y las pantallas son los destinos.

• SDA (Serial Data): La línea por la que viajan los datos en ambos sentidos. El controlador envía direcciones y comandos, y el sensor devuelve sus medidas por la misma línea.
• SCL (Serial Clock): La línea de reloj. En cada pulso de reloj se lee un bit de SDA, y el reloj lo genera el controlador.
• GND (tierra común): La referencia de las señales. Incluso los módulos con alimentación separada deben compartir la misma GND.

Las líneas son de drenador abierto (open-drain): ningún dispositivo pone una línea a nivel alto, solo puede tirar de ella hacia nivel bajo. Lo que mantiene la línea a 1 son las resistencias pull-up que conectan SDA y SCL a la tensión de alimentación. Por eso no hay cortocircuito aunque dos dispositivos intenten hablar a la vez; si cualquiera baja la línea, todos ven un 0. Un mensaje I2C sigue este orden:

1. START: Con SCL en alto, el controlador baja SDA de 1 a 0 y todos los dispositivos del bus empiezan a escuchar.
2. Dirección y bit de sentido: Se envía la dirección de 7 bits seguida de un bit de lectura (1) o escritura (0).
3. ACK: El dispositivo dueño de esa dirección baja SDA durante el 9.º pulso de reloj para decir «aquí estoy». Si nadie lo hace, se llama NACK.
4. Bytes de datos: Cada byte se envía como 8 bits y el receptor responde a cada uno con un ACK. En la mayoría de sensores el primer byte es el número del registro que se va a leer o escribir.
5. STOP: Con SCL en alto, SDA sube de 0 a 1 y el bus queda libre. En las lecturas se usa un START repetido (repeated start) en lugar de STOP para cambiar de sentido sin soltar el bus.

Comparar I2C con los otros dos protocolos más comunes del mundo Arduino deja claro cuándo elegirlo:

Velocidades de I2C y límites técnicos

La librería Wire de Arduino arranca por defecto a 100 kHz; la mayoría de sensores también admite 400 kHz y puedes pasar a esa velocidad con Wire.setClock(400000). Una velocidad mayor hace que las pantallas se refresquen con más fluidez, pero vuelve el bus más sensible a la longitud de los cables y al valor de las pull-up. Según el estándar, la capacidad total del bus (cables más pines de los dispositivos) no debe superar 400 pF. Los cables dupont y planos normales añaden de 50 a 100 pF por metro y cada pin de dispositivo hasta 10 pF; por eso I2C se diseñó para trabajar dentro de una misma placa o con cables de unas decenas de centímetros. Más allá de 1 metro hay que bajar la velocidad, usar pull-up más fuertes o añadir extensores de bus como el P82B715.

Direcciones I2C: 7 bits, 8 bits y direcciones reservadas

Cada dispositivo del bus tiene una dirección de 7 bits, lo que en teoría da 128 direcciones. Como los rangos 0x00–0x07 y 0x78–0x7F están reservados para usos especiales, las direcciones utilizables son las 112 que van de 0x08 a 0x77. Normalmente el fabricante del chip fija la dirección, pero en muchos módulos puedes cambiar sus últimos bits con puentes de soldadura o pines llamados A0, A1, A2 o AD0.

Aquí viene lo confuso: algunas hojas de datos y las serigrafías de la parte trasera de los módulos dan la dirección en 8 bits, incluido el bit de sentido. Por ejemplo, detrás de una placa OLED pone «0x78», pero la dirección en el código es 0x3C; si un módulo LCD indica 0x4E, en el código es 0x27. La regla es sencilla: divide el valor de 8 bits entre 2 (desplázalo un bit a la derecha) y obtendrás la dirección de 7 bits. Las librerías de Arduino, ESP32 y MicroPython esperan siempre direcciones de 7 bits.

Resistencias pull-up: por qué hacen falta y cómo elegir su valor

Como los dispositivos del bus I2C solo pueden bajar las líneas, el nivel alto lo aportan las resistencias pull-up. Si la resistencia es demasiado grande, la capacidad del bus ralentiza el paso de 0 a 1, los flancos de la señal se redondean y a alta velocidad se leen bits erróneos. Si es demasiado pequeña, aumenta la corriente que un dispositivo debe absorber al bajar la línea; el estándar solo exige que un dispositivo pueda absorber al menos 3 mA a 0,4 V, así que la pull-up debe mantener la corriente por debajo de ese valor.

Estas fórmulas dan los dos límites: la resistencia mínima es R(mín) = (VCC − 0,4 V) / 3 mA y la máxima R(máx) = t(subida) / (0,8473 × C(bus)). Para 5 V sale R(mín) = 4,6 V / 0,003 A ≈ 1,53 kΩ, y para 3,3 V ≈ 0,97 kΩ. En un bus corto con 100 pF de capacidad, R(máx) ≈ 11,8 kΩ a 100 kHz y ≈ 3,5 kΩ a 400 kHz. Por eso en la práctica los valores más usados son 4,7 kΩ para 100 kHz y 2,2 kΩ para 400 kHz y buses con muchos dispositivos. Puedes usar la herramienta Código de colores de resistencias para leer las bandas y la herramienta Constante de tiempo RC para ver el retardo que crean la resistencia y la capacidad.

En el Arduino Uno, al llamar a Wire.begin() también se activan las resistencias pull-up internas de 20–50 kΩ del ATmega328P. Con un solo módulo y 10–20 cm de cable suelen bastar, pero no son fiables; las resistencias externas siempre son mejor opción. Si usas una placa de sensor sin pull-up, no olvides añadir una resistencia de 4,7 kΩ desde SDA y otra desde SCL hasta VCC.

Pines I2C: Arduino Uno, Mega, ESP32, ESP8266 y Pico

Paso a paso: encontrar direcciones con el escáner I2C

Cuando consigues un módulo nuevo, lo primero es averiguar las direcciones de los dispositivos del bus. Un escáner I2C envía un mensaje vacío a cada dirección de 0x08 a 0x77 y muestra las que responden con ACK. Así compruebas a la vez que el módulo está bien conectado y qué dirección debes poner en tu código.

1. Conecta GND del módulo a GND del Arduino y VCC a 5V (a 3.3V en módulos que solo admiten 3,3 V).
2. Conecta SDA a A4 y SCL a A5. Si tienes varios módulos, une todos sus SDA y todos sus SCL en la protoboard.
3. Sube el código de abajo y abre el monitor serie a 115200 baudios.
4. Apunta las direcciones que aparecen. Si no sale nada, revisa los cables, la GND común y las resistencias pull-up.
5. Desconecta y vuelve a conectar los módulos uno a uno para confirmar qué dirección corresponde a cada dispositivo; el escáner repite la búsqueda cada 5 segundos.

1#include <Wire.h>
2
3void printHex(byte addr) {
4  Serial.print(F("0x"));
5  if (addr < 16) Serial.print('0');    // tek haneliye sıfır ekle / pad single digit
6  Serial.print(addr, HEX);
7}
8
9void setup() {
10  Serial.begin(115200);
11  Wire.begin();                         // Uno: A4 = SDA, A5 = SCL
12#if defined(ARDUINO_ARCH_AVR)
13  Wire.setWireTimeout(3000, true);      // AVR (Uno, Nano, Mega): hat kilitlenirse 3 ms sonra kurtar / recover a stuck bus after 3 ms
14#endif
15  Serial.println(F("I2C tarayici / I2C scanner"));
16}
17
18void loop() {
19  byte found = 0;
20  for (byte addr = 0x08; addr <= 0x77; addr++) {   // geçerli 7 bit adresler / valid 7-bit addresses
21    Wire.beginTransmission(addr);
22    byte err = Wire.endTransmission();             // 0 = cihaz ACK verdi / device acknowledged
23    if (err == 0) {
24      Serial.print(F("Bulundu / found: "));
25      printHex(addr);
26      Serial.println();
27      found++;
28    } else if (err == 4 || err == 5) {
29      Serial.print(F("Hat hatasi / bus error at "));
30      printHex(addr);
31      Serial.println();
32    }
33  }
34  if (found == 0) {
35    Serial.println(F("Cihaz yok: kablolari ve pull-up'lari kontrol et / no devices: check wiring and pull-ups"));
36  } else {
37    Serial.print(found);
38    Serial.println(F(" cihaz bulundu / device(s) found"));
39  }
40  Serial.println();
41  delay(5000);                          // 5 sn sonra yeniden tara / rescan after 5 s
42}

La línea setWireTimeout del código es importante: cuando SDA o SCL están en cortocircuito, o un dispositivo se queda colgado manteniendo la línea en bajo, la librería Wire del Uno con la configuración por defecto puede esperar para siempre y congelar tu programa. Con el tiempo de espera activado, la librería se rinde a los 3 ms, reinicia el hardware I2C y el escáner informa del problema con un código de error. La línea está dentro de un #if para que solo se compile en placas AVR (Uno, Nano, Mega); las librerías Wire de ESP32 y ESP8266 ya traen su propia protección por tiempo de espera, así que el mismo código compila y funciona sin cambios en las tres plataformas.

I2C sin librería: leer y escribir registros

Las librerías facilitan el trabajo, pero por dentro todas hacen lo mismo: envían al dispositivo el número de registro y luego leen o escriben bytes en ese registro. Hacerlo tú mismo una vez te permite leer la hoja de datos de un sensor nuevo y usarlo incluso sin librería. El ejemplo siguiente despierta el sensor MPU6050 del modo reposo, lee su registro de identidad (WHO_AM_I) y después calcula la temperatura y la aceleración en el eje Z a partir de los valores en bruto.

1#include <Wire.h>
2
3const byte MPU_ADDR = 0x68;             // AD0 GND'de; AD0 = 3.3V ise 0x69 / AD0 low; 0x69 if AD0 high
4
5void writeReg(byte reg, byte value) {
6  Wire.beginTransmission(MPU_ADDR);
7  Wire.write(reg);                      // önce yazmaç adresi / register address first
8  Wire.write(value);                    // sonra veri / then the data
9  Wire.endTransmission();               // STOP gönder / send STOP
10}
11
12int16_t readWord(byte reg) {
13  Wire.beginTransmission(MPU_ADDR);
14  Wire.write(reg);
15  Wire.endTransmission(false);          // STOP yok, tekrarlı START / no STOP, repeated START
16  Wire.requestFrom(MPU_ADDR, (byte)2);  // 2 bayt iste / request 2 bytes
17  uint8_t hi = Wire.read();
18  uint8_t lo = Wire.read();
19  return (int16_t)(((uint16_t)hi << 8) | lo);
20}
21
22void setup() {
23  Serial.begin(115200);
24  Wire.begin();
25  Wire.setClock(400000);                // hızlı mod 400 kHz / fast mode 400 kHz
26  writeReg(0x6B, 0x00);                 // PWR_MGMT_1: uykudan uyandır / wake up from sleep
27  Wire.beginTransmission(MPU_ADDR);
28  Wire.write(0x75);                     // WHO_AM_I yazmacı / WHO_AM_I register
29  Wire.endTransmission(false);
30  Wire.requestFrom(MPU_ADDR, (byte)1);
31  Serial.print(F("WHO_AM_I = 0x"));
32  Serial.println(Wire.read(), HEX);     // 68 beklenir / expect 68
33}
34
35void loop() {
36  int16_t raw = readWord(0x41);         // TEMP_OUT_H ve TEMP_OUT_L / TEMP_OUT_H and TEMP_OUT_L
37  float tempC = raw / 340.0 + 36.53;    // veri sayfasındaki formül / datasheet formula
38  int16_t az = readWord(0x3F);          // Z ekseni ivmesi / Z-axis acceleration
39  Serial.print(F("Sicaklik / temp: "));
40  Serial.print(tempC, 1);
41  Serial.print(F(" C   AccZ: "));
42  Serial.println(az / 16384.0, 2);      // +-2g aralığında 16384 = 1 g / 16384 = 1 g at +-2g
43  delay(500);
44}

Fíjate en la línea endTransmission(false) de la función de lectura: cambia de sentido con un START repetido en lugar de un STOP, así ningún otro dispositivo puede colarse y el sensor no olvida qué registro se le pidió. Si WHO_AM_I devuelve 0x68, la comunicación es perfecta. En módulos clónicos baratos el valor puede ser 0x70 u otro número; eso indica que el chip es un modelo compatible pero distinto, como el MPU6500, y es la razón por la que algunas librerías dicen «sensor no encontrado». La fórmula de temperatura (valor en bruto / 340 + 36,53) sale directamente de la hoja de datos del MPU6050; para la aceleración en el rango de ±2 g, un valor en bruto de 16384 equivale a 1 g, así que un sensor plano sobre la mesa marca unos 1,00 en el eje Z.

Varios dispositivos en el mismo bus y conflictos de dirección

La gran ventaja de I2C es que puedes conectar dispositivos en paralelo a los mismos dos cables siempre que sus direcciones sean distintas. Por ejemplo, una LCD (0x27), una OLED (0x3C), un BMP280 (0x76) y un reloj DS3231 (0x68) comparten sin problemas los pines A4 y A5; cada librería habla con su propia dirección mientras los demás dispositivos escuchan en silencio. El problema llega cuando dos dispositivos tienen la misma dirección: ambos responden con ACK, sus datos chocan y normalmente ninguno funciona. Estas son las soluciones:

• Cambia el pin de dirección: Si conectas el pin AD0 del MPU6050 a 3,3 V, su dirección pasa a 0x69 y desaparece el conflicto con el DS3231 (0x68).
• Usa los puentes de soldadura: Los puentes A0–A2 de los módulos LCD ofrecen 8 direcciones y el pin ADDR del ADS1115 ofrece 4.
• Abre un segundo bus I2C: Lleva el dispositivo en conflicto a otros pines con Wire1 en el ESP32 o con I2C1 en la Pico.
• Añade un multiplexor I2C: El TCA9548A abre ocho subbuses independientes desde una sola dirección (0x70); podrías conectar incluso ocho OLED con la misma dirección.
• Dispositivos con dirección fija: En algunos chips, como el DS1307 o el HTU21D, la dirección no se puede cambiar; con ellos solo sirve un bus aparte o un multiplexor.

I2C con ESP32: los pines que quieras y dos buses separados

En el ESP32, el hardware I2C se puede asignar a los pines con mucha flexibilidad. Los pines por defecto son GPIO 21 (SDA) y GPIO 22 (SCL), pero con Wire.begin(SDA, SCL) puedes elegir casi cualquier par de GPIO. El ESP32 clásico y el ESP32-S3 tienen dos controladores I2C, así que puedes usar dos sensores con la misma dirección en dos buses separados; el ESP32-C3 solo tiene un controlador. Los GPIO 34–39 son solo de entrada y no sirven para I2C. Para ver el mapa completo de pines de la placa consulta la herramienta Pinout, y para una introducción general el artículo ¿Qué es el ESP32?.

1#include <Wire.h>
2
3// Klasik ESP32'de iki I2C denetleyicisi vardır: Wire ve Wire1 / the classic ESP32 has two I2C controllers: Wire and Wire1
4
5void scan(TwoWire &bus, const char *name) {
6  Serial.printf("%s:\n", name);
7  for (uint8_t addr = 0x08; addr <= 0x77; addr++) {
8    bus.beginTransmission(addr);
9    if (bus.endTransmission() == 0) {
10      Serial.printf("  bulundu / found 0x%02X\n", addr);
11    }
12  }
13}
14
15void setup() {
16  Serial.begin(115200);
17  Wire.begin(21, 22);                   // SDA, SCL: varsayılan pinler / default pins
18  Wire1.begin(32, 33, 400000);          // SDA, SCL, hız: başka iki GPIO / SDA, SCL, speed: any two other GPIOs
19  scan(Wire, "Wire  (SDA 21, SCL 22)");
20  scan(Wire1, "Wire1 (SDA 32, SCL 33)");
21}
22
23void loop() {
24}

I2C con la Raspberry Pi Pico (MicroPython)

El chip RP2040 de la Pico tiene dos controladores llamados I2C0 e I2C1, y cada uno puede asignarse a varios pares de pines. Para I2C0 puedes usar GP0/GP1, GP4/GP5, GP8/GP9, GP12/GP13, GP16/GP17 y GP20/GP21; para I2C1, GP2/GP3, GP6/GP7, GP10/GP11, GP14/GP15, GP18/GP19 y GP26/GP27. En cada par, el pin par es SDA y el impar es SCL. En MicroPython el escáner es una sola línea: i2c.scan() devuelve la lista de direcciones que responden con ACK. Como la Pico funciona a 3,3 V, alimentar los módulos desde el pin 3V3(OUT) es lo más seguro; aunque el RP2040 admite también el modo rápido plus de 1 MHz, quedarse en 400 kHz en una protoboard da menos sorpresas. Para tus primeros pasos con la Pico, lee ¿Qué es la Raspberry Pi Pico?.

1from machine import Pin, I2C
2
3i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)   # I2C0: GP4 = SDA, GP5 = SCL
4devices = i2c.scan()                                 # ACK veren adresler / addresses that ACK
5
6if devices:
7    for addr in devices:
8        print("Bulundu / found:", hex(addr))
9else:
10    print("Cihaz yok / no devices")
11
12# MPU6050 varsa WHO_AM_I yazmacını oku / if an MPU6050 is present, read WHO_AM_I
13if 0x68 in devices:
14    i2c.writeto_mem(0x68, 0x6B, b"\x00")             # uykudan uyandır / wake up
15    who = i2c.readfrom_mem(0x68, 0x75, 1)[0]
16    print("WHO_AM_I:", hex(who))                     # 0x68 beklenir / expect 0x68

Ideas de proyectos con I2C

• Miniestación meteorológica: Mide presión y temperatura con un BMP280 y muéstralas en una pantalla OLED; los dos módulos comparten los mismos dos cables.
• Reloj digital: Lee la hora de un módulo DS3231 y muéstrala en una pantalla LCD I2C.
• Indicador de inclinación: Calcula el ángulo con un MPU6050 y dibuja el resultado en la OLED como un nivel de burbuja.
• Nodo de sensores Wi-Fi: Consulta desde el móvil un sensor conectado a los pines D1 y D2 de un ESP8266 NodeMCU.
• Brazo robótico con 16 servos: Controla 16 servos con solo dos pines gracias al driver PCA9685.
• Registrador de datos: Guarda una medida por minuto en una EEPROM AT24C256 para que los datos sobrevivan a un corte de luz.

Errores frecuentes y cómo solucionarlos

I2C es la forma más práctica de añadir pantallas, relojes, sensores y memoria a tu proyecto con solo dos cables; en cuanto entiendas las direcciones, las resistencias pull-up y el código escáner, resolverás la mayoría de problemas en pocos minutos. En la aplicación BlueGrays encontrarás proyectos que usan I2C, como la pantalla LCD I2C, el juego Pong en una pantalla OLED, un reloj digital con DS1307 y una pantalla del tiempo con ESP32, con esquemas de circuito y código paso a paso.