Componentes · 8 min de leitura

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

Módulo I2C com um chip PCF8574
Módulo I2C: o PCF8574 nele conecta 8 pinos ao barramento I2C de dois fios; os adaptadores de LCD usam exatamente o mesmo chip.

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ísticaValor
Pinos8 (P0–P7), quase bidirecionais
Alimentação2,5–6 V (funciona em 3,3 V e 5 V)
InterfaceI2C, até 100 kHz
EndereçoPCF8574: 0x20–0x27, PCF8574A: 0x38–0x3F
Corrente de saída em LOWAté 25 mA por pino (drenando)
Corrente de saída em HIGHCerca de 100 µA (pull-up fraco)
InterrupçãoPino INT, dreno aberto, ativo em LOW
EncapsulamentoDIP-16 (PCF8574P) e SO-16 (PCF8574T)

Pinagem e ligações do PCF8574

PCF8574 / móduloArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
INT (opcional)D2GPIO 4GP6
P0–P3LEDs: ânodo no VCC passando por um resistor, cátodo no pinoIgualIgual
P4–P7Botões: uma perna no pino, a outra no GNDIgualIgual

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.

Se você ligar um LED ao contrário, com o ânodo no pino do PCF8574 e o cátodo no GND, ele não acende ou brilha bem fraquinho, porque um pino em HIGH só fornece cerca de 100 µA. Com um ESP32 ou um Pico, alimente o módulo em 3,3 V: em 5 V, os resistores de pull-up dele puxam SDA e SCL para 5 V, o que pode danificar os pinos das placas de 3,3 V. Quando muitos LEDs estiverem acesos ao mesmo tempo, mantenha a corrente total abaixo de 80 mA.

Como definir o endereço: A0, A1, A2 e o PCF8574A

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

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

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}

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

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}

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 pino INT é uma saída de dreno aberto e não consegue ir para HIGH sozinho, então é obrigatório usar INPUT_PULLUP no Arduino ou um pull-up externo de 10 kΩ. Você pode ligar os pinos INT de vários PCF8574 à mesma linha de interrupção; quando ela disparar, leia um por um para descobrir qual mudou. No ESP32, a rotina de interrupção precisa ser marcada com IRAM_ATTR; o bloco #ifndef do código transforma essa palavra em nada no Uno.

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 PCF8574Ligação no LCD
P0RS (comando ou dado)
P1RW (leitura ou escrita)
P2E (habilitação)
P3Luz de fundo (por um transistor)
P4–P7D4–D7 (barramento de dados de 4 bits)
LCD 2x16 com módulo I2C
LCD 2x16 com módulo I2C: o PCF8574 na parte de trás reduz a interface paralela de 16 pinos do LCD a 4 fios (GND, VCC, SDA, SCL).

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.

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

CaracterísticaPCF8574MCP2301774HC595
Pinos extras8168 saídas (encadeável)
InterfaceI2C, 2 fiosI2C, 2 fios (versão SPI: MCP23S17)Serial de 3 fios (parecida com SPI)
Direção dos pinosQuase bidirecionalCada pino configurado como entrada ou saídaSomente saída
Corrente de saídaDrena 25 mA em LOW, muito fraca em HIGH25 mA por pino, fornecendo e drenandoRecomendam-se alguns mA por pino
Pull-up internoFonte de corrente fraca (fixa)100 kΩ, ativado por softwareNenhum
Interrupção1 INT2 INT (INTA, INTB)Nenhuma
Velocidade do I2C100 kHzAté 1,7 MHz-
Ideal paraBotões, LEDs e I/O simplesMuitos pinos, corrente de saída de verdade e velocidadeMuitos 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

SintomaCausa provávelSolução
Não aparece na varredura I2CSDA e SCL trocados ou falta de GND comumConfira as ligações; no Uno, SDA = A4 e SCL = A5
O endereço é diferente do esperadoO chip é um PCF8574A ou A0–A2 estão ajustados de outro jeitoConfira a faixa 0x38–0x3F e os jumpers
O LED não acende ou fica muito fracoTentativa 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 1Um 0 foi escrito antes no pino de entradaEnvie 1 para as entradas em toda escrita (0xF0 | ...)
A interrupção dispara uma vez e nunca maisA porta não foi lida, então o INT fica em LOWLeia a porta com read8() depois de cada interrupção
A comunicação falha com muitos módulosOs resistores de pull-up em paralelo somam um valor baixo demaisRemova 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).

Ver todos os projetos
Sequencial de LEDs
AR-5Intermediário

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…

4.6(87)
218
Efeito Knight Rider com LEDs
AR-6Intermediário

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.

4.8(107)
214
Controle de LED com botão (momentâneo)
AR-9Iniciante

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.

4.8(114)
253
Ligar e desligar um LED com botão
AR-10Iniciante

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.

4.7(103)
177
Uso do display LCD com I2C
AR-32Iniciante
Premium

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…

4.8(53)
70
Display LCD I2C com ESP32 (16x2)
ES-17Intermediário
Premium

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

4.9(23)
40
Calculadora I2C com Arduino
AR-94Intermediário
Premium

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.

5.0(31)
43
Uso do teclado matricial 4x4
AR-63Iniciante
Premium

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.

4.5(27)
35