PCF8574 Arduino: expansor I2C de 8 pines, direcciones y código
Guía del PCF8574 con Arduino: 8 pines extra de entrada y salida por I2C, tabla de direcciones A0-A2, LED y botones, interrupción INT, módulo LCD y MCP23017.
El PCF8574 es un expansor I2C económico que le da a tu Arduino 8 pines extra de entrada y salida usando solo dos cables (SDA y SCL). Usar el PCF8574 con Arduino conviene siempre que te quedas sin pines: cuando una pantalla LCD, un sensor y unos módulos relé ya ocupan casi todos, el PCF8574 se cuelga del mismo bus I2C y te entrega 8 pines más para botones y LED. Con los pines de dirección A0, A1 y A2 puedes conectar hasta 8 módulos al mismo bus y llegar a 64 pines adicionales.
En esta guía conocerás los pines cuasi bidireccionales del PCF8574, por qué eso hace que los LED enciendan al escribir LOW y cómo se leen los botones. Verás la tabla de direcciones (PCF8574 y PCF8574A), leerás botones con interrupción mediante el pin INT, descubrirás que el módulo I2C del LCD que usas siempre es en realidad un PCF8574 y lo compararás con el MCP23017. El código está listo para Arduino Uno, ESP32 y Raspberry Pi Pico (MicroPython).

¿Qué es el PCF8574 y cómo funciona?
Dentro del PCF8574 hay un registro de salida (latch) de 8 bits. El Arduino manda un solo byte por I2C y cada bit fija el estado de un pin: P0 es el bit menos significativo y P7 el más significativo. Los pines no funcionan como salidas push-pull clásicas. En LOW, el pin se une a GND mediante un interruptor fuerte y puede absorber hasta 25 mA. En HIGH, solo lo mantiene arriba una fuente de corriente débil de unos 100 µA. A este diseño se le llama cuasi bidireccional y tiene dos consecuencias importantes: los LED se conectan de modo que el pin absorba la corriente (ánodo a VCC), y para usar un pin como entrada primero hay que escribirle un 1. Cuando un botón lleva ese pin en HIGH a GND, lees un 0. Al encender, todos los pines están en HIGH.
| Característica | Valor |
|---|---|
| Pines | 8 (P0–P7), cuasi bidireccionales |
| Alimentación | 2,5–6 V (funciona con 3,3 V y 5 V) |
| Interfaz | I2C, hasta 100 kHz |
| Dirección | PCF8574: 0x20–0x27, PCF8574A: 0x38–0x3F |
| Corriente de salida en LOW | Hasta 25 mA por pin (absorbe) |
| Corriente de salida en HIGH | Unos 100 µA (pull-up débil) |
| Interrupción | Pin INT, drenador abierto, activo en LOW |
| Encapsulado | DIP-16 (PCF8574P) y SO-16 (PCF8574T) |
Pines del PCF8574 y conexiones
| PCF8574 / módulo | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V | 3V3 | 3V3 (OUT) |
| GND | GND | GND | GND |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| INT (opcional) | D2 | GPIO 4 | GP6 |
| P0–P3 | LED: ánodo a VCC con resistencia, cátodo al pin | Igual | Igual |
| P4–P7 | Botones: una pata al pin y la otra a GND | Igual | Igual |
En los ejemplos van cuatro LED en P0–P3 y cuatro botones en P4–P7. El ánodo de cada LED va a VCC a través de una resistencia de 330 Ω y el cátodo al pin del PCF8574; al escribir 0 en el pin, la corriente pasa por el LED hacia el pin y el LED enciende. A 5 V, 330 Ω equivalen a (5 - 2) / 330 ≈ 9 mA para un LED rojo; elige el valor adecuado para tu LED con la calculadora de resistencia para LED. Los botones no necesitan resistencia propia, porque la fuente de corriente débil del chip hace de pull-up. Aun así, con cables largos en la protoboard conviene un pull-up externo de 10 kΩ contra el ruido; la base del tema está en resistencias pull-up y pull-down. Si usas el chip suelto en encapsulado DIP-16, los pines 1–3 son A0–A2, 4–7 y 9–12 son P0–P7, el 8 es GND, el 13 INT, el 14 SCL, el 15 SDA y el 16 VCC.
Elegir la dirección: A0, A1, A2 y PCF8574A
| A2 | A1 | A0 | PCF8574 | PCF8574A |
|---|---|---|---|---|
| 0 | 0 | 0 | 0x20 | 0x38 |
| 0 | 0 | 1 | 0x21 | 0x39 |
| 0 | 1 | 0 | 0x22 | 0x3A |
| 0 | 1 | 1 | 0x23 | 0x3B |
| 1 | 0 | 0 | 0x24 | 0x3C |
| 1 | 0 | 1 | 0x25 | 0x3D |
| 1 | 1 | 0 | 0x26 | 0x3E |
| 1 | 1 | 1 | 0x27 | 0x3F |
La dirección depende de si A0–A2 van a GND o a VCC; en la tabla, 1 significa VCC y 0 significa GND. Los módulos expansores morados más comunes traen jumpers o pequeños interruptores DIP para estos tres pines y suelen venir en 0x20. Con 8 módulos del mismo tipo obtienes 64 pines, y si mezclas PCF8574 y PCF8574A llegas a 16 módulos y 128 pines. Si no estás seguro de la dirección, corre el escáner I2C de qué es I2C o de la guía de pantalla LCD I2C; si el chip trae una "A" en su nombre, la dirección está entre 0x38 y 0x3F.
Primer programa sin librería: leer botones y encender LED
1// PCF8574: P0-P3 LED (LOW = yanar), P4-P7 düğme (GND'ye) / P0-P3 LEDs (LOW = on), P4-P7 buttons (to GND)
2#include <Wire.h>
3
4const uint8_t PCF_ADDR = 0x20; // A0, A1, A2 = GND
5uint8_t lastButtons = 0x0F;
6
7void pcfWrite(uint8_t value) {
8 Wire.beginTransmission(PCF_ADDR);
9 Wire.write(value); // 8 pinin hepsi tek baytta / all 8 pins in one byte
10 Wire.endTransmission();
11}
12
13uint8_t pcfRead() {
14 Wire.requestFrom(PCF_ADDR, (uint8_t)1);
15 return Wire.available() ? Wire.read() : 0xFF;
16}
17
18void setup() {
19 Serial.begin(9600);
20 Wire.begin(); // Uno: SDA = A4, SCL = A5
21 pcfWrite(0xFF); // hepsi HIGH: LED'ler sönük, girişler hazır / all HIGH: LEDs off, inputs ready
22}
23
24void loop() {
25 uint8_t buttons = pcfRead() >> 4; // P4-P7, basılı = 0 / pressed = 0
26 // Üst 4 bit 1 kalmalı (giriş); basılı düğme kendi LED'ini yakar
27 // Upper 4 bits must stay 1 (inputs); a pressed button lights its LED
28 pcfWrite(0xF0 | buttons);
29 if (buttons != lastButtons) {
30 lastButtons = buttons;
31 Serial.print("Buttons P7..P4: ");
32 Serial.println(buttons | 0x10, BIN); // baştaki 1 sıfırları göstermek için / leading 1 keeps the zeros visible
33 }
34 delay(20);
35}Para hablar con el PCF8574 ni siquiera necesitas librería: un byte enviado con Wire.write() fija los 8 pines a la vez, y un byte leído con Wire.requestFrom() da el estado actual de los 8. Al desplazar el byte leído 4 bits a la derecha, los botones de P4–P7 quedan en los cuatro bits bajos; un botón presionado se lee como 0. Al escribir, 0xF0 | buttons hace dos cosas: mantiene en 1 los cuatro bits altos para que P4–P7 sigan siendo entradas y copia el estado de los botones en los cuatro bits bajos. Como el bit de un botón presionado es 0, el pin del LED correspondiente queda en LOW y el LED enciende. Si las operaciones con bits son nuevas para ti, empieza por sistemas numéricos y operaciones con bits.
Pin INT e interrupción: leer botones sin consultar todo el tiempo
El código anterior ocupa el bus I2C decenas de veces por segundo. El pin INT del PCF8574 baja a LOW en cuanto cualquier entrada cambia desde la última lectura y se queda así hasta que el chip se lee o se escribe. Si lo conectas a un pin de interrupción del Arduino, solo lees cuando algo cambia; el resto del tiempo el bus y el procesador quedan libres. El siguiente ejemplo usa la librería PCF8574 de Rob Tillaart, que instalas desde el Gestor de librerías. Desde la versión 0.4 de la librería tienes que llamar tú mismo a Wire.begin() antes de pcf.begin().
1// PCF8574 + INT pini: yalnız değişiklik olunca oku / read only when something changes
2#include <Wire.h>
3#include <PCF8574.h> // Rob Tillaart
4
5#ifndef IRAM_ATTR
6#define IRAM_ATTR // AVR'de boş / empty on AVR
7#endif
8
9#if defined(ESP32)
10const int INT_PIN = 4; // PCF8574 INT -> GPIO 4
11#else
12const int INT_PIN = 2; // PCF8574 INT -> D2 (Uno kesme pini / Uno interrupt pin)
13#endif
14
15PCF8574 pcf(0x20);
16volatile bool changed = false;
17uint8_t lastState = 0xFF;
18
19void IRAM_ATTR onPcfInt() {
20 changed = true; // yalnız bayrak kaldır / just raise a flag
21}
22
23void setup() {
24 Serial.begin(115200);
25#if defined(ESP32)
26 Wire.begin(21, 22); // SDA, SCL
27#else
28 Wire.begin();
29#endif
30 if (!pcf.begin(0xFF)) Serial.println("PCF8574 not found");
31 pinMode(INT_PIN, INPUT_PULLUP); // INT open-drain çıkış, pull-up şart / INT is open-drain, needs a pull-up
32 attachInterrupt(digitalPinToInterrupt(INT_PIN), onPcfInt, FALLING);
33}
34
35void loop() {
36 if (!changed) return;
37 delay(20); // kontaklar otursun (tuş arkı) / let the contacts settle (bounce)
38 changed = false;
39 uint8_t state = pcf.read8(); // okumak INT'i sıfırlar / reading clears INT
40 uint8_t fell = lastState & ~state; // 1'den 0'a inen bitler = yeni basışlar / bits that went 1 -> 0 = new presses
41 lastState = state;
42 for (uint8_t i = 4; i < 8; i++) {
43 if (fell & (1 << i)) {
44 pcf.toggle(i - 4); // P4 -> P0 LED, P5 -> P1 LED ...
45 Serial.print("LED P");
46 Serial.println(i - 4);
47 }
48 }
49}La rutina de interrupción solo levanta una bandera, porque hacer operaciones I2C dentro de una interrupción da problemas tanto en el Uno como en el ESP32. Cuando loop() ve la bandera, espera 20 ms a que termine el rebote de los contactos del botón, luego lee todo el puerto con read8(), lo que además libera INT. La expresión lastState & ~state encuentra los bits que pasaron de 1 a 0, es decir, los botones recién presionados. Cada nueva pulsación cambia el LED correspondiente con toggle(); como toggle() usa el byte de salida que guarda la librería, los pines de entrada siguen recibiendo un 1. La idea general de las interrupciones está en interrupciones en Arduino.
El módulo I2C del LCD es en realidad un PCF8574
Mira con atención la plaquita I2C azul o negra soldada detrás de un LCD de 16x2 y verás un chip marcado PCF8574T o PCF8574AT. La librería LiquidCrystal_I2C maneja los 8 pines de ese chip como si estuvieran conectados directo a la interfaz paralela del LCD y envía los datos en modo de 4 bits. Por eso la dirección del LCD suele ser 0x27 o 0x3F: en el adaptador, A0–A2 van a VCC con resistencias pull-up, así que los tres bits son 1; en un PCF8574T eso da 0x27 y en un PCF8574AT 0x3F. Si unes con soldadura los puentes A0–A2 de la parte trasera cambias la dirección y puedes usar varios LCD en el mismo bus.
| Pin del PCF8574 | Conexión del LCD |
|---|---|
| P0 | RS (comando o dato) |
| P1 | RW (lectura o escritura) |
| P2 | E (enable) |
| P3 | Retroiluminación (con transistor) |
| P4–P7 | D4–D7 (bus de datos de 4 bits) |

PCF8574 con ESP32 y Raspberry Pi Pico
En el ESP32 los dos ejemplos funcionan sin cambios; la única diferencia es que Wire.begin(21, 22) indica los pines I2C de forma explícita, y el ejemplo con interrupción ya lo hace dentro de su bloque #if defined(ESP32). En la Raspberry Pi Pico, la clase machine.I2C de MicroPython hace lo mismo en pocas líneas: writeto() escribe un byte y readfrom() lee uno. El código de abajo escanea el bus I2C al arrancar, muestra una luz que corre por P0–P3 mientras no presionas nada y enciende el LED correspondiente cuando presionas un botón. Quédate en 100 kHz; la hoja de datos del PCF8574 no garantiza velocidades mayores.
1# Raspberry Pi Pico + PCF8574 (MicroPython): P0-P3 LED, P4-P7 düğme / P0-P3 LEDs, P4-P7 buttons
2from machine import Pin, I2C
3import time
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000) # PCF8574 en fazla 100 kHz / max 100 kHz
6ADDR = 0x20
7print("I2C:", [hex(a) for a in i2c.scan()]) # 0x20 görünmeli / 0x20 should appear
8
9
10def pcf_write(value):
11 i2c.writeto(ADDR, bytes([value]))
12
13
14def pcf_read():
15 return i2c.readfrom(ADDR, 1)[0]
16
17
18pcf_write(0xFF) # hepsi HIGH: LED'ler sönük / all HIGH: LEDs off
19led = 0
20while True:
21 buttons = pcf_read() >> 4 # basılı = 0 / pressed = 0
22 if buttons != 0x0F:
23 out = 0xF0 | buttons # düğmeyi LED'e aynala / mirror buttons to LEDs
24 else:
25 out = 0xF0 | (~(1 << led) & 0x0F) # yürüyen ışık / running light
26 led = (led + 1) % 4
27 pcf_write(out)
28 time.sleep_ms(150)¿PCF8574, MCP23017 o 74HC595?
| Característica | PCF8574 | MCP23017 | 74HC595 |
|---|---|---|---|
| Pines extra | 8 | 16 | 8 salidas (encadenables) |
| Interfaz | I2C, 2 cables | I2C, 2 cables (versión SPI: MCP23S17) | Serie de 3 cables (tipo SPI) |
| Dirección de los pines | Cuasi bidireccional | Cada pin se elige como entrada o salida | Solo salida |
| Corriente de salida | Absorbe 25 mA en LOW, muy débil en HIGH | 25 mA por pin, entrega y absorbe | Se recomiendan pocos mA por pin |
| Pull-up interno | Fuente de corriente débil (fija) | 100 kΩ, se activa por software | No tiene |
| Interrupción | 1 INT | 2 INT (INTA, INTB) | No tiene |
| Velocidad I2C | 100 kHz | Hasta 1,7 MHz | - |
| Ideal para | Botones, LED y E/S sencillas | Muchos pines, corriente real de salida y velocidad | Muchos LED y displays de 7 segmentos |
Si solo necesitas leer unos botones y encender algunos LED, el PCF8574 es la opción más barata y sencilla. Si quieres manejar LED con HIGH, elegir la dirección de cada pin, tener 16 pines en un solo chip o trabajar a 400 kHz o más, pasa al MCP23017. Y si solo necesitas salidas para muchos LED o displays de 7 segmentos, el registro de desplazamiento 74HC595 es más rápido y aún más barato.
Ideas de proyectos con el PCF8574
- Placa de relés: Maneja un módulo relé de ocho canales desde un solo bus I2C; las entradas de relé activas en LOW encajan perfecto con la lógica del PCF8574.
- Teclado matricial: Conecta las 8 líneas de un teclado 4x4 al PCF8574 y deja libres los pines del Arduino.
- Panel de botones: Lee 8 botones para un juego o un control mediante la interrupción INT.
- Indicador de estado: Muestra el estado de alarma de varios sensores en una barra de 8 LED.
- Varias pantallas: Conecta dos LCD al mismo Arduino con adaptadores de direcciones distintas.
- Efecto auto fantástico: Haz correr una luz por el PCF8574 en un proyecto que ya no tiene pines libres.
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| No aparece en el escaneo I2C | SDA y SCL invertidos o sin GND común | Revisa el cableado; en el Uno SDA = A4 y SCL = A5 |
| La dirección no es la esperada | El chip es un PCF8574A o A0–A2 están en otra posición | Revisa el rango 0x38–0x3F y los jumpers |
| El LED no enciende o brilla muy poco | Se intenta encender el LED con HIGH | Ánodo a VCC con resistencia, cátodo al pin; escribe 0 |
| El botón siempre lee 0 o siempre 1 | Antes se escribió un 0 en el pin de entrada | Manda un 1 a las entradas en cada escritura (0xF0 | ...) |
| La interrupción llega una vez y ya no vuelve | El puerto no se leyó y INT se quedó en LOW | Lee el puerto con read8() después de cada interrupción |
| Falla la comunicación con muchos módulos | Los pull-up en paralelo dan una resistencia total muy baja | Quita las resistencias SDA/SCL de algunos módulos y acorta los cables |
El PCF8574 resuelve la falta de pines con dos cables y es fácil de aprender; en cuanto entiendes su lógica cuasi bidireccional, manejas LED, botones, relés y LCD en el mismo bus sin complicarte. En la app BlueGrays encontrarás proyectos de LCD I2C, calculadora, teclado matricial, luces secuenciales y botones con diagramas y código paso a paso, listos para ampliarlos con un PCF8574 cuando te falten pines.
Preguntas frecuentes
¿Cómo encuentro la dirección I2C del PCF8574?
Según A0–A2, el PCF8574 queda entre 0x20 y 0x27 y el PCF8574A entre 0x38 y 0x3F. Lo más seguro es correr un escáner I2C y leer la dirección en el Monitor Serie. En los adaptadores de LCD suele ser 0x27 o 0x3F.
¿Cuántos PCF8574 puedo conectar a un Arduino?
Cada PCF8574 suma 8 pines y A0–A2 permiten 8 direcciones, así que con módulos del mismo tipo llegas a 64 pines. Como el PCF8574 y el PCF8574A usan rangos distintos, si los mezclas alcanzas 16 módulos y 128 pines. Con muchos módulos cuida el valor total de las resistencias pull-up del I2C.
¿Por qué el LED del PCF8574 enciende con LOW?
Los pines del PCF8574 pueden absorber hasta 25 mA en LOW, pero solo entregan unos 100 µA en HIGH. Por eso el ánodo del LED va a VCC con una resistencia y el cátodo al pin, y al escribir 0 se enciende. Conectado al revés, el LED queda apagado o muy tenue.
¿Cómo leo un botón con el PCF8574?
Primero escribe un 1 en el pin para que quede en HIGH con el pull-up débil. Cuando el botón lleva el pin a GND, lees un 0. Si escribes un 0 en una entrada, se queda en LOW para siempre y el botón ya no se puede leer.
¿Qué diferencia hay entre el PCF8574 y el MCP23017?
El PCF8574 es un chip sencillo con 8 pines cuasi bidireccionales y un límite de 100 kHz. El MCP23017 ofrece 16 pines, dirección por pin, pull-ups activables, dos salidas de interrupción y hasta 1,7 MHz de velocidad I2C. Para botones y LED basta el PCF8574; para proyectos grandes conviene el MCP23017.
¿El PCF8574 funciona con ESP32 a 3,3 V?
Sí, el PCF8574 trabaja de 2,5 a 6 V, así que se conecta directo al ESP32 y a la Raspberry Pi Pico. Aliméntalo con 3,3 V; a 5 V los pull-up llevan SDA y SCL a 5 V y eso puede dañar las placas de 3,3 V. En el ESP32 indica los pines I2C con Wire.begin(21, 22).
Proyectos para hacer después de leer esto
Ver todos los proyectos
Luz secuencial LED
Luces que se encienden una tras otra, como si corrieran. El Arduino enciende seis LED de uno en uno; cada uno brilla un instante y se apaga, así que la luz recorre la fila de principio a fin y vuelve…

Efecto coche fantástico con LED
La clásica luz que va y viene: un punto de luz recorre seis LED de un extremo al otro y luego regresa.

Encender un LED con pulsador (Push)
Como un timbre: la luz se enciende mientras pulsas y se apaga cuando sueltas. El Arduino escucha el botón todo el rato; mientras está pulsado enciende el LED, y en cuanto levantas el dedo lo apaga.

Encender y apagar un LED con un botón
Pulsas el botón una vez y la luz se enciende, lo pulsas otra vez y se apaga, igual que el interruptor de tu habitación.

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…

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).

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.

Funcionamiento del teclado 4x4
En el teclado de 4x4, muy parecido a las teclas de un teléfono, el Arduino sabe al instante qué tecla has pulsado y la escribe en la pantalla del ordenador.
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

