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.

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ística | Valor |
|---|---|
| Chip driver | HD44780 ou compatível (KS0066, SPLC780) |
| Display | 16 colunas × 2 linhas, cada caractere com 5 × 8 pixels |
| Alimentação | 4,5–5,5 V (também existem versões especiais de 3,3 V) |
| Corrente da lógica | Cerca de 1–2 mA |
| Corrente da luz de fundo | Cerca de 15–30 mA (LED, dependendo do modelo) |
| Barramento de dados | Paralelo de 8 bits ou 4 bits |
| Caracteres personalizados | 8 (CGRAM) |
| Tempo dos comandos | Maioria dos comandos: 37 µs; clear() e home(): cerca de 1,5 ms |
A função de cada um dos 16 pinos
| Pino | Nome | Função | Ligação |
|---|---|---|---|
| 1 | VSS | Terra | GND |
| 2 | VDD | Alimentação da lógica | 5V |
| 3 | V0 (VO, VEE) | Ajuste de contraste | Cursor de um potenciômetro de 10 kΩ |
| 4 | RS | Seleção de comando (LOW) ou caractere (HIGH) | Arduino D12 |
| 5 | RW | Leitura (HIGH) ou escrita (LOW) | GND (apenas escrevemos) |
| 6 | E | Pulso de dados válidos | Arduino D11 |
| 7–10 | D0–D3 | Bits inferiores de dados | Ficam sem ligação no modo de 4 bits |
| 11 | D4 | Bit de dados 4 | Arduino D5 |
| 12 | D5 | Bit de dados 5 | Arduino D4 |
| 13 | D6 | Bit de dados 6 | Arduino D3 |
| 14 | D7 | Bit de dados 7 | Arduino D2 |
| 15 | A (LED+) | Ânodo da luz de fundo | 5V por meio de 220 Ω |
| 16 | K (LED−) | Cátodo da luz de fundo | GND |
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

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
- 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.
- 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.
- 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.
- 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.
- Confira no Gerenciador de Bibliotecas se a biblioteca LiquidCrystal está instalada (ela vem com o Arduino IDE) e carregue o código abaixo.
- Quando os quadrados desaparecerem e o texto surgir, faça o ajuste final do contraste com o potenciômetro.
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.
| Comando | O 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.
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.
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.
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.
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.
| Sintoma | Causa provável | Solução |
|---|---|---|
| 16 quadrados pretos apenas na linha superior | Display não inicializado: ligação de RS, E, D4–D7 ou ordem dos pinos no construtor incorreta, ou nenhum código carregado | Confira os fios com a tabela e a ordem LiquidCrystal lcd(RS, E, D4, D5, D6, D7) |
| Quadrados suaves nas duas linhas | Contraste alto demais (V0 muito próximo de GND) | Gire o potenciômetro |
| Luz de fundo acesa, mas nada aparece | Contraste baixo demais ou V0 desconectado | Confira se o cursor do potenciômetro está ligado a V0 e gire-o |
| Luz de fundo não acende | Pinos 15 e 16 desconectados, invertidos ou resistor ausente | Ligue A a 5V por meio de 220 Ω e K a GND |
| Caracteres sem sentido ou deslocados | Fio 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 pisca | lcd.clear() é usado no laço | Sobrescreva com setCursor() e apague os dígitos antigos com espaços |
| Um dígito antigo permanece quando o número fica mais curto | O novo valor é mais curto que o anterior | Adicione espaços depois do valor |
| Texto não aparece depois de um caractere personalizado | createChar moveu o cursor para a memória de caracteres | Chame setCursor() depois de createChar |
Vale a pena passar para um módulo I2C?

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ística | Paralelo (4 bits) | Com módulo I2C |
|---|---|---|
| Pinos do Arduino usados | 6 | 2 (A4, A5) |
| Número de fios | 12 (incluindo alimentação e potenciômetro) | 4 |
| Atualização de toda a tela | Menos de 2 ms | Cerca de 20–30 ms a 100 kHz |
| Ajuste de contraste | Potenciômetro externo | Trimpot no módulo |
| Desligar a luz de fundo por software | Precisa de um transistor extra | lcd.noBacklight() |
| Biblioteca | LiquidCrystal (vem com o IDE) | LiquidCrystal I2C (instalada separadamente) |
| Problemas típicos | Fios em excesso, conexões soltas | Problemas 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.
Projetos para montar depois desta leitura
Ver todos os projetos
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…

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.

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.

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…

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…

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

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.

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

