Componentes · 11 min de leitura

Ligação do LCD 16x2 ao Arduino sem I2C: modo de 4 bits e contraste

Como ligar um LCD 16x2 ao Arduino sem módulo I2C: função dos 16 pinos, modo de 4 bits, contraste, LiquidCrystal, solução para quadrados pretos e uso de um LCD 20x4.

Ao ligar um LCD 16x2 a um Arduino sem módulo I2C, você usa 12 dos 16 pinos do display: seis vão para pinos digitais do Arduino, e os demais cuidam da alimentação, do contraste e da luz de fundo. Parece muita coisa, mas essa ligação ensina como o display realmente funciona, dispensa a busca pelo endereço I2C, é mais rápida que I2C e não deixa seu projeto parado quando você não tem um módulo adaptador I2C. A maioria dos LCDs dos kits para iniciantes de Arduino também vem sem o módulo I2C.

Neste guia, você vai conhecer a função de cada um dos 16 pinos, entender por que usamos apenas 4 linhas de dados (modo de 4 bits), aprender a ligar o potenciômetro de contraste e conhecer os comandos da biblioteca LiquidCrystal. Depois, vai criar caracteres personalizados para um gráfico de barras que se preenche com um potenciômetro, passar para um LCD 20x4 e usar o mesmo display com um ESP32 e um Raspberry Pi Pico. Nas seções finais, você encontrará soluções para os problemas mais comuns, como “quadrados pretos” e “tela em branco”, e saberá quando vale a pena passar para um módulo I2C.

LCD de caracteres 16x2
LCD 16x2: caracteres de 5 × 8 pixels em 16 colunas e 2 linhas. Os 16 pinos na borda superior são ligados diretamente, sem módulo I2C.

Como funciona um LCD 16x2?

O chip em forma de gota preta na parte de trás do display é o driver HD44780 (ou um clone totalmente compatível), a linguagem comum de quase todos os LCDs de caracteres. O Arduino envia dois tipos de bytes a esse chip: comandos (limpar a tela, mover o cursor para esta posição, ligar o display) e caracteres (o código da letra a exibir). O pino RS indica qual está sendo enviado: com RS em LOW, o byte é um comando; com RS em HIGH, é um caractere. O pino E (enable) é o sinal de “dados prontos, leia agora”; depois de colocar um byte nas linhas de dados, E recebe um breve pulso HIGH e o chip lê o byte na borda de descida. Dentro do chip há uma memória de exibição de 80 caracteres (DDRAM), uma ROM de fontes com 208 caracteres incorporados e uma pequena memória (CGRAM) para os 8 caracteres personalizados que você vai criar.

CaracterísticaValor
Chip driverHD44780 ou compatível (KS0066, SPLC780)
Display16 colunas × 2 linhas, cada caractere com 5 × 8 pixels
Alimentação4,5–5,5 V (também existem versões especiais de 3,3 V)
Corrente da lógicaCerca de 1–2 mA
Corrente da luz de fundoCerca de 15–30 mA (LED, dependendo do modelo)
Barramento de dadosParalelo de 8 bits ou 4 bits
Caracteres personalizados8 (CGRAM)
Tempo dos comandosMaioria dos comandos: 37 µs; clear() e home(): cerca de 1,5 ms

A função de cada um dos 16 pinos

PinoNomeFunçãoLigação
1VSSTerraGND
2VDDAlimentação da lógica5V
3V0 (VO, VEE)Ajuste de contrasteCursor de um potenciômetro de 10 kΩ
4RSSeleção de comando (LOW) ou caractere (HIGH)Arduino D12
5RWLeitura (HIGH) ou escrita (LOW)GND (apenas escrevemos)
6EPulso de dados válidosArduino D11
7–10D0–D3Bits inferiores de dadosFicam sem ligação no modo de 4 bits
11D4Bit de dados 4Arduino D5
12D5Bit de dados 5Arduino D4
13D6Bit de dados 6Arduino D3
14D7Bit de dados 7Arduino D2
15A (LED+)Ânodo da luz de fundo5V por meio de 220 Ω
16K (LED−)Cátodo da luz de fundoGND
Em alguns LCDs, a ordem dos pinos é diferente, ou os pinos 15 e 16 da luz de fundo ficam logo no início. Confira as indicações na placa e a marca do pino 1 antes de ligar. Não ligue a luz de fundo diretamente a 5 V sem resistor: se o módulo não tiver resistor em série, o LED consumirá corrente demais e perderá luminosidade. Geralmente há um resistor de cerca de 100 Ω na parte de trás, identificado como R8 ou R9; se você não tiver certeza, adicione o resistor de 220 Ω mesmo assim. Você pode encontrar o valor adequado com a calculadora de resistor para LED.

Modo de 4 bits: por que 4 linhas de dados em vez de 8?

O HD44780 pode receber um byte de uma só vez por 8 linhas de dados (modo de 8 bits) ou em duas metades pelas linhas D4–D7 (modo de 4 bits). No modo de 4 bits, a metade superior do byte é enviada primeiro, seguida da inferior, com um pulso no pino E para cada metade. Isso leva o dobro do tempo, mas na prática você não percebe: escrever um caractere ainda leva cerca de 50 µs, e atualizar toda a tela leva menos de 2 ms. Em troca, quatro pinos do Arduino ficam livres. A biblioteca LiquidCrystal seleciona automaticamente o modo de 4 bits quando você passa seis pinos ao construtor; deixar D0–D3 sem ligação é seguro porque o chip tem resistores de pull-up internos nesses pinos.

O potenciômetro de contraste

Potenciômetro de 10 kΩ
Um potenciômetro de 10 kΩ é tudo de que você precisa para o contraste: terminais externos em 5V e GND, terminal central no V0 do LCD.

A tensão no pino V0 determina se o texto fica visível. O que orienta o cristal líquido é a diferença entre VDD e V0; nos módulos padrão de 5 V, a melhor imagem costuma ser obtida com V0 em torno de 0,3–1 V. À medida que V0 se aproxima de 0 V, o fundo dos caracteres também escurece e as células vazias aparecem como quadrados pretos; ao se aproximar de 5 V, o texto desaparece completamente. Por isso, um potenciômetro é a opção mais prática para a primeira montagem: ligue um terminal externo a 5V, o outro a GND e o terminal central a V0; depois, gire devagar até o texto ficar nítido. Depois de encontrar o ajuste, você pode substituir o potenciômetro por um resistor fixo: 1–2,2 kΩ entre V0 e GND funciona bem na maioria dos módulos.

Passo a passo: seu primeiro texto com Arduino

  1. Solde uma barra de 16 pinos macho no LCD e encaixe o display na protoboard; em uma protoboard longa, sobra espaço para fios dos dois lados do display.
  2. Leve 5V e GND do Arduino às trilhas de alimentação da protoboard. Ligue os pinos 1 (VSS) e 16 (K) do LCD a GND, o pino 2 (VDD) a 5V e o pino 15 (A) a 5V por meio de 220 Ω. Ao conectar o Arduino à USB, a luz de fundo deve acender.
  3. Ligue o potenciômetro e gire-o. Mesmo antes de carregar qualquer código, devem aparecer 16 quadrados pretos na linha superior; isso mostra que o display e o contraste estão funcionando.
  4. Ligue o pino 5 (RW) a GND. Depois, ligue RS a D12, E a D11 e D4–D7 a D5, D4, D3 e D2, respectivamente.
  5. Confira no Gerenciador de Bibliotecas se a biblioteca LiquidCrystal está instalada (ela vem com o Arduino IDE) e carregue o código abaixo.
  6. Quando os quadrados desaparecerem e o texto surgir, faça o ajuste final do contraste com o potenciômetro.
C++ (Arduino IDE)
1// 16x2 LCD, I2C modülü olmadan (4-bit mod) / 16x2 LCD without an I2C module (4-bit mode)
2// RS -> D12, E -> D11, D4 -> D5, D5 -> D4, D6 -> D3, D7 -> D2, RW -> GND, V0 -> pot
3#include <LiquidCrystal.h>
4
5const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
6LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
7
8void setup() {
9  lcd.begin(16, 2);              // 16 sütun, 2 satır / 16 columns, 2 rows
10  lcd.print(F("Merhaba Arduino!"));
11  lcd.setCursor(0, 1);           // sütun 0, satır 1 / column 0, row 1
12  lcd.print(F("Sure:"));
13}
14
15void loop() {
16  unsigned long s = millis() / 1000;
17  lcd.setCursor(6, 1);
18  lcd.print(s);
19  lcd.print(F(" sn   "));      // eski haneleri boşlukla sil / overwrite old digits with spaces
20  delay(200);
21}

O código adota duas práticas simples, mas importantes. Primeiro, antes de escrever o valor que muda, ele vai até essa posição com setCursor(), em vez de chamar clear(), e acrescenta alguns espaços depois do número. clear() é um comando pesado, que leva cerca de 1,5 ms e, quando usado no laço, faz a tela piscar; além disso, não há necessidade de apagar e reescrever toda a tela. Os espaços evitam que um dígito antigo permaneça na tela quando o número fica mais curto (por exemplo, de 100 para 99). Segundo, os textos fixos são escritos com a macro F(), para ficarem na memória de programa em vez da RAM. Um display 16x2 comporta no máximo 16 caracteres por linha; um texto mais longo ultrapassa a borda direita e não fica visível.

ComandoO que faz
lcd.begin(16, 2)Inicializa o display e define o número de colunas e linhas
lcd.print(value) (imprime o valor)Exibe texto, um inteiro ou um decimal; lcd.print(3.14159, 2) exibe duas casas decimais
lcd.setCursor(column, row) (coluna, linha)Escolhe onde escrever; a contagem começa em 0
lcd.clear()Limpa a tela e retorna o cursor à posição inicial (leva 1,5 ms)
lcd.cursor() / lcd.noCursor() (mostra/oculta o cursor)Mostra ou oculta o cursor sublinhado
lcd.blink() / lcd.noBlink() (liga/desliga o cursor piscante)Ativa ou desativa o cursor de bloco piscante
lcd.display() / lcd.noDisplay() (liga/desliga a exibição)Liga ou desliga a imagem sem apagar a memória de exibição
lcd.scrollDisplayLeft()Desloca toda a tela uma coluna para a esquerda
lcd.createChar(num, array) (cria caractere personalizado)Carrega um caractere personalizado na posição 0–7
lcd.write(byte(num)) (escreve caractere personalizado)Escreve um caractere personalizado ou um código da ROM

Caracteres personalizados: gráfico de barras que se preenche com um potenciômetro

Cada célula de caractere é uma grade de pixels com 5 colunas e 8 linhas. Para definir um caractere personalizado, você escreve cada linha como um número de 5 bits: 1 representa um pixel aceso, 0 um apagado. O HD44780 permite 8 caracteres personalizados ao mesmo tempo. O exemplo abaixo usa cinco dessas posições para blocos com 1, 2, 3, 4 e 5 colunas preenchidas a partir da esquerda. Com 16 células × 5 colunas, você obtém uma barra de 80 níveis que se preenche e esvazia suavemente com um potenciômetro; ideal para volume, nível de bateria ou porcentagem de um sensor. Abordamos a criação de caracteres personalizados para letras turcas (ş, ğ, ı, ç) no artigo sobre LCD I2C; o mesmo comando createChar funciona exatamente da mesma forma na ligação paralela.

C++ (Arduino IDE)
1// Özel karakterlerle 80 adımlık çubuk grafik / 80-step bar graph with custom characters
2// Potansiyometre orta ucu -> A0 / potentiometer wiper -> A0
3#include <LiquidCrystal.h>
4
5LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
6
7byte bars[5][8];                       // 1..5 sütun dolu bloklar / blocks with 1..5 columns filled
8
9void buildBars() {
10  for (int n = 0; n < 5; n++) {
11    byte row = 0;
12    for (int c = 0; c <= n; c++) row |= (0b10000 >> c);   // soldan doldur / fill from the left
13    for (int r = 0; r < 8; r++) bars[n][r] = row;
14    lcd.createChar(n, bars[n]);        // karakter 0 = 1 sütun ... 4 = 5 sütun / char 0 = 1 column ... 4 = 5 columns
15  }
16}
17
18void setup() {
19  lcd.begin(16, 2);
20  buildBars();
21  lcd.setCursor(0, 0);                 // createChar sonrası konum ayarla / set position after createChar
22  lcd.print(F("Seviye / Level"));
23}
24
25void loop() {
26  int raw = analogRead(A0);
27  int steps = map(raw, 0, 1023, 0, 80);  // 16 hücre x 5 sütun / 16 cells x 5 columns
28  int percent = map(raw, 0, 1023, 0, 100);
29
30  lcd.setCursor(12, 0);
31  if (percent < 100) lcd.print(' ');
32  if (percent < 10) lcd.print(' ');
33  lcd.print(percent);
34  lcd.print('%');
35
36  lcd.setCursor(0, 1);
37  for (int cell = 0; cell < 16; cell++) {
38    int fill = steps - cell * 5;       // bu hücreye düşen sütun / columns in this cell
39    if (fill >= 5) lcd.write(byte(4));
40    else if (fill > 0) lcd.write(byte(fill - 1));
41    else lcd.print(' ');
42  }
43  delay(50);
44}

O comando createChar move o cursor da memória de exibição para a memória de caracteres. Por isso, depois de carregar os caracteres personalizados, você deve chamar setCursor() antes de escrever; caso contrário, o primeiro texto pode não aparecer. Os caracteres ficam apenas na CGRAM e são perdidos quando o display fica sem alimentação, por isso são carregados novamente em setup() a cada inicialização. Se você alterar a definição de um caractere personalizado enquanto ele estiver na tela, todas as células que exibem esse caractere mudarão ao mesmo tempo; pequenas animações são feitas exatamente com esse truque.

LCD 20x4: mesma ligação, tela maior

LCDs com 20 colunas e 4 linhas usam o mesmo chip HD44780 e os mesmos 16 pinos; a ligação é idêntica e, no código, você só precisa de lcd.begin(20, 4). A luz de fundo consome um pouco mais de corrente (40–60 mA), então evite reduzir o resistor em série para não sobrecarregar a linha de 5V do Arduino durante o uso prolongado. A única particularidade que você precisa conhecer é a ordem das linhas: na memória de exibição, o fim da linha 1 continua na linha 3, e o fim da linha 2 continua na linha 4. Assim, se você escrever um texto longo sem setCursor(), ele passa da linha 1 para a linha 3, e não para a linha 2. Chamar setCursor(0, row) no início de cada linha elimina completamente o problema.

C++ (Arduino IDE)
1// 20x4 LCD: aynı bağlantı, begin(20, 4) / 20x4 LCD: same wiring, begin(20, 4)
2#include <LiquidCrystal.h>
3
4LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
5
6void setup() {
7  lcd.begin(20, 4);
8  for (int row = 0; row < 4; row++) {
9    lcd.setCursor(0, row);             // her satırı açıkça seç / select every row explicitly
10    lcd.print(F("Satir / Row "));
11    lcd.print(row + 1);
12  }
13}
14
15void loop() {
16  lcd.setCursor(15, 3);
17  lcd.print(millis() / 1000 % 100000);  // 5 haneye sığsın / fit in 5 digits
18  delay(500);
19}

LCD paralelo com ESP32

Um LCD 16x2 padrão não oferece contraste suficiente se não for alimentado com 5 V, enquanto os pinos do ESP32 são de 3,3 V. A boa notícia: desde que RW esteja ligado a GND, o LCD nunca aplica tensão às linhas; ele apenas recebe os sinais. Como o menor nível de entrada que o HD44780 aceita como HIGH a 5 V é de cerca de 2,2 V, os sinais de 3,3 V do ESP32 são suficientes e não é necessário um conversor de nível lógico. Ligue VDD do LCD ao pino VIN da placa ESP32 (5 V da USB). A biblioteca LiquidCrystal funciona da mesma forma no ESP32; apenas evite pinos com função especial na inicialização, como GPIO 0, 2, 12 e 15.

C++ (Arduino IDE)
1// ESP32 + 16x2 LCD (paralel, 4-bit) / ESP32 + 16x2 LCD (parallel, 4-bit)
2// RS -> GPIO 22, E -> GPIO 21, D4 -> 19, D5 -> 18, D6 -> 26, D7 -> 25
3// VDD -> VIN (5 V), RW -> GND, V0 -> pot, A -> 220 ohm -> VIN
4#include <LiquidCrystal.h>
5
6LiquidCrystal lcd(22, 21, 19, 18, 26, 25);
7
8void setup() {
9  lcd.begin(16, 2);
10  lcd.print("ESP32 + LCD");
11}
12
13void loop() {
14  lcd.setCursor(0, 1);
15  lcd.print("Heap: ");
16  lcd.print(ESP.getFreeHeap() / 1024);   // boş bellek (KB) / free memory (KB)
17  lcd.print(" KB   ");
18  delay(1000);
19}

LCD paralelo com Raspberry Pi Pico (MicroPython)

A mesma lógica se aplica ao Raspberry Pi Pico: alimente o LCD com 5 V de VBUS (pino 40), ligue RW a GND e leve os sinais diretamente aos pinos GP. O MicroPython não tem uma biblioteca LiquidCrystal pronta, por isso abaixo há um driver curto que controla o modo de 4 bits por conta própria. Ele segue a sequência de inicialização do datasheet do HD44780: espera 50 ms após ligar, força o chip para o modo de 8 bits três vezes, depois passa para o modo de 4 bits e liga o display. Cada caractere é enviado em duas metades (nibbles), com um pulso curto no pino E depois de cada uma.

MicroPython
1# Raspberry Pi Pico: I2C'siz 16x2 LCD sürücüsü (4-bit) / 16x2 LCD driver without I2C (4-bit)
2# RS -> GP16, E -> GP17, D4 -> GP18, D5 -> GP19, D6 -> GP20, D7 -> GP21
3# VDD -> VBUS (pin 40, 5 V), RW -> GND, V0 -> pot
4from machine import Pin
5import time
6
7
8class LCD4:
9    def __init__(self, rs, e, d4, d5, d6, d7):
10        self.rs = Pin(rs, Pin.OUT, value=0)
11        self.e = Pin(e, Pin.OUT, value=0)
12        self.data = [Pin(p, Pin.OUT, value=0) for p in (d4, d5, d6, d7)]
13        time.sleep_ms(50)                 # güç geldikten sonra bekle / wait after power-up
14        for _ in range(3):
15            self._nibble(0x03)            # 8-bit moda zorla / force 8-bit mode
16            time.sleep_ms(5)
17        self._nibble(0x02)                # 4-bit moda geç / switch to 4-bit mode
18        self.command(0x28)                # 4 bit, 2 satır, 5x8 / 4-bit, 2 lines, 5x8
19        self.command(0x0C)                # ekran açık, imleç kapalı / display on, cursor off
20        self.clear()
21        self.command(0x06)                # soldan sağa yaz / write left to right
22
23    def _nibble(self, value):
24        for i, pin in enumerate(self.data):
25            pin.value((value >> i) & 1)
26        self.e.value(1)                   # E darbesi / E pulse
27        time.sleep_us(1)
28        self.e.value(0)
29        time.sleep_us(50)                 # komut süresi (37 µs) / command time (37 µs)
30
31    def _write(self, value, rs):
32        self.rs.value(rs)
33        self._nibble(value >> 4)          # önce üst yarı / upper half first
34        self._nibble(value & 0x0F)
35
36    def command(self, cmd):
37        self._write(cmd, 0)
38
39    def clear(self):
40        self.command(0x01)
41        time.sleep_ms(2)                  # clear yaklaşık 1,5 ms / clear takes about 1.5 ms
42
43    def move_to(self, col, row):
44        offsets = (0x00, 0x40, 0x14, 0x54)   # 16x2 ve 20x4 satır adresleri / row addresses
45        self.command(0x80 | (offsets[row] + col))
46
47    def putstr(self, text):
48        for ch in text:
49            self._write(ord(ch), 1)
50
51
52lcd = LCD4(rs=16, e=17, d4=18, d5=19, d6=20, d7=21)
53lcd.move_to(0, 0)
54lcd.putstr("Merhaba Pico!")
55count = 0
56while True:
57    lcd.move_to(0, 1)
58    lcd.putstr("Sayac: {:<9d}".format(count))
59    count += 1
60    time.sleep(1)

Quadrados pretos, tela em branco e outros problemas

Quase todo problema que você encontrará com um LCD paralelo apresenta um de poucos sintomas, e o próprio display indica onde procurar. A pista mais importante é esta: se você vê 16 quadrados pretos apenas na linha superior, a alimentação e o contraste estão corretos, mas o chip nunca foi inicializado. Ao ligar, o HD44780 inicia no modo de uma linha e controla apenas a primeira linha; enquanto o código não conseguir inicializar o display, a imagem não mudará. Nesse caso, o problema quase sempre está nos fios RS, E ou D4–D7, ou na ordem dos pinos no construtor. Se você vê quadrados suaves nas duas linhas, o display está funcionando e o contraste está apenas alto demais.

SintomaCausa provávelSolução
16 quadrados pretos apenas na linha superiorDisplay não inicializado: ligação de RS, E, D4–D7 ou ordem dos pinos no construtor incorreta, ou nenhum código carregadoConfira os fios com a tabela e a ordem LiquidCrystal lcd(RS, E, D4, D5, D6, D7)
Quadrados suaves nas duas linhasContraste alto demais (V0 muito próximo de GND)Gire o potenciômetro
Luz de fundo acesa, mas nada apareceContraste baixo demais ou V0 desconectadoConfira se o cursor do potenciômetro está ligado a V0 e gire-o
Luz de fundo não acendePinos 15 e 16 desconectados, invertidos ou resistor ausenteLigue A a 5V por meio de 220 Ω e K a GND
Caracteres sem sentido ou deslocadosFio de dados solto, D4–D7 trocados, ruído de motor ou reléPrenda os fios, adicione 100 µF na alimentação e reinicialize com lcd.begin() se necessário
Texto piscalcd.clear() é usado no laçoSobrescreva com setCursor() e apague os dígitos antigos com espaços
Um dígito antigo permanece quando o número fica mais curtoO novo valor é mais curto que o anteriorAdicione espaços depois do valor
Texto não aparece depois de um caractere personalizadocreateChar moveu o cursor para a memória de caracteresChame setCursor() depois de createChar
Em projetos com motores, relés ou servos, às vezes o LCD começa a mostrar caracteres sem sentido depois de algumas horas: uma queda de tensão colocou o chip em um estado indefinido. Chamar lcd.begin(16, 2) periodicamente, por exemplo uma vez por minuto, e redesenhar a tela resolve o problema sem que o usuário perceba.

Vale a pena passar para um módulo I2C?

Módulo adaptador I2C para LCD (PCF8574)
O módulo adaptador I2C baseado no PCF8574 é soldado na parte de trás do LCD e reduz os 16 pinos a apenas quatro fios.

Graças ao chip PCF8574 na parte de trás, o módulo I2C transporta todos os sinais do LCD por dois fios (SDA e SCL); o potenciômetro de contraste e o transistor da luz de fundo também ficam na placa. À medida que seu projeto cresce, essa praticidade faz diferença: um Uno tem apenas 20 pinos digitais e analógicos, e um LCD paralelo usa seis deles sozinho. Por outro lado, a ligação paralela é mais rápida, não tem conflitos de endereço I2C e dispensa um módulo extra. A tabela abaixo resume qual é melhor em cada situação; para configurar o módulo I2C, veja o artigo sobre display LCD I2C.

CaracterísticaParalelo (4 bits)Com módulo I2C
Pinos do Arduino usados62 (A4, A5)
Número de fios12 (incluindo alimentação e potenciômetro)4
Atualização de toda a telaMenos de 2 msCerca de 20–30 ms a 100 kHz
Ajuste de contrastePotenciômetro externoTrimpot no módulo
Desligar a luz de fundo por softwarePrecisa de um transistor extralcd.noBacklight()
BibliotecaLiquidCrystal (vem com o IDE)LiquidCrystal I2C (instalada separadamente)
Problemas típicosFios em excesso, conexões soltasProblemas de endereço (0x27 / 0x3F) e pull-up

Ideias de projetos com LCD 16x2

  • Termômetro digital: Exiba a temperatura e a umidade de um NTC ou de um DHT11 em texto grande, escrevendo o símbolo de grau com lcd.write(223).
  • Fechadura com senha: Mostre a senha digitada em um teclado matricial como asteriscos e acione um relé se ela estiver correta.
  • Display de distância: Exiba a distância medida por um HC-SR04 em centímetros e como gráfico de barras ao mesmo tempo.
  • Cronômetro e contagem regressiva: Inicie, pare e reinicie com dois botões, exibindo o tempo como minutos:segundos:centésimos.
  • Minijogo: Desenhe um corredor e obstáculos com caracteres personalizados e faça-o pular com um botão.
  • Sistema de menus: Crie um menu em que você navega e altera configurações com um encoder rotativo, salvando as escolhas na EEPROM.

Ligar um LCD 16x2 sem módulo I2C pode parecer uma confusão de fios no início, mas, depois de aprender como o display recebe comandos, você pode usar qualquer LCD de caracteres, o 20x4 e até outros microcontroladores com a mesma lógica. No app BlueGrays, os projetos “Exibir uma mensagem no LCD 16x2”, “Texto que vai e volta no LCD” e “Medição de distância com LCD” ensinam essa ligação passo a passo, com diagrama de fiação e código pronto.

Perguntas frequentes

Por que meu LCD 16x2 mostra quadrados pretos?

Se os quadrados aparecem apenas na linha superior, a alimentação e o contraste estão corretos, mas o Arduino não conseguiu inicializar o display; confira os fios RS, E e D4–D7 e a ordem dos pinos no construtor LiquidCrystal. Se aparecem quadrados suaves nas duas linhas, o contraste está alto demais e basta girar o potenciômetro.

Por que a luz de fundo do meu LCD está acesa, mas nenhum texto aparece?

A causa mais comum é o contraste baixo demais: quando V0 fica próximo de 5 V, os caracteres ficam invisíveis. Confira se o cursor do potenciômetro está ligado a V0 e gire-o devagar. Se o contraste estiver correto e aparecerem quadrados na linha superior, o problema está nos fios de dados ou no código.

É possível usar um LCD 16x2 sem potenciômetro?

Sim. Um resistor fixo de 1–2,2 kΩ entre V0 e GND oferece bom contraste na maioria dos módulos de 5 V. A forma mais confiável é encontrar o valor com um potenciômetro e depois substituí-lo por um resistor fixo. Você também pode ligar V0 a um pino PWM por meio de um filtro RC e ajustar o contraste por software.

Onde ligar o pino RW do LCD?

Se você só vai escrever no display, ligue RW (pino 5) a GND; isso mantém o LCD permanentemente no modo de escrita, que é como a biblioteca LiquidCrystal funciona. Se RW ficar flutuando, o display poderá mudar aleatoriamente para o modo de leitura e aplicar sinais às linhas de dados, e talvez nada apareça. Ligar RW a GND também protege os pinos de placas de 3,3 V.

Qual é a diferença entre LiquidCrystal e LiquidCrystal_I2C?

LiquidCrystal controla o LCD diretamente pelos pinos do Arduino e vem com o Arduino IDE; ela é usada na ligação paralela. LiquidCrystal_I2C envia os mesmos comandos por um módulo I2C PCF8574 e precisa ser instalada separadamente. A maioria dos comandos (print, setCursor, createChar) é igual nas duas; a versão I2C acrescenta lcd.init() para inicialização e backlight() para a luz de fundo.

Meu código para LCD 16x2 funciona em um LCD 20x4?

Sim, porque a ligação e os comandos são os mesmos; você só precisa trocar lcd.begin(16, 2) por lcd.begin(20, 4). Em um display 20x4, as linhas seguem a ordem 1, 3, 2, 4 na memória, por isso ir para cada linha com setCursor(0, row) é a abordagem mais clara. A luz de fundo consome um pouco mais de corrente.

Ver todos os projetos
Exibição de mensagens no display LCD 2x16
AR-29Avançado
Premium

Exibição de mensagens no display LCD 2x16

Seu primeiro passo para escrever textos em um display. O display LCD de duas linhas mostra primeiro uma mensagem de espera, depois escreve uma saudação na linha de cima e uma palavra letra por letra…

4.6(37)
51
Animação de texto que rebate nas bordas do LCD
AR-30Avançado
Premium

Animação de texto que rebate nas bordas do LCD

Na linha de cima do display LCD, a palavra BLUEGRAYS desliza de uma borda à outra e volta como uma bola que bate na parede, repetindo o movimento sem parar.

4.5(29)
40
Medição de distância com display LCD
AR-31Avançado
Premium

Medição de distância com display LCD

Uma ferramenta que mede distâncias sem régua: aproxime e afaste a mão na frente do sensor e veja o número mudar.

4.6(45)
59
Medição de temperatura com NTC e display LCD 2x16
AR-44Iniciante
Premium

Medição de temperatura com NTC e display LCD 2x16

Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

4.5(33)
44
Relógio RTC DS1302 com display LCD
AR-46Intermediário
Premium

Relógio RTC DS1302 com display LCD

Um pequeno relógio de mesa que mantém a hora mesmo quando falta energia. O módulo de relógio DS1302 mantém a hora graças à sua própria pilha; a cada segundo, o Arduino lê essa informação e exibe a…

4.7(41)
51
Voltímetro digital com display LCD
AR-56Intermediário
Premium

Voltímetro digital com display LCD

Descubra a tensão de uma pilha ou de um adaptador de alimentação com um medidor feito por você.

4.5(27)
36
Fechadura com senha, teclado 4x4 e LCD
AR-64Avançado
Premium

Fechadura com senha, teclado 4x4 e LCD

Uma pequena fechadura eletrônica que impede a entrada de quem não sabe a senha. Você pressiona a cerquilha e digita a senha no teclado.

4.8(59)
75
Jogo de corrida no LCD com Arduino
AR-96Intermediário
Premium

Jogo de corrida no LCD com Arduino

Jogo de corrida infinita com rolagem lateral em um display LCD de 16x2 caracteres. O herói corre automaticamente, e o jogador pressiona o botão para pular os obstáculos. Obstáculos aleatórios aparecem nas linhas superior e inferior. O buzzer passivo toca a melodia de abertura, o som de pulo, o som de comemoração a cada 50 pontos e a melodia de fim de jogo. A tela de abertura "BlueGrays - Arduino Projects" aparece ao iniciar. A pontuação é atualizada em tempo real no canto superior direito.

4.6(32)
56