Composants · 9 min de lecture

PCF8574 Arduino : extension I2C de 8 broches, adresses et code

Guide PCF8574 Arduino : 8 entrées-sorties en plus via I2C, table d'adresses A0-A2, câblage des LED et boutons, interruption INT, module LCD et MCP23017.

Le PCF8574 est un expandeur I2C bon marché qui offre à ton Arduino 8 entrées-sorties supplémentaires avec seulement deux fils (SDA et SCL). Associer le PCF8574 et l'Arduino devient utile dès que les broches manquent : quand un écran LCD, un capteur et quelques relais en occupent déjà la plupart, le PCF8574 se branche sur le même bus I2C et te donne 8 broches de plus pour des boutons et des LED. Grâce aux broches d'adresse A0, A1 et A2, tu peux mettre jusqu'à 8 modules sur le même bus et atteindre 64 broches supplémentaires.

Dans ce guide, tu découvriras les broches quasi bidirectionnelles du PCF8574, pourquoi les LED s'allument quand tu écris LOW et comment lire des boutons. Tu auras la table d'adresses (PCF8574 et PCF8574A), tu liras les boutons par interruption grâce à la broche INT, tu verras que le module I2C de ton écran LCD est en réalité un PCF8574 et tu le compareras au MCP23017. Le code est prêt pour l'Arduino Uno, l'ESP32 et la Raspberry Pi Pico (MicroPython).

Module I2C avec puce PCF8574
Module I2C : le PCF8574 qu'il porte relie 8 broches au bus I2C à deux fils ; les adaptateurs d'écran LCD utilisent exactement la même puce.

Qu'est-ce que le PCF8574 et comment fonctionne-t-il ?

Le PCF8574 contient un registre de sortie (latch) de 8 bits. L'Arduino envoie un seul octet en I2C et chaque bit fixe l'état d'une broche : P0 est le bit de poids faible, P7 le bit de poids fort. Les broches ne fonctionnent pas comme des sorties push-pull classiques. À l'état LOW, la broche est reliée à GND par un interrupteur puissant et peut absorber jusqu'à 25 mA. À l'état HIGH, elle n'est maintenue en haut que par une faible source de courant d'environ 100 µA. On parle de structure quasi bidirectionnelle, avec deux conséquences importantes : il faut câbler les LED pour que la broche absorbe le courant (anode vers VCC), et il faut écrire un 1 sur une broche avant de l'utiliser comme entrée. Quand un bouton tire cette broche HIGH vers GND, tu lis un 0. À la mise sous tension, toutes les broches sont à HIGH.

CaractéristiqueValeur
Broches8 (P0–P7), quasi bidirectionnelles
Alimentation2,5–6 V (fonctionne en 3,3 V et en 5 V)
InterfaceI2C, jusqu'à 100 kHz
AdressePCF8574 : 0x20–0x27, PCF8574A : 0x38–0x3F
Courant de sortie à LOWJusqu'à 25 mA par broche (absorbé)
Courant de sortie à HIGHEnviron 100 µA (pull-up faible)
InterruptionBroche INT, drain ouvert, active à LOW
BoîtierDIP-16 (PCF8574P) et SO-16 (PCF8574T)

Brochage du PCF8574 et câblage

PCF8574 / moduleArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
INT (facultatif)D2GPIO 4GP6
P0–P3LED : anode vers VCC via une résistance, cathode vers la brocheIdentiqueIdentique
P4–P7Boutons : une patte vers la broche, l'autre vers GNDIdentiqueIdentique

Dans les exemples, quatre LED sont sur P0–P3 et quatre boutons sur P4–P7. L'anode de chaque LED va à VCC à travers une résistance de 330 Ω et la cathode à la broche du PCF8574 ; quand tu écris 0 sur la broche, le courant traverse la LED vers la broche et la LED s'allume. En 5 V, 330 Ω donnent (5 - 2) / 330 ≈ 9 mA pour une LED rouge ; choisis la valeur adaptée à ta LED avec le calculateur de résistance pour LED. Les boutons n'ont pas besoin de résistance, car la faible source de courant de la puce joue le rôle de pull-up. Avec de longs fils sur la plaque d'essai, une résistance de pull-up externe de 10 kΩ reste utile contre les parasites ; les bases sont dans résistances pull-up et pull-down. Avec la puce seule en boîtier DIP-16, les broches 1 à 3 sont A0–A2, 4 à 7 et 9 à 12 sont P0–P7, la 8 est GND, la 13 INT, la 14 SCL, la 15 SDA et la 16 VCC.

Si tu branches la LED à l'envers, anode sur la broche du PCF8574 et cathode à GND, elle ne s'allume pas ou très faiblement, car une broche à HIGH ne fournit qu'environ 100 µA. Avec un ESP32 ou une Pico, alimente le module en 3,3 V : en 5 V, ses résistances de pull-up tirent SDA et SCL à 5 V, ce qui peut endommager les broches des cartes 3,3 V. Si beaucoup de LED sont allumées en même temps, garde le courant total sous 80 mA.

Choisir l'adresse : A0, A1, A2 et PCF8574A

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

L'adresse dépend du raccordement de A0–A2 à GND ou à VCC ; dans le tableau, 1 signifie VCC et 0 signifie GND. Les modules d'extension violets les plus courants ont des cavaliers ou de petits interrupteurs DIP pour ces trois broches, généralement réglés sur 0x20 d'origine. Huit modules du même type donnent 64 broches, et en mélangeant PCF8574 et PCF8574A tu arrives à 16 modules et 128 broches. Si tu n'es pas sûr de l'adresse, lance le scanner I2C de qu'est-ce que l'I2C ou du guide écran LCD I2C ; si la référence de la puce contient un "A", l'adresse se situe entre 0x38 et 0x3F.

Premier programme sans bibliothèque : lire des boutons et piloter des 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}

Pas besoin de bibliothèque pour dialoguer avec le PCF8574 : un octet envoyé avec Wire.write() règle les 8 broches d'un coup, et un octet lu avec Wire.requestFrom() donne l'état actuel des 8 broches. En décalant l'octet lu de 4 bits vers la droite, les boutons de P4–P7 arrivent dans les quatre bits de poids faible ; un bouton appuyé se lit 0. À l'écriture, 0xF0 | buttons fait deux choses : il garde les quatre bits de poids fort à 1 pour que P4–P7 restent des entrées, et il recopie l'état des boutons dans les quatre bits de poids faible. Comme le bit d'un bouton appuyé vaut 0, la broche de la LED correspondante passe à LOW et la LED s'allume. Si les opérations sur les bits sont nouvelles pour toi, commence par systèmes de numération et opérations sur les bits.

La broche INT : lire les boutons par interruption au lieu de les scruter

Le code précédent occupe le bus I2C des dizaines de fois par seconde. La broche INT du PCF8574 passe à LOW dès qu'une entrée a changé depuis la dernière lecture et y reste jusqu'à ce que la puce soit lue ou écrite. Relie-la à une broche d'interruption de l'Arduino et tu ne lis plus que lorsqu'un changement se produit ; le reste du temps, le bus et le processeur sont libres. L'exemple suivant utilise la bibliothèque PCF8574 de Rob Tillaart, à installer depuis le gestionnaire de bibliothèques. À partir de la version 0.4, tu dois appeler toi-même Wire.begin() avant 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 d'interruption se contente de lever un drapeau, car un échange I2C à l'intérieur d'une interruption pose problème sur l'Uno comme sur l'ESP32. Quand loop() voit le drapeau, elle attend 20 ms que les rebonds des contacts cessent, puis lit tout le port avec read8(), ce qui libère aussi INT. L'expression lastState & ~state trouve les bits passés de 1 à 0, c'est-à-dire les nouveaux appuis. Chaque nouvel appui inverse la LED correspondante avec toggle() ; comme toggle() part de l'octet de sortie mémorisé par la bibliothèque, les broches d'entrée continuent de recevoir un 1. Pour le principe général des interruptions, lis les interruptions sur Arduino.

La broche INT est une sortie à drain ouvert et ne peut pas passer à HIGH toute seule : INPUT_PULLUP côté Arduino ou une résistance de pull-up externe de 10 kΩ est indispensable. Tu peux relier les broches INT de plusieurs PCF8574 à la même ligne d'interruption ; quand elle se déclenche, lis-les l'un après l'autre pour trouver celui qui a changé. Sur l'ESP32, la routine d'interruption doit porter l'attribut IRAM_ATTR ; le bloc #ifndef du code neutralise ce mot sur l'Uno.

Le module I2C de l'écran LCD est en réalité un PCF8574

Regarde de près la petite carte I2C bleue ou noire soudée au dos d'un écran LCD 16x2 : tu y trouveras une puce marquée PCF8574T ou PCF8574AT. La bibliothèque LiquidCrystal_I2C pilote les 8 broches de cette puce comme si elles étaient reliées directement à l'interface parallèle du LCD et envoie les données en mode 4 bits. C'est aussi pour cela que l'adresse du LCD est presque toujours 0x27 ou 0x3F : sur l'adaptateur, A0–A2 sont tirées à VCC par des résistances, donc les trois bits valent 1, ce qui donne 0x27 sur un PCF8574T et 0x3F sur un PCF8574AT. En fermant les ponts de soudure A0–A2 au dos, tu changes l'adresse et peux brancher plusieurs LCD sur le même bus.

Broche du PCF8574Connexion du LCD
P0RS (commande ou donnée)
P1RW (lecture ou écriture)
P2E (enable)
P3Rétroéclairage (via un transistor)
P4–P7D4–D7 (bus de données 4 bits)
Écran LCD 2x16 avec module I2C
Écran LCD 2x16 avec module I2C : le PCF8574 au dos réduit l'interface parallèle à 16 broches du LCD à seulement 4 fils (GND, VCC, SDA, SCL).

Le PCF8574 avec l'ESP32 et la Raspberry Pi Pico

Sur l'ESP32, les deux exemples fonctionnent tels quels ; la seule différence est que Wire.begin(21, 22) indique explicitement les broches I2C, ce que l'exemple avec interruption fait déjà dans son bloc #if defined(ESP32). Sur la Raspberry Pi Pico, la classe machine.I2C de MicroPython fait le même travail en quelques lignes : writeto() écrit un octet et readfrom() en lit un. Le code ci-dessous scanne le bus I2C au démarrage, affiche un chenillard sur P0–P3 tant qu'aucun bouton n'est appuyé et allume la LED correspondante quand tu appuies sur un bouton. Reste à 100 kHz ; la fiche technique du PCF8574 ne garantit pas de vitesse plus élevée.

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 ou 74HC595 ?

CaractéristiquePCF8574MCP2301774HC595
Broches en plus8168 sorties (chaînables)
InterfaceI2C, 2 filsI2C, 2 fils (version SPI : MCP23S17)Série 3 fils (type SPI)
Sens des brochesQuasi bidirectionnelChaque broche en entrée ou en sortie au choixSortie uniquement
Courant de sortieAbsorbe 25 mA à LOW, très faible à HIGH25 mA par broche, fourni et absorbéQuelques mA par broche conseillés
Pull-up interneFaible source de courant (fixe)100 kΩ, activable par logicielAucun
Interruption1 INT2 INT (INTA, INTB)Aucune
Vitesse I2C100 kHzJusqu'à 1,7 MHz-
Idéal pourBoutons, LED et E/S simplesBeaucoup de broches, vrai courant de sortie et vitesseBeaucoup de LED et d'afficheurs 7 segments

Si tu veux seulement lire quelques boutons et allumer quelques LED, le PCF8574 est l'option la moins chère et la plus simple. Pour piloter des LED à l'état HIGH, choisir le sens de chaque broche, réunir 16 broches dans une seule puce ou travailler à 400 kHz et plus, passe au MCP23017. Si tu n'as besoin que de sorties pour de nombreuses LED ou des afficheurs 7 segments, le registre à décalage 74HC595 est plus rapide et encore moins cher.

Idées de projets avec le PCF8574

  • Carte relais : pilote un module relais à huit voies depuis un seul bus I2C ; les entrées de relais actives à LOW collent parfaitement à la logique du PCF8574.
  • Clavier matriciel : branche les 8 lignes d'un clavier 4x4 sur le PCF8574 et garde les broches de l'Arduino libres.
  • Panneau de boutons : lis 8 boutons pour un jeu ou une télécommande grâce à l'interruption INT.
  • Voyants d'état : affiche l'état d'alarme de plusieurs capteurs sur une barre de 8 LED.
  • Plusieurs écrans : branche deux LCD sur le même Arduino avec des adaptateurs à adresses différentes.
  • Effet K2000 : fais défiler une lumière via le PCF8574 dans un projet qui n'a plus de broches libres.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Absent du scan I2CSDA et SCL inversés ou pas de masse communeVérifier le câblage ; sur l'Uno SDA = A4, SCL = A5
Adresse différente de celle attendueLa puce est un PCF8574A ou A0–A2 sont réglées autrementVérifier la plage 0x38–0x3F et les cavaliers
La LED ne s'allume pas ou très faiblementOn essaie d'allumer la LED avec HIGHAnode vers VCC via une résistance, cathode vers la broche ; écrire 0
Le bouton lit toujours 0 ou toujours 1Un 0 a été écrit auparavant sur la broche d'entréeEnvoyer un 1 aux entrées à chaque écriture (0xF0 | ...)
L'interruption arrive une fois puis plus jamaisPort non lu, INT reste à LOWLire le port avec read8() après chaque interruption
La communication échoue avec beaucoup de modulesLes pull-up en parallèle donnent une résistance totale trop faibleRetirer les résistances SDA/SCL de certains modules, raccourcir les fils

Le PCF8574 règle le manque de broches avec deux fils et s'apprend vite ; une fois sa logique quasi bidirectionnelle comprise, tu pilotes LED, boutons, relais et LCD sur le même bus sans difficulté. Dans l'application BlueGrays, tu trouveras des projets d'écran LCD I2C, de calculatrice, de clavier, de chenillard et de boutons avec schémas et code pas à pas, prêts à être étendus avec un PCF8574 quand les broches viennent à manquer.

Questions fréquentes

Comment trouver l'adresse I2C du PCF8574 ?

Selon A0–A2, le PCF8574 se trouve entre 0x20 et 0x27 et le PCF8574A entre 0x38 et 0x3F. Le plus sûr est de lancer un scanner I2C et de lire l'adresse dans le moniteur série. Sur les adaptateurs LCD, elle vaut le plus souvent 0x27 ou 0x3F.

Combien de PCF8574 peut-on brancher sur un Arduino ?

Chaque PCF8574 ajoute 8 broches et A0–A2 offrent 8 adresses, soit 64 broches avec des modules du même type. Comme le PCF8574 et le PCF8574A ont des plages d'adresses différentes, en les mélangeant tu montes à 16 modules et 128 broches. Avec beaucoup de modules, surveille la valeur totale des résistances de pull-up I2C.

Pourquoi la LED du PCF8574 s'allume-t-elle à LOW ?

Les broches du PCF8574 peuvent absorber jusqu'à 25 mA à LOW, mais ne fournissent qu'environ 100 µA à HIGH. L'anode de la LED va donc à VCC via une résistance et la cathode à la broche ; écrire 0 l'allume. Branchée à l'envers, la LED reste éteinte ou très faible.

Comment lire un bouton avec le PCF8574 ?

Écris d'abord un 1 sur la broche pour qu'elle reste à HIGH grâce au pull-up faible. Quand le bouton tire la broche vers GND, tu lis un 0. Si tu écris un 0 sur une entrée, elle reste à LOW en permanence et le bouton ne peut plus être lu.

Quelle différence entre le PCF8574 et le MCP23017 ?

Le PCF8574 est une puce simple à 8 broches quasi bidirectionnelles, limitée à 100 kHz. Le MCP23017 propose 16 broches, un sens réglable par broche, des pull-up activables, deux sorties d'interruption et jusqu'à 1,7 MHz en I2C. Pour des boutons et des LED, le PCF8574 suffit ; pour de gros projets, le MCP23017 est préférable.

Le PCF8574 fonctionne-t-il avec un ESP32 en 3,3 V ?

Oui, le PCF8574 fonctionne de 2,5 à 6 V et se branche donc directement sur l'ESP32 et la Raspberry Pi Pico. Alimente-le en 3,3 V : en 5 V, les pull-up tirent SDA et SCL à 5 V, ce qui peut abîmer les cartes 3,3 V. Sur l'ESP32, indique les broches I2C avec Wire.begin(21, 22).

Voir tous les projets
Chenillard à LED
AR-5Intermédiaire

Chenillard à LED

Des lumières qui s'allument l'une après l'autre, comme si elles couraient. L'Arduino allume six LED une par une ; chacune brille un court instant puis s'éteint, et la lumière parcourt la rangée du…

4.6(87)
218
Chenillard K2000 à LED
AR-6Intermédiaire

Chenillard K2000 à LED

Le fameux balayage lumineux : un point de lumière glisse d'un bout à l'autre de six LED, puis revient.

4.8(107)
214
Allumer une LED avec un bouton-poussoir (Push)
AR-9Débutant

Allumer une LED avec un bouton-poussoir (Push)

Comme une sonnette : la lumière reste allumée tant que tu appuies et s'éteint quand tu relâches.

4.8(114)
253
Allumer et éteindre une LED avec un bouton
AR-10Débutant

Allumer et éteindre une LED avec un bouton

Un appui et la lumière s'allume, un deuxième et elle s'éteint, exactement comme l'interrupteur de ta chambre.

4.7(103)
177
Utilisation de l'écran LCD avec I2C
AR-32Débutant
Premium

Utilisation de l'écran LCD avec I2C

Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

4.8(53)
70
Écran LCD I2C ESP32 (16x2)
ES-17Intermédiaire
Premium

Écran LCD I2C ESP32 (16x2)

Dans ce projet, on relie un écran LCD 16x2 caractères à l'ESP32 en I2C pour afficher du texte. Grâce à l'I2C, 2 broches de données (SDA et SCL) suffisent, au lieu des 6+ broches d'un branchement parallèle classique. Le code affiche un message fixe sur la première ligne et un compteur qui augmente chaque seconde sur la deuxième. Au démarrage, un scanner I2C écrit l'adresse de l'écran dans le Serial Monitor (souvent 0x27 ou 0x3F).

4.9(23)
40
Calculatrice Arduino I2C
AR-94Intermédiaire
Premium

Calculatrice Arduino I2C

Il s'agit d'un projet de calculatrice basé sur Arduino qui effectue des opérations d'addition, de soustraction, de multiplication et de division à l'aide d'un clavier à membrane 4x4 et d'un écran LCD I2C 16x2. Grâce à l'I2C, la connexion de l'écran n'est assurée que par deux câbles, ce qui réduit l'encombrement des câbles et permet d'utiliser plus de broches. L'entrée de nombres décimaux et la prise en charge des nombres négatifs sont également disponibles.

5.0(31)
43
Fonctionnement du clavier 4x4
AR-63Débutant
Premium

Fonctionnement du clavier 4x4

Sur le clavier 4x4, qui ressemble beaucoup aux touches d'un téléphone, l'Arduino sait tout de suite quelle touche tu as pressée et l'écrit sur l'écran de ton ordinateur.

4.5(27)
35