Componenti · 8 min di lettura

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

Modulo I2C con chip PCF8574
Modulo I2C: il PCF8574 montato sopra collega 8 pin al bus I2C a due fili; anche gli adattatori per LCD usano proprio questo chip.

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.

CaratteristicaValore
Pin8 (P0–P7), quasi bidirezionali
Alimentazione2,5–6 V (funziona a 3,3 V e a 5 V)
InterfacciaI2C, fino a 100 kHz
IndirizzoPCF8574: 0x20–0x27, PCF8574A: 0x38–0x3F
Corrente di uscita a LOWFino a 25 mA per pin (assorbita)
Corrente di uscita a HIGHCirca 100 µA (pull-up debole)
InterruptPin INT, open-drain, attivo a LOW
PackageDIP-16 (PCF8574P) e SO-16 (PCF8574T)

Pinout del PCF8574 e collegamenti

PCF8574 / moduloArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
INT (facoltativo)D2GPIO 4GP6
P0–P3LED: anodo a VCC tramite resistenza, catodo al pinUgualeUguale
P4–P7Pulsanti: un piedino al pin, l'altro a GNDUgualeUguale

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.

Se colleghi il LED al contrario, con l'anodo sul pin del PCF8574 e il catodo a GND, non si accende o resta debolissimo, perché un pin a HIGH fornisce solo circa 100 µA. Con ESP32 e Pico alimenta il modulo a 3,3 V: a 5 V le sue resistenze di pull-up portano SDA e SCL a 5 V, e questo può danneggiare i pin delle schede a 3,3 V. Se accendi molti LED contemporaneamente, tieni la corrente totale sotto gli 80 mA.

Scegliere l'indirizzo: A0, A1, A2 e PCF8574A

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

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

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}

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

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 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 pin INT è un'uscita open-drain e non può andare a HIGH da solo: serve INPUT_PULLUP su Arduino oppure un pull-up esterno da 10 kΩ. Puoi collegare i pin INT di più PCF8574 alla stessa linea di interrupt; quando scatta, leggili uno dopo l'altro e trovi quello cambiato. Sull'ESP32 la routine di interrupt deve avere l'attributo IRAM_ATTR; il blocco #ifndef del codice rende innocua questa parola sull'Uno.

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 PCF8574Collegamento LCD
P0RS (comando o dato)
P1RW (lettura o scrittura)
P2E (enable)
P3Retroilluminazione (tramite transistor)
P4–P7D4–D7 (bus dati a 4 bit)
LCD 2x16 con modulo I2C
LCD 2x16 con modulo I2C: il PCF8574 sul retro riduce l'interfaccia parallela a 16 pin dell'LCD a soli 4 fili (GND, VCC, SDA, SCL).

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.

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?

CaratteristicaPCF8574MCP2301774HC595
Pin aggiuntivi8168 uscite (collegabili in cascata)
InterfacciaI2C, 2 filiI2C, 2 fili (versione SPI: MCP23S17)Seriale a 3 fili (tipo SPI)
Direzione dei pinQuasi bidirezionaleOgni pin impostabile come ingresso o uscitaSolo uscita
Corrente di uscitaAssorbe 25 mA a LOW, debolissima a HIGH25 mA per pin, sia in uscita sia in ingressoConsigliati pochi mA per pin
Pull-up internoDebole sorgente di corrente (fissa)100 kΩ, attivabile via softwareNessuno
Interrupt1 INT2 INT (INTA, INTB)Nessuno
Velocità I2C100 kHzFino a 1,7 MHz-
Ideale perPulsanti, LED e I/O sempliciTanti 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

SintomoCausa probabileSoluzione
Non compare nella scansione I2CSDA e SCL invertiti o massa non in comuneControlla i collegamenti; sull'Uno SDA = A4, SCL = A5
Indirizzo diverso da quello attesoIl chip è un PCF8574A o A0–A2 sono impostati diversamenteControlla l'intervallo 0x38–0x3F e i jumper
Il LED non si accende o è debolissimoSi cerca di accendere il LED con HIGHAnodo a VCC tramite resistenza, catodo al pin; scrivi 0
Il pulsante legge sempre 0 o sempre 1In precedenza è stato scritto 0 sul pin di ingressoInvia un 1 agli ingressi a ogni scrittura (0xF0 | ...)
L'interrupt arriva una volta e poi mai piùPorta non letta, INT resta a LOWLeggi la porta con read8() dopo ogni interrupt
La comunicazione si blocca con molti moduliI pull-up in parallelo danno una resistenza totale troppo bassaTogli 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).

Vedi tutti i progetti
LED in sequenza
AR-5Intermedio

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…

4.6(87)
218
Effetto Supercar con LED
AR-6Intermedio

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.

4.8(107)
214
Accendere un LED con un pulsante (Push)
AR-9Principiante

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.

4.8(114)
253
Accendere e spegnere un LED con un pulsante
AR-10Principiante

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.

4.7(103)
177
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Schermo LCD I2C per ESP32 (16x2)
ES-17Intermedio
Premium

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

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

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.

5.0(31)
43
Funzionamento del tastierino 4x4
AR-63Principiante
Premium

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.

4.5(27)
35