PCF8574 Arduino: espansore I2C da 8 pin, indirizzi e codice
Guida PCF8574 Arduino: 8 ingressi e uscite in più via I2C, tabella indirizzi A0-A2, collegare LED e pulsanti, interrupt INT, modulo LCD e confronto MCP23017.
Il PCF8574 è un espansore I2C economico che regala al tuo Arduino 8 ingressi e uscite in più usando solo due fili (SDA e SCL). Usare il PCF8574 con Arduino conviene ogni volta che i pin finiscono: quando un display LCD, un sensore e qualche relè ne occupano già quasi tutti, il PCF8574 si aggancia allo stesso bus I2C e ti dà altri 8 pin per pulsanti e LED. Con i pin di indirizzo A0, A1 e A2 puoi collegare fino a 8 moduli sullo stesso bus e arrivare a 64 pin aggiuntivi.
In questa guida scoprirai i pin quasi bidirezionali del PCF8574, perché per questo i LED si accendono quando scrivi LOW e come si leggono i pulsanti. Avrai la tabella degli indirizzi (PCF8574 e PCF8574A), leggerai i pulsanti con un interrupt tramite il pin INT, scoprirai che il modulo I2C dell'LCD che usi sempre è in realtà un PCF8574 e lo confronterai con l'MCP23017. Il codice è pronto per Arduino Uno, ESP32 e Raspberry Pi Pico (MicroPython).

Che cos'è il PCF8574 e come funziona?
Dentro il PCF8574 c'è un registro di uscita (latch) a 8 bit. Arduino invia un solo byte via I2C e ogni bit imposta lo stato di un pin: P0 è il bit meno significativo, P7 il più significativo. I pin non funzionano come le classiche uscite push-pull. A LOW il pin viene collegato a GND tramite un interruttore robusto e può assorbire fino a 25 mA. A HIGH, invece, lo tiene alto solo una debole sorgente di corrente di circa 100 µA. Questa struttura si chiama quasi bidirezionale e ha due conseguenze importanti: i LED vanno collegati in modo che sia il pin ad assorbire la corrente (anodo verso VCC), e per usare un pin come ingresso devi prima scriverci un 1. Quando un pulsante porta quel pin a GND, leggi uno 0. All'accensione tutti i pin sono a HIGH.
| Caratteristica | Valore |
|---|---|
| Pin | 8 (P0–P7), quasi bidirezionali |
| Alimentazione | 2,5–6 V (funziona a 3,3 V e a 5 V) |
| Interfaccia | I2C, fino a 100 kHz |
| Indirizzo | PCF8574: 0x20–0x27, PCF8574A: 0x38–0x3F |
| Corrente di uscita a LOW | Fino a 25 mA per pin (assorbita) |
| Corrente di uscita a HIGH | Circa 100 µA (pull-up debole) |
| Interrupt | Pin INT, open-drain, attivo a LOW |
| Package | DIP-16 (PCF8574P) e SO-16 (PCF8574T) |
Pinout del PCF8574 e collegamenti
| PCF8574 / modulo | 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 (facoltativo) | D2 | GPIO 4 | GP6 |
| P0–P3 | LED: anodo a VCC tramite resistenza, catodo al pin | Uguale | Uguale |
| P4–P7 | Pulsanti: un piedino al pin, l'altro a GND | Uguale | Uguale |
Negli esempi ci sono quattro LED su P0–P3 e quattro pulsanti su P4–P7. L'anodo di ogni LED va a VCC tramite una resistenza da 330 Ω e il catodo al pin del PCF8574; scrivendo 0 sul pin, la corrente passa dal LED verso il pin e il LED si accende. A 5 V, 330 Ω significano (5 - 2) / 330 ≈ 9 mA per un LED rosso; scegli il valore giusto per il tuo LED con il calcolatore di resistenza per LED. I pulsanti non hanno bisogno di una resistenza propria, perché la debole sorgente di corrente del chip fa da pull-up. Con cavi lunghi sulla breadboard è comunque utile un pull-up esterno da 10 kΩ contro i disturbi; le basi sono nella guida resistenze di pull-up e pull-down. Se usi il chip nudo in package DIP-16, i pin 1–3 sono A0–A2, 4–7 e 9–12 sono P0–P7, l'8 è GND, il 13 INT, il 14 SCL, il 15 SDA e il 16 VCC.
Scegliere l'indirizzo: A0, A1, A2 e 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 |
L'indirizzo dipende dal collegamento di A0–A2 a GND o a VCC; in tabella 1 significa VCC e 0 significa GND. I diffusi moduli di espansione viola hanno jumper o piccoli dip switch per questi tre pin e di fabbrica sono quasi sempre a 0x20. Con 8 moduli dello stesso tipo ottieni 64 pin, mescolando PCF8574 e PCF8574A arrivi a 16 moduli e 128 pin. Se non sei sicuro dell'indirizzo, lancia lo scanner I2C della guida cos'è l'I2C o di quella sul display LCD I2C; se la sigla del chip contiene una "A", l'indirizzo è tra 0x38 e 0x3F.
Primo sketch senza libreria: leggere pulsanti e pilotare 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}Per parlare con il PCF8574 non serve nemmeno una libreria: un byte inviato con Wire.write() imposta tutti e 8 i pin in un colpo, e un byte letto con Wire.requestFrom() restituisce lo stato attuale degli 8 pin. Spostando il byte letto di 4 bit a destra, i pulsanti su P4–P7 finiscono nei quattro bit bassi; un pulsante premuto si legge come 0. In scrittura, 0xF0 | buttons fa due cose: mantiene a 1 i quattro bit alti perché P4–P7 restino ingressi, e copia lo stato dei pulsanti nei quattro bit bassi. Dato che il bit di un pulsante premuto è 0, il pin del LED corrispondente va a LOW e il LED si accende. Se le operazioni sui bit sono una novità, comincia da sistemi di numerazione e operazioni sui bit.
Il pin INT: leggere i pulsanti con un interrupt invece del polling
Lo sketch precedente impegna il bus I2C decine di volte al secondo. Il pin INT del PCF8574 va a LOW appena un ingresso cambia rispetto all'ultima lettura e resta così finché il chip non viene letto o scritto. Collegandolo a un pin di interrupt di Arduino leggi solo quando qualcosa cambia; il resto del tempo bus e processore restano liberi. L'esempio seguente usa la libreria PCF8574 di Rob Tillaart, che installi dal Gestore librerie. Dalla versione 0.4 della libreria devi chiamare tu Wire.begin() prima di 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 routine di interrupt si limita ad alzare un flag, perché fare operazioni I2C dentro un interrupt crea problemi sia sull'Uno sia sull'ESP32. Quando loop() vede il flag, aspetta 20 ms che finiscano i rimbalzi dei contatti, poi legge tutta la porta con read8(), che azzera anche INT. L'espressione lastState & ~state trova i bit passati da 1 a 0, cioè i pulsanti appena premuti. Ogni nuova pressione inverte con toggle() il LED corrispondente; dato che toggle() parte dal byte di uscita memorizzato nella libreria, i pin di ingresso continuano a ricevere un 1. Il funzionamento generale degli interrupt è spiegato in interrupt su Arduino.
Il modulo I2C dell'LCD è in realtà un PCF8574
Guarda bene la schedina I2C blu o nera saldata dietro un LCD 16x2: troverai un chip con la sigla PCF8574T o PCF8574AT. La libreria LiquidCrystal_I2C pilota gli 8 pin di questo chip come se fossero collegati direttamente all'interfaccia parallela dell'LCD e invia i dati in modalità a 4 bit. Ecco perché l'indirizzo dell'LCD è quasi sempre 0x27 o 0x3F: sull'adattatore A0–A2 sono portati a VCC da resistenze di pull-up, quindi tutti e tre i bit valgono 1, che su un PCF8574T dà 0x27 e su un PCF8574AT 0x3F. Chiudendo con lo stagno i ponticelli A0–A2 sul retro cambi l'indirizzo e puoi usare più LCD sullo stesso bus.
| Pin del PCF8574 | Collegamento LCD |
|---|---|
| P0 | RS (comando o dato) |
| P1 | RW (lettura o scrittura) |
| P2 | E (enable) |
| P3 | Retroilluminazione (tramite transistor) |
| P4–P7 | D4–D7 (bus dati a 4 bit) |

PCF8574 con ESP32 e Raspberry Pi Pico
Sull'ESP32 entrambi gli esempi funzionano senza modifiche; l'unica differenza è che Wire.begin(21, 22) indica esplicitamente i pin I2C, e l'esempio con interrupt lo fa già nel suo blocco #if defined(ESP32). Sul Raspberry Pi Pico la classe machine.I2C di MicroPython fa lo stesso lavoro in poche righe: writeto() scrive un byte e readfrom() ne legge uno. Il codice qui sotto esegue la scansione del bus I2C all'avvio, mostra una luce che scorre su P0–P3 finché non premi nulla e accende il LED corrispondente quando premi un pulsante. Resta a 100 kHz; il datasheet del PCF8574 non garantisce velocità più alte.
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?
| Caratteristica | PCF8574 | MCP23017 | 74HC595 |
|---|---|---|---|
| Pin aggiuntivi | 8 | 16 | 8 uscite (collegabili in cascata) |
| Interfaccia | I2C, 2 fili | I2C, 2 fili (versione SPI: MCP23S17) | Seriale a 3 fili (tipo SPI) |
| Direzione dei pin | Quasi bidirezionale | Ogni pin impostabile come ingresso o uscita | Solo uscita |
| Corrente di uscita | Assorbe 25 mA a LOW, debolissima a HIGH | 25 mA per pin, sia in uscita sia in ingresso | Consigliati pochi mA per pin |
| Pull-up interno | Debole sorgente di corrente (fissa) | 100 kΩ, attivabile via software | Nessuno |
| Interrupt | 1 INT | 2 INT (INTA, INTB) | Nessuno |
| Velocità I2C | 100 kHz | Fino a 1,7 MHz | - |
| Ideale per | Pulsanti, LED e I/O semplici | Tanti pin, vera corrente di uscita e velocità | Tanti LED e display a 7 segmenti |
Se devi solo leggere qualche pulsante e accendere qualche LED, il PCF8574 è la scelta più economica e semplice. Se vuoi pilotare i LED con HIGH, scegliere la direzione di ogni pin, avere 16 pin in un unico chip o lavorare a 400 kHz e oltre, passa all'MCP23017. Se ti servono solo uscite per molti LED o display a 7 segmenti, lo shift register 74HC595 è più veloce e ancora più economico.
Idee di progetto con il PCF8574
- Scheda relè: pilota un modulo relè a otto canali da un unico bus I2C; gli ingressi dei relè attivi a LOW si sposano perfettamente con la logica del PCF8574.
- Tastierino: collega le 8 linee di un tastierino 4x4 al PCF8574 e lascia liberi i pin di Arduino.
- Pannello pulsanti: leggi 8 pulsanti per un gioco o un telecomando tramite l'interrupt INT.
- Indicatore di stato: mostra lo stato di allarme di più sensori su una barra di 8 LED.
- Più display: collega due LCD allo stesso Arduino con adattatori a indirizzi diversi.
- Effetto Supercar: fai scorrere una luce tramite il PCF8574 in un progetto che non ha più pin liberi.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Non compare nella scansione I2C | SDA e SCL invertiti o massa non in comune | Controlla i collegamenti; sull'Uno SDA = A4, SCL = A5 |
| Indirizzo diverso da quello atteso | Il chip è un PCF8574A o A0–A2 sono impostati diversamente | Controlla l'intervallo 0x38–0x3F e i jumper |
| Il LED non si accende o è debolissimo | Si cerca di accendere il LED con HIGH | Anodo a VCC tramite resistenza, catodo al pin; scrivi 0 |
| Il pulsante legge sempre 0 o sempre 1 | In precedenza è stato scritto 0 sul pin di ingresso | Invia un 1 agli ingressi a ogni scrittura (0xF0 | ...) |
| L'interrupt arriva una volta e poi mai più | Porta non letta, INT resta a LOW | Leggi la porta con read8() dopo ogni interrupt |
| La comunicazione si blocca con molti moduli | I pull-up in parallelo danno una resistenza totale troppo bassa | Togli le resistenze SDA/SCL da alcuni moduli e accorcia i cavi |
Il PCF8574 risolve la mancanza di pin con due fili e si impara in fretta; una volta capita la logica quasi bidirezionale, gestisci LED, pulsanti, relè e LCD sullo stesso bus senza fatica. Nell'app BlueGrays trovi progetti con LCD I2C, calcolatrice, tastierino, luci in sequenza e pulsanti con schemi e codice passo passo, pronti da ampliare con un PCF8574 quando i pin non bastano.
Domande frequenti
Come trovo l'indirizzo I2C del PCF8574?
A seconda di A0–A2, il PCF8574 sta tra 0x20 e 0x27 e il PCF8574A tra 0x38 e 0x3F. Il modo più sicuro è lanciare uno scanner I2C e leggere l'indirizzo nel Monitor seriale. Sugli adattatori LCD di solito è 0x27 o 0x3F.
Quanti PCF8574 posso collegare a un Arduino?
Ogni PCF8574 aggiunge 8 pin e A0–A2 permettono 8 indirizzi, quindi con moduli dello stesso tipo arrivi a 64 pin. Poiché PCF8574 e PCF8574A usano intervalli diversi, mescolandoli arrivi a 16 moduli e 128 pin. Con molti moduli fai attenzione al valore complessivo delle resistenze di pull-up I2C.
Perché il LED sul PCF8574 si accende a LOW?
I pin del PCF8574 possono assorbire fino a 25 mA a LOW, ma a HIGH forniscono solo circa 100 µA. Per questo l'anodo del LED va a VCC tramite una resistenza e il catodo al pin, e scrivendo 0 il LED si accende. Collegato al contrario resta spento o debolissimo.
Come leggo un pulsante con il PCF8574?
Prima scrivi un 1 sul pin, così resta a HIGH grazie al pull-up debole. Quando il pulsante porta il pin a GND, leggi uno 0. Se invece scrivi uno 0 su un ingresso, resta a LOW per sempre e il pulsante non si può più leggere.
Che differenza c'è tra PCF8574 e MCP23017?
Il PCF8574 è un chip semplice con 8 pin quasi bidirezionali e un limite di 100 kHz. L'MCP23017 offre 16 pin, direzione per singolo pin, pull-up attivabili, due uscite di interrupt e fino a 1,7 MHz sull'I2C. Per pulsanti e LED basta il PCF8574; per progetti più grandi conviene l'MCP23017.
Il PCF8574 funziona con ESP32 a 3,3 V?
Sì, il PCF8574 lavora da 2,5 a 6 V e si collega direttamente a ESP32 e Raspberry Pi Pico. Alimentalo a 3,3 V: a 5 V i pull-up portano SDA e SCL a 5 V e possono danneggiare le schede a 3,3 V. Sull'ESP32 indica i pin I2C con Wire.begin(21, 22).
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED in sequenza
Luci che si accendono una dopo l'altra, come se corressero. L'Arduino accende sei LED uno alla volta; ognuno brilla per un istante e si spegne, così la luce percorre la fila dall'inizio alla fine e…

Effetto Supercar con LED
La classica luce che va e viene: un punto luminoso scorre da un capo all'altro di sei LED e poi torna indietro.

Accendere un LED con un pulsante (Push)
Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

Accendere e spegnere un LED con un pulsante
Premi il pulsante una volta e la luce si accende, premilo di nuovo e si spegne, proprio come l'interruttore della tua stanza.

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

Schermo LCD I2C per ESP32 (16x2)
In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

Calcolatrice Arduino I2C
Si tratta di un progetto di calcolatore basato su Arduino che esegue operazioni di addizione, sottrazione, moltiplicazione e divisione utilizzando una tastiera a membrana 4x4 e un display LCD I2C 16x2. Grazie all'I2C, il collegamento del display avviene con soli 2 cavi, riducendo così l'ingombro dei cavi e mantenendo un maggior numero di pin utilizzabili. Sono inoltre disponibili l'ingresso di numeri decimali e il supporto di numeri negativi.

Funzionamento del tastierino 4x4
Sul tastierino 4x4, molto simile ai tasti di un telefono, l'Arduino capisce subito quale tasto hai premuto e lo scrive sullo schermo del computer.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

