PCF8574 com Arduino: expansor de I/O I2C para 8 pinos extras, com código
Guia do PCF8574 com Arduino: 8 pinos de I/O extras via I2C, tabela de endereços A0-A2, ligação de LEDs e botões, interrupção INT, o adaptador I2C do LCD e comparação com o MCP23017.
O PCF8574 é um expansor de I/O I2C barato que dá ao seu Arduino 8 pinos extras de entrada/saída com apenas dois fios (SDA e SCL). Usar um PCF8574 com Arduino compensa sempre que os pinos acabam: quando um LCD, um sensor e alguns relés já ocuparam a maioria deles, o PCF8574 simplesmente entra no mesmo barramento I2C e entrega mais 8 pinos para botões e LEDs. Com os pinos de endereço A0, A1 e A2, você pode colocar até 8 módulos em um único barramento e chegar a 64 pinos extras.
Neste guia você vai conhecer os pinos quase bidirecionais do PCF8574, entender por que isso faz os LEDs acenderem quando você escreve LOW e aprender a ler botões. Você vai ter a tabela de endereços (PCF8574 e PCF8574A), ler botões pelo pino INT com uma interrupção, descobrir que o adaptador I2C do LCD que você usa todo dia é, na verdade, um PCF8574 e ver como ele se compara ao MCP23017. O código está pronto para Arduino Uno, ESP32 e Raspberry Pi Pico (MicroPython).

O que é o PCF8574 e como ele funciona?
Dentro do PCF8574 há um latch de saída de 8 bits. O Arduino envia um único byte via I2C e cada bit define o estado de um pino: P0 é o bit menos significativo e P7, o mais significativo. Os pinos não se comportam como as clássicas saídas push-pull. Em LOW, o pino é ligado ao GND por uma chave forte e consegue drenar até 25 mA. Em HIGH, ele é mantido em nível alto apenas por uma fonte de corrente fraca, de cerca de 100 µA. Isso se chama projeto quase bidirecional e traz duas consequências importantes: ligue os LEDs de modo que o pino drene a corrente (ânodo no VCC) e escreva 1 em um pino antes de usá-lo como entrada. Quando um botão puxa esse pino em HIGH para o GND, você lê 0. Ao ligar a alimentação, todos os pinos ficam em HIGH.
| Característica | Valor |
|---|---|
| Pinos | 8 (P0–P7), quase bidirecionais |
| Alimentação | 2,5–6 V (funciona em 3,3 V e 5 V) |
| Interface | I2C, até 100 kHz |
| Endereço | PCF8574: 0x20–0x27, PCF8574A: 0x38–0x3F |
| Corrente de saída em LOW | Até 25 mA por pino (drenando) |
| Corrente de saída em HIGH | Cerca de 100 µA (pull-up fraco) |
| Interrupção | Pino INT, dreno aberto, ativo em LOW |
| Encapsulamento | DIP-16 (PCF8574P) e SO-16 (PCF8574T) |
Pinagem e ligações do PCF8574
| 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 | LEDs: ânodo no VCC passando por um resistor, cátodo no pino | Igual | Igual |
| P4–P7 | Botões: uma perna no pino, a outra no GND | Igual | Igual |
Nos exemplos, quatro LEDs ficam em P0–P3 e quatro botões em P4–P7. O ânodo de cada LED vai ao VCC passando por um resistor de 330 Ω, e o cátodo vai ao pino do PCF8574; quando você escreve 0 no pino, a corrente passa pelo LED, entra no pino e o LED acende. Em 5 V, 330 Ω significam (5 - 2) / 330 ≈ 9 mA para um LED vermelho; escolha o valor certo para o seu LED com a calculadora de resistor para LED. Os botões não precisam de resistor próprio, porque a fonte de corrente fraca do chip funciona como pull-up. Com fios longos na protoboard, um pull-up externo de 10 kΩ ainda ajuda contra ruído; o básico está em resistores de pull-up e pull-down. Se você usar o chip avulso no encapsulamento DIP-16, os pinos 1–3 são A0–A2, 4–7 e 9–12 são P0–P7, 8 é GND, 13 INT, 14 SCL, 15 SDA e 16 VCC.
Como definir o endereço: A0, A1, A2 e o 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 |
O endereço depende de A0–A2 estarem ligados ao GND ou ao VCC; na tabela, 1 significa VCC e 0 significa GND. As placas expansoras roxas mais comuns têm jumpers ou pequenas chaves DIP para esses três pinos, normalmente ajustados em 0x20 de fábrica. Oito módulos do mesmo tipo dão 64 pinos, e misturar o PCF8574 com o PCF8574A leva você a 16 módulos e 128 pinos. Se você não tem certeza do endereço, rode o scanner I2C do guia o que é I2C ou do guia do display LCD I2C; se a marcação do chip tiver um “A”, a faixa de endereços é 0x38–0x3F.
Primeiro sketch sem biblioteca: lendo botões e acionando LEDs
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}Você nem precisa de biblioteca para conversar com um PCF8574: um byte enviado com Wire.write() define os 8 pinos de uma vez, e um byte lido com Wire.requestFrom() devolve o estado atual dos 8 pinos. Deslocar o byte 4 bits para a direita leva os botões de P4–P7 para os quatro bits inferiores, e um botão pressionado é lido como 0. Na escrita, 0xF0 | buttons faz dois trabalhos: mantém os quatro bits superiores em 1, para que P4–P7 continuem como entradas, e copia os estados dos botões para os quatro bits inferiores. Como o bit de um botão pressionado é 0, o pino do LED correspondente vai para LOW e o LED acende. Se as operações com bits são novidade para você, sistemas numéricos e operações bit a bit é um bom ponto de partida.
O pino INT: lendo botões com interrupção em vez de polling
O sketch acima mantém o barramento I2C ocupado dezenas de vezes por segundo. O pino INT do PCF8574 vai para LOW assim que qualquer entrada muda desde a última leitura e fica assim até que o chip seja lido ou escrito. Ligue-o a um pino de interrupção do Arduino e você só lê quando algo muda; no resto do tempo, o barramento e o processador ficam livres para outras tarefas. O próximo exemplo usa a biblioteca PCF8574 de Rob Tillaart, que você instala pelo Gerenciador de Bibliotecas. A partir da versão 0.4 da biblioteca, você mesmo precisa chamar 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}A rotina de interrupção apenas levanta uma flag, porque tráfego I2C dentro de uma interrupção causa problemas tanto no Uno quanto no ESP32. Quando o loop() vê a flag, ele espera 20 ms para o repique dos contatos do botão acabar e então lê a porta inteira com read8(), o que também libera o INT. A expressão lastState & ~state encontra os bits que passaram de 1 para 0, ou seja, os novos toques nos botões. Cada novo toque inverte o LED correspondente com toggle(); como o toggle() trabalha a partir do byte de saída que a biblioteca guarda, os pinos de entrada continuam recebendo 1. Para a ideia geral por trás das interrupções, veja interrupções no Arduino.
O adaptador I2C do LCD é, na verdade, um PCF8574
Olhe de perto a plaquinha I2C azul ou preta soldada atrás de um LCD 16x2 e você vai encontrar um chip marcado como PCF8574T ou PCF8574AT. A biblioteca LiquidCrystal_I2C aciona os 8 pinos desse chip como se eles estivessem ligados direto à interface paralela do LCD e envia os dados no modo de 4 bits. É também por isso que o endereço do LCD costuma ser 0x27 ou 0x3F: no adaptador, A0–A2 são puxados para o VCC, então os três bits valem 1, o que dá 0x27 em um PCF8574T e 0x3F em um PCF8574AT. Faça uma ponte de solda nas ilhas A0–A2, na parte de trás, para mudar o endereço e usar vários LCDs no mesmo barramento.
| Pino do PCF8574 | Ligação no LCD |
|---|---|
| P0 | RS (comando ou dado) |
| P1 | RW (leitura ou escrita) |
| P2 | E (habilitação) |
| P3 | Luz de fundo (por um transistor) |
| P4–P7 | D4–D7 (barramento de dados de 4 bits) |

Como usar o PCF8574 com ESP32 e Raspberry Pi Pico
No ESP32, os dois exemplos rodam sem alterações; a única diferença é que Wire.begin(21, 22) indica os pinos I2C de forma explícita, e o exemplo com interrupção já faz isso dentro do bloco #if defined(ESP32). No Raspberry Pi Pico, a classe machine.I2C do MicroPython faz o mesmo trabalho em poucas linhas: writeto() escreve um byte e readfrom() lê um. O código abaixo faz uma varredura do barramento I2C na inicialização, mostra um LED sequencial em P0–P3 enquanto nenhum botão está pressionado e acende o LED correspondente quando você aperta um botão. Fique em 100 kHz; o datasheet do PCF8574 não garante velocidades maiores.
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
| Característica | PCF8574 | MCP23017 | 74HC595 |
|---|---|---|---|
| Pinos extras | 8 | 16 | 8 saídas (encadeável) |
| Interface | I2C, 2 fios | I2C, 2 fios (versão SPI: MCP23S17) | Serial de 3 fios (parecida com SPI) |
| Direção dos pinos | Quase bidirecional | Cada pino configurado como entrada ou saída | Somente saída |
| Corrente de saída | Drena 25 mA em LOW, muito fraca em HIGH | 25 mA por pino, fornecendo e drenando | Recomendam-se alguns mA por pino |
| Pull-up interno | Fonte de corrente fraca (fixa) | 100 kΩ, ativado por software | Nenhum |
| Interrupção | 1 INT | 2 INT (INTA, INTB) | Nenhuma |
| Velocidade do I2C | 100 kHz | Até 1,7 MHz | - |
| Ideal para | Botões, LEDs e I/O simples | Muitos pinos, corrente de saída de verdade e velocidade | Muitos LEDs e displays de 7 segmentos |
Se você só precisa ler alguns botões e acender alguns LEDs, o PCF8574 é a opção mais barata e mais simples. Se quer acionar LEDs com HIGH, definir a direção de cada pino, ter 16 pinos em um único chip ou trabalhar em 400 kHz ou mais, passe para o MCP23017. Se você só precisa de saídas para muitos LEDs ou displays de 7 segmentos, o registrador de deslocamento 74HC595 é mais rápido e ainda mais barato.
Ideias de projeto com o PCF8574
- Placa de relés: Acione um módulo relé de oito canais a partir de um único barramento I2C; as entradas de relé ativas em LOW combinam perfeitamente com a lógica do PCF8574.
- Teclado: Ligue as 8 linhas de um teclado matricial 4x4 ao PCF8574 e guarde os pinos do próprio Arduino para outros componentes.
- Painel de botões: Leia 8 botões de um jogo ou de um controle remoto pela interrupção INT.
- Painel de status: Mostre o estado de alarme de vários sensores em uma barra de 8 LEDs.
- Vários displays: Use dois LCDs no mesmo Arduino com adaptadores de endereços diferentes.
- Efeito Super Máquina: Faça uma luz de varredura correr pelo PCF8574 em um projeto que não tem mais pinos livres.
Problemas comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| Não aparece na varredura I2C | SDA e SCL trocados ou falta de GND comum | Confira as ligações; no Uno, SDA = A4 e SCL = A5 |
| O endereço é diferente do esperado | O chip é um PCF8574A ou A0–A2 estão ajustados de outro jeito | Confira a faixa 0x38–0x3F e os jumpers |
| O LED não acende ou fica muito fraco | Tentativa de acionar o LED com HIGH | Ânodo no VCC passando por um resistor, cátodo no pino; escreva 0 |
| O botão sempre lê 0 ou sempre 1 | Um 0 foi escrito antes no pino de entrada | Envie 1 para as entradas em toda escrita (0xF0 | ...) |
| A interrupção dispara uma vez e nunca mais | A porta não foi lida, então o INT fica em LOW | Leia a porta com read8() depois de cada interrupção |
| A comunicação falha com muitos módulos | Os resistores de pull-up em paralelo somam um valor baixo demais | Remova os resistores de SDA/SCL de alguns módulos e encurte os fios |
O PCF8574 resolve a falta de pinos com dois fios e é fácil de aprender; quando a lógica quase bidirecional faz sentido, você consegue usar LEDs, botões, relés e LCDs no mesmo barramento. No app BlueGrays você encontra projetos de LCD I2C, calculadora, teclado matricial, LED sequencial e botões, com esquemas do circuito e código passo a passo, prontos para serem ampliados com um PCF8574 quando os pinos acabarem.
Perguntas frequentes
Como descubro o endereço I2C de um PCF8574?
Dependendo de A0–A2, o PCF8574 fica entre 0x20 e 0x27, e o PCF8574A entre 0x38 e 0x3F. O jeito mais seguro é rodar um sketch de scanner I2C e ler o endereço no Monitor Serial. Nos adaptadores de LCD, ele costuma ser 0x27 ou 0x3F.
Quantos módulos PCF8574 posso ligar a um Arduino?
Cada PCF8574 acrescenta 8 pinos e A0–A2 permitem 8 endereços, então módulos de um mesmo tipo dão 64 pinos. Como o PCF8574 e o PCF8574A usam faixas de endereços diferentes, misturá-los leva você a 16 módulos e 128 pinos. Com muitos módulos, fique de olho no valor combinado dos resistores de pull-up do I2C.
Por que o LED no PCF8574 acende quando o pino está em LOW?
Os pinos do PCF8574 conseguem drenar até 25 mA em LOW, mas só fornecem cerca de 100 µA em HIGH. Por isso o ânodo do LED vai ao VCC passando por um resistor e o cátodo vai ao pino, de modo que escrever 0 acende o LED. Ligado ao contrário, o LED fica apagado ou muito fraco.
Como leio um botão com o PCF8574?
Primeiro escreva 1 no pino, para que ele fique em HIGH em repouso pelo pull-up fraco. Quando o botão puxa o pino para o GND, você lê 0. Se, em vez disso, você escrever 0 em uma entrada, ela fica presa em LOW permanentemente e o botão não pode mais ser lido.
PCF8574 ou MCP23017: qual é a diferença?
O PCF8574 é um chip simples, com 8 pinos quase bidirecionais e limite de 100 kHz. O MCP23017 oferece 16 pinos, direção por pino, pull-ups ativáveis, duas saídas de interrupção e velocidades de I2C de até 1,7 MHz. Para tarefas simples com botões e LEDs, o PCF8574 basta; para projetos maiores, o MCP23017 é a melhor escolha.
O PCF8574 funciona com um ESP32 em 3,3 V?
Sim, o PCF8574 funciona de 2,5 a 6 V, então trabalha diretamente com o ESP32 e o Raspberry Pi Pico. Alimente-o em 3,3 V; em 5 V, os pull-ups levam SDA e SCL a 5 V, o que pode danificar placas de 3,3 V. No ESP32, defina os pinos I2C com Wire.begin(21, 22).
Projetos para montar depois desta leitura
Ver todos os projetos
Sequencial de LEDs
Luzes que acendem uma após a outra, como se estivessem correndo. O Arduino acende seis LEDs, um de cada vez; cada um brilha por um instante e apaga, fazendo a luz percorrer a sequência do início ao…

Efeito Knight Rider com LEDs
O clássico efeito Knight Rider: um ponto de luz percorre seis LEDs de uma ponta à outra e depois volta.

Controle de LED com botão (momentâneo)
É como uma campainha: a luz fica acesa enquanto você pressiona o botão e apaga quando você solta.

Ligar e desligar um LED com botão
Pressione o botão uma vez para acender a luz e outra vez para apagar, como o interruptor do seu quarto.

Uso do display LCD com I2C
Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

Display LCD I2C com ESP32 (16x2)
Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).

Calculadora I2C com Arduino
Projeto de calculadora com Arduino que faz operações de adição, subtração, multiplicação e divisão usando um teclado de membrana 4x4 e um display LCD I2C 16x2. Com I2C, a conexão do display usa apenas 2 fios, reduzindo a quantidade de cabos e deixando mais pinos livres. Também permite inserir números decimais e negativos.

Uso do teclado matricial 4x4
No teclado matricial 4x4, parecido com as teclas de um telefone, o Arduino identifica na hora qual tecla você pressionou e a mostra na tela do computador.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

