Componentes · 8 min de lectura

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

Módulo I2C con chip PCF8574
Módulo I2C: el PCF8574 que lleva conecta 8 pines al bus I2C de dos hilos; los adaptadores de LCD usan exactamente el mismo chip.

¿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ísticaValor
Pines8 (P0–P7), cuasi bidireccionales
Alimentación2,5–6 V (funciona con 3,3 V y 5 V)
InterfazI2C, hasta 100 kHz
DirecciónPCF8574: 0x20–0x27, PCF8574A: 0x38–0x3F
Corriente de salida en LOWHasta 25 mA por pin (absorbe)
Corriente de salida en HIGHUnos 100 µA (pull-up débil)
InterrupciónPin INT, drenador abierto, activo en LOW
EncapsuladoDIP-16 (PCF8574P) y SO-16 (PCF8574T)

Pines del PCF8574 y conexiones

PCF8574 / móduloArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
INT (opcional)D2GPIO 4GP6
P0–P3LED: ánodo a VCC con resistencia, cátodo al pinIgualIgual
P4–P7Botones: una pata al pin y la otra a GNDIgualIgual

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.

Si conectas el LED al revés, con el ánodo en el pin del PCF8574 y el cátodo a GND, no encenderá o brillará muy poco, porque un pin en HIGH solo entrega unos 100 µA. Con ESP32 y Pico alimenta el módulo con 3,3 V: si va a 5 V, sus resistencias pull-up llevan SDA y SCL a 5 V, y eso puede dañar los pines de las placas de 3,3 V. Si enciendes muchos LED a la vez, mantén la corriente total por debajo de 80 mA.

Elegir la dirección: A0, A1, A2 y PCF8574A

A2A1A0PCF8574PCF8574A
0000x200x38
0010x210x39
0100x220x3A
0110x230x3B
1000x240x3C
1010x250x3D
1100x260x3E
1110x270x3F

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

C++ (Arduino IDE)
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().

C++ (Arduino IDE)
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 pin INT es una salida de drenador abierto y no puede ponerse en HIGH por sí solo; hace falta INPUT_PULLUP en el Arduino o un pull-up externo de 10 kΩ. Puedes unir los pines INT de varios PCF8574 a la misma línea de interrupción; cuando se dispare, lee todos uno tras otro y encuentra el que cambió. En el ESP32 la rutina de interrupción debe marcarse con IRAM_ATTR; el bloque #ifndef del código anula esa palabra en el Uno.

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 PCF8574Conexión del LCD
P0RS (comando o dato)
P1RW (lectura o escritura)
P2E (enable)
P3Retroiluminación (con transistor)
P4–P7D4–D7 (bus de datos de 4 bits)
LCD 2x16 con módulo I2C
LCD 2x16 con módulo I2C: el PCF8574 de la parte trasera reduce la interfaz paralela de 16 pines del LCD a solo 4 cables (GND, VCC, SDA, SCL).

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.

MicroPython
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ísticaPCF8574MCP2301774HC595
Pines extra8168 salidas (encadenables)
InterfazI2C, 2 cablesI2C, 2 cables (versión SPI: MCP23S17)Serie de 3 cables (tipo SPI)
Dirección de los pinesCuasi bidireccionalCada pin se elige como entrada o salidaSolo salida
Corriente de salidaAbsorbe 25 mA en LOW, muy débil en HIGH25 mA por pin, entrega y absorbeSe recomiendan pocos mA por pin
Pull-up internoFuente de corriente débil (fija)100 kΩ, se activa por softwareNo tiene
Interrupción1 INT2 INT (INTA, INTB)No tiene
Velocidad I2C100 kHzHasta 1,7 MHz-
Ideal paraBotones, LED y E/S sencillasMuchos pines, corriente real de salida y velocidadMuchos 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íntomaCausa probableSolución
No aparece en el escaneo I2CSDA y SCL invertidos o sin GND comúnRevisa el cableado; en el Uno SDA = A4 y SCL = A5
La dirección no es la esperadaEl chip es un PCF8574A o A0–A2 están en otra posiciónRevisa el rango 0x38–0x3F y los jumpers
El LED no enciende o brilla muy pocoSe 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 1Antes se escribió un 0 en el pin de entradaManda un 1 a las entradas en cada escritura (0xF0 | ...)
La interrupción llega una vez y ya no vuelveEl puerto no se leyó y INT se quedó en LOWLee el puerto con read8() después de cada interrupción
Falla la comunicación con muchos módulosLos pull-up en paralelo dan una resistencia total muy bajaQuita 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).

Ver todos los proyectos
Luz secuencial LED
AR-5Intermedio

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…

4.6(87)
218
Efecto coche fantástico con LED
AR-6Intermedio

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.

4.8(107)
214
Encender un LED con pulsador (Push)
AR-9Principiante

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.

4.8(114)
253
Encender y apagar un LED con un botón
AR-10Principiante

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.

4.7(103)
177
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

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…

4.8(53)
70
Pantalla LCD I2C para ESP32 (16x2)
ES-17Intermedio
Premium

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

4.9(23)
40
Calculadora Arduino I2C
AR-94Intermedio
Premium

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.

5.0(31)
43
Funcionamiento del teclado 4x4
AR-63Principiante
Premium

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.

4.5(27)
35