Tipos de display para Arduino comparados: LCD, OLED, TFT, e-paper e 7 segmentos
Tipos de display para Arduino comparados: LCD 16x2, OLED, TFT, e-paper, TM1637, MAX7219 e Nextion. Veja resolução, pinos, memória, consumo e qual combina com cada projeto.
Os tipos de display para Arduino confundem no começo: a mesma palavra “display” serve para um LCD de 16 caracteres, um OLED do tamanho da ponta de um dedo, um TFT colorido como a tela de um celular e um painel e-paper que mantém a imagem mesmo quando a alimentação é cortada. Cada um é muito diferente em resolução, cor, forma de ligação, uso de memória e consumo de energia. A escolha errada vira um Uno sem RAM, uma leitura impossível de enxergar sob o sol ou um sensor que esgota a bateria em um dia.
Neste guia vamos ver, uma por uma, as sete famílias de display mais usadas em projetos com Arduino: LCDs de caracteres (16x2 e 20x4), OLEDs (SSD1306 e SH1106), TFTs coloridos (ILI9341 e ST7789), e-paper, 7 segmentos e TM1637, matrizes de LED MAX7219 e displays touch Nextion. Primeiro vem uma grande tabela comparativa, depois uma breve apresentação e um código de exemplo funcionando para cada display e, por fim, uma tabela de “qual display para qual projeto” e os erros mais comuns.

Tipos de display para Arduino: tabela comparativa rápida
| Display | Resolução | Cor | Interface | Pinos de dados | Corrente típica | Preço |
|---|---|---|---|---|---|---|
| LCD de caracteres 16x2 / 20x4 | 16×2 ou 20×4 caracteres | Monocromático, com luz de fundo | Paralela ou módulo I2C | 6 (paralela) / 2 (I2C) | 20–40 mA | Muito barato |
| OLED SSD1306 / SH1106 | 128×64 (0,96" e 1,3") | Monocromático (branco, azul, amarelo-azul) | I2C ou SPI | 2 (I2C) / 5 (SPI) | 10–25 mA | Barato |
| TFT ILI9341 | 240×320 (2,4–3,2") | 65 mil cores | SPI ou paralela de 8 bits | 5 (SPI) | 50–100 mA | Médio |
| TFT ST7789 | 240×240, 240×320, 135×240 | 65 mil cores | SPI | 4–5 | 30–80 mA | Médio |
| E-paper (e-ink) | 200×200, 296×128, 250×122 | Preto e branco (alguns com vermelho/amarelo) | SPI | 6 (incluindo BUSY) | 5–20 mA só durante a atualização | Médio a caro |
| 7 segmentos / TM1637 | 1–8 dígitos | LED de uma cor | Direta ou 2 fios (TM1637) | 8–12 / 2 | 20–80 mA | Muito barato |
| Matriz de LED MAX7219 | 8×8, em cascata até 32×8 ou mais | LED de uma cor | 3 fios (parecido com SPI) | 3 | 20–300 mA conforme o brilho | Barato |
| Nextion HMI | De 320×240 até 800×480 | 65 mil cores, touch | UART (TX/RX) | 2 | 90–500 mA | Caro |
O número de “pinos de dados” na tabela não inclui a alimentação (VCC e GND). Os valores de corrente variam muito conforme a luz de fundo e o brilho; o e-paper só consome corrente enquanto a imagem muda e depois praticamente não gasta nada. Os preços estão classificados uns em relação aos outros: pelo preço de um Nextion você compra uns dez LCDs 16x2.
O que observar ao escolher um display
- O que você vai mostrar? Só números pedem um display de 7 segmentos; algumas linhas de texto, um LCD de caracteres; gráficos e ícones, um OLED; e uma interface colorida ou fotos, um TFT.
- Onde ele será lido? E-paper e LCDs são bem legíveis sob o sol; OLEDs e TFTs sofrem com luz forte. No escuro, por outro lado, o preto do OLED é preto de verdade e não cansa os olhos.
- Quantos pinos estão livres? Displays I2C se viram com dois fios; um LCD paralelo precisa de seis, um TFT SPI de cinco e o e-paper de seis. Para fazer as contas de pinos, veja os posts sobre I2C e SPI.
- Sua placa tem memória suficiente? Os 2 KB de RAM do Uno mal comportam o buffer de um OLED e nunca comportam o buffer de um TFT colorido. No ESP32 e no Pico isso quase não é problema.
- Vai funcionar com bateria? O e-paper, que mantém a imagem sem gastar energia, é imbatível para sensores que funcionam por meses.
- Nível de tensão: a maioria dos módulos TFT e e-paper usa lógica de 3,3 V; com um Uno, talvez você precise de um conversor de nível lógico.
- Suporte de bibliotecas: displays que funcionam com bibliotecas populares como Adafruit GFX, U8g2, TFT_eSPI e LiquidCrystal_I2C facilitam muito encontrar exemplos e resolver problemas.
LCD de caracteres: 16x2 e 20x4
Os LCDs de caracteres com controlador HD44780 são o display clássico do Arduino. Cada caractere é formado por 5×8 pontos; o modelo 16x2 comporta 16 caracteres em cada uma das 2 linhas e o 20x4, 20 caracteres em cada uma das 4 linhas. Como o próprio controlador do display guarda a imagem, ele quase não usa RAM do Arduino. A ligação direta precisa de 6 pinos (RS, E e D4–D7) mais um potenciômetro para o contraste; explicamos esse método no post ligação paralela do LCD 16x2. Com um módulo I2C baseado no PCF8574 soldado na parte de trás, basta SDA e SCL. Você pode definir até 8 caracteres personalizados e, assim, desenhar o símbolo de grau, um ícone de bateria ou letras acentuadas. O uso detalhado está no post display LCD I2C.
1// I2C 16x2 LCD: sıcaklık gibi bir değeri göstermek / I2C 16x2 LCD: showing a value such as temperature
2// SDA -> A4, SCL -> A5, VCC -> 5V, GND -> GND
3#include <Wire.h>
4#include <LiquidCrystal_I2C.h>
5
6LiquidCrystal_I2C lcd(0x27, 16, 2); // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8byte degree[8] = { // kendi karakterin: derece işareti / custom character: degree sign
9 0b00110, 0b01001, 0b01001, 0b00110,
10 0b00000, 0b00000, 0b00000, 0b00000
11};
12
13void setup() {
14 lcd.init();
15 lcd.backlight();
16 lcd.createChar(0, degree); // 8 özel karakterden ilki / first of 8 custom characters
17 lcd.setCursor(0, 0);
18 lcd.print("BlueGrays LCD");
19}
20
21void loop() {
22 int raw = analogRead(A0); // A0'a bağlı bir sensör / a sensor on A0
23 float value = raw * 100.0 / 1023.0;
24 lcd.setCursor(0, 1);
25 lcd.print("Deger: ");
26 lcd.print(value, 1);
27 lcd.write(byte(0)); // derece işaretini yaz / print the degree sign
28 lcd.print(" "); // eski karakterleri sil / clear leftover characters
29 delay(500);
30}OLED: SSD1306 e SH1106

Nos displays OLED, cada pixel produz a própria luz; não há luz de fundo, o contraste é altíssimo e a imagem fica nítida de qualquer ângulo. Os modelos de 0,96 polegada costumam ter o driver SSD1306, enquanto os de 1,3 polegada geralmente têm o SH1106. Por fora os dois parecem iguais, mas a memória interna do SH1106 tem 132 colunas; num SH1106 controlado com uma biblioteca de SSD1306, a imagem se desloca dois pixels e aparece uma faixa com ruído na borda. A solução é escolher uma biblioteca ou construtor compatível com o driver. A biblioteca U8g2 suporta os dois e, graças ao modo de página, consegue rodar no Uno com um buffer de apenas 128 bytes. O básico do SSD1306 está no post display OLED de 0,96 polegada (SSD1306).
1// U8g2 ile 1,3" SH1106 OLED (sayfa modu, Uno'da az RAM) / 1.3" SH1106 OLED with U8g2 (page mode, low RAM on the Uno)
2// SDA -> A4, SCL -> A5. 0,96" SSD1306 için yorumdaki satırı kullan / for a 0.96" SSD1306 use the commented line
3#include <U8g2lib.h>
4#include <Wire.h>
5
6U8G2_SH1106_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
7// U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
8
9void setup() {
10 oled.begin();
11}
12
13void loop() {
14 int level = map(analogRead(A0), 0, 1023, 0, 120); // A0'daki potansiyometre / potentiometer on A0
15 oled.firstPage();
16 do { // her sayfa için aynı çizim tekrarlanır / the same drawing repeats per page
17 oled.setFont(u8g2_font_ncenB08_tr);
18 oled.drawStr(0, 12, "BlueGrays OLED");
19 oled.drawFrame(0, 40, 124, 14); // çubuk çerçevesi / bar frame
20 oled.drawBox(2, 42, level, 10); // dolu çubuk / filled bar
21 } while (oled.nextPage());
22 delay(100);
23}O _1_ no nome do construtor significa que a tela é desenhada em páginas de 8 linhas: o laço firstPage() e nextPage() repete o mesmo desenho oito vezes e envia uma faixa da tela a cada vez. É um pouco mais lento, mas usa 128 bytes de RAM em vez de 1 KB. No ESP32 e no Pico, onde sobra memória, você pode escolher a versão _F_, com buffer completo, e ter animações mais suaves.
TFT colorido: ILI9341 e ST7789

Se você quer gráficos, menus, ícones e medidores coloridos, parte para os displays TFT. Cada pixel carrega cor de 16 bits (RGB565), então dá para mostrar cerca de 65 mil cores. Os dois drivers mais comuns são o ILI9341 e o ST7789. O ILI9341 é usado em telas de 240×320 de 2,4 a 3,2 polegadas e muitas vezes vem com um controlador touch XPT2046. O ST7789 aparece em telas quadradas (240×240) de 1,3 e 1,54 polegada e em telas de 135×240 de placas como a TTGO T-Display. Eles funcionam no Uno, mas devagar: até pintar a tela inteira uma vez leva um tempo visível. No ESP32, interfaces fluidas são possíveis com SPI a 40 MHz e bibliotecas otimizadas como a TFT_eSPI. Para detalhes, veja os posts display TFT ILI9341 e display TFT ST7789.
| Característica | ILI9341 | ST7789 |
|---|---|---|
| Tamanhos comuns | 2,4", 2,8", 3,2" | 1,14", 1,3", 1,54", 2,0" |
| Resolução | 240×320 | 135×240, 240×240, 240×320 |
| Interface | SPI (as versões shield para Uno usam paralela de 8 bits) | SPI (alguns modelos não têm pino CS) |
| Touch | Touch resistivo XPT2046 na maioria dos modelos | Geralmente não tem |
| Biblioteca | Adafruit_ILI9341, TFT_eSPI | Adafruit_ST7789, TFT_eSPI |
| Tamanho do buffer de tela cheia | 153.600 bytes | 115.200 bytes (240×240) |
1// ESP32 + 2,8" ILI9341 TFT: renkli sıcaklık göstergesi / colour temperature gauge
2// SCK 18, MOSI 23, MISO 19 (isteğe bağlı / optional), CS 5, DC 16, RST 17, VCC 3V3, LED 3V3
3#include <SPI.h>
4#include <Adafruit_GFX.h>
5#include <Adafruit_ILI9341.h>
6
7const int TFT_CS = 5;
8const int TFT_DC = 16;
9const int TFT_RST = 17;
10
11Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST); // donanım SPI (VSPI) / hardware SPI (VSPI)
12
13void setup() {
14 tft.begin(40000000); // 40 MHz SPI
15 tft.setRotation(1); // yatay 320x240 / landscape 320x240
16 tft.fillScreen(ILI9341_BLACK);
17 tft.setTextColor(ILI9341_WHITE);
18 tft.setTextSize(2);
19 tft.setCursor(10, 10);
20 tft.print("BlueGrays TFT");
21 tft.drawRect(10, 180, 300, 30, ILI9341_WHITE); // çubuk çerçevesi / bar frame
22}
23
24void loop() {
25 float temp = 20.0 + (analogReadMilliVolts(34) / 3300.0) * 20.0; // örnek değer / example value
26 uint16_t color = temp < 26 ? ILI9341_GREEN : (temp < 33 ? ILI9341_YELLOW : ILI9341_RED);
27
28 tft.fillRect(10, 60, 300, 80, ILI9341_BLACK); // yalnız değişen alanı sil / clear only the changing area
29 tft.setTextSize(6);
30 tft.setTextColor(color);
31 tft.setCursor(20, 70);
32 tft.print(temp, 1);
33 tft.print(" C");
34
35 int w = (int)((temp - 20.0) / 20.0 * 296);
36 tft.fillRect(12, 182, w, 26, color);
37 tft.fillRect(12 + w, 182, 296 - w, 26, ILI9341_BLACK);
38 delay(500);
39}Displays e-paper (e-ink)
O e-paper é a tecnologia de tela usada nos leitores de e-book. Ele forma a imagem movendo minúsculas cápsulas de pigmento preto e branco com um campo elétrico; depois de desenhada, a imagem continua na tela mesmo quando a alimentação é cortada. Isso o torna ideal, junto com o modo deep sleep do ESP32, para estações que acordam uma vez por hora para atualizar a previsão do tempo e funcionam com bateria por meses. Como parece papel, é perfeitamente legível sob o sol. A desvantagem é a velocidade: uma atualização completa leva cerca de 2 segundos e a tela pisca algumas vezes; nos modelos que suportam atualização parcial, isso cai para menos de meio segundo, mas atualizações parciais frequentes podem deixar leves marcas (ghosting). A ligação é por SPI e precisa de MOSI, SCK, CS, DC, RST e um pino BUSY, que avisa quando o display está ocupado. A biblioteca mais comum é a GxEPD2.
| Característica | Valor |
|---|---|
| Tamanhos comuns | 1,54" (200×200), 2,13" (250×122), 2,9" (296×128), 4,2" (400×300) |
| Cor | Preto e branco; modelos de três cores acrescentam vermelho ou amarelo (atualização de 10–15 segundos) |
| Tempo de atualização completa | Cerca de 1–3 segundos |
| Atualização parcial | 0,3–0,5 segundo nos modelos que suportam |
| Corrente em espera | Perto de zero enquanto mantém a imagem |
| Alimentação | 3,3 V (a maioria dos módulos aceita 5 V por meio de um regulador) |
Displays de 7 segmentos e TM1637

Se você só precisa mostrar números, os displays de 7 segmentos continuam sendo a opção mais legível: grandes, brilhantes e visíveis a metros de distância. Um display de um dígito precisa de 8 pinos para os 7 segmentos e o ponto decimal, mais um resistor para cada segmento; um display multiplexado de 4 dígitos usa 12 pinos. Explicamos essa ligação e a diferença entre ânodo comum e cátodo comum no post display de 7 segmentos. O jeito mais fácil de fugir da dor de cabeça com pinos é o módulo TM1637: você liga o display de 4 dígitos, que tem o próprio driver, só com CLK e DIO e ajusta o brilho em 8 níveis pelo software. Embora o protocolo do TM1637 lembre o I2C, ele não usa endereços; por isso pode ir em quaisquer dois pinos digitais e cada módulo precisa do seu próprio par de pinos.
1// TM1637 4 haneli gösterge ile sayaç ve saat / Counter and clock with a TM1637 4-digit display
2// CLK -> D2, DIO -> D3, VCC -> 5V, GND -> GND
3#include <TM1637Display.h>
4
5TM1637Display display(2, 3); // CLK, DIO
6unsigned long lastTick = 0;
7int seconds = 0;
8
9void setup() {
10 display.setBrightness(4); // 0 (sönük) - 7 (en parlak) / 0 (dim) - 7 (brightest)
11 display.clear();
12}
13
14void loop() {
15 if (millis() - lastTick >= 1000) {
16 lastTick = millis();
17 seconds++;
18 int mm = (seconds / 60) % 100;
19 int ss = seconds % 60;
20 // 0b01000000: ortadaki iki nokta / the colon in the middle
21 display.showNumberDecEx(mm * 100 + ss, 0b01000000, true);
22 }
23}Matriz de LED MAX7219

O MAX7219 é um chip que controla sozinho 64 LEDs (uma matriz 8×8 ou um display de 7 segmentos de 8 dígitos) e se comunica por três fios, DIN, CLK e CS, usando um protocolo parecido com SPI. Os módulos podem ser ligados em cascata; com os módulos 4 em 1, comuns no mercado, você monta painéis de texto rolante de 32×8 e, com duas fileiras, de 32×16. O brilho e a legibilidade a distância o tornam ideal para painéis de mensagens, placares e relógios. No Arduino, as bibliotecas mais usadas são MD_Parola e MD_MAX72XX; os detalhes estão no post matriz de LED MAX7219. Abaixo controlamos uma única matriz 8×8 com um Raspberry Pi Pico sem biblioteca, escrevendo diretamente nos registradores:
1# Raspberry Pi Pico: kütüphanesiz MAX7219 8x8 matris / MAX7219 8x8 matrix without a library
2# GP18 -> CLK, GP19 -> DIN, GP17 -> CS, VCC -> VBUS (5 V), GND -> GND
3from machine import Pin, SPI
4import time
5
6spi = SPI(0, baudrate=1_000_000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
7cs = Pin(17, Pin.OUT, value=1)
8
9def write_reg(reg, value):
10 cs.value(0)
11 spi.write(bytearray([reg, value])) # önce yazmaç, sonra değer / register first, then value
12 cs.value(1)
13
14def init():
15 write_reg(0x0F, 0x00) # test modu kapalı / display test off
16 write_reg(0x09, 0x00) # kod çözme yok (matris) / no decode (matrix)
17 write_reg(0x0B, 0x07) # 8 satırın hepsi / scan all 8 rows
18 write_reg(0x0A, 0x03) # parlaklık 0-15 / brightness 0-15
19 write_reg(0x0C, 0x01) # uyku modundan çık / leave shutdown mode
20
21SMILE = [0x3C, 0x42, 0xA5, 0x81, 0xA5, 0x99, 0x42, 0x3C]
22HEART = [0x00, 0x66, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18]
23
24def show(image):
25 for row in range(8):
26 write_reg(row + 1, image[row]) # satır yazmaçları 1-8 / row registers 1-8
27
28init()
29while True:
30 show(SMILE)
31 time.sleep(1)
32 show(HEART)
33 time.sleep(1)Os LEDs do MAX7219 precisam de alimentação de 5 V para acender com brilho, por isso o VCC do módulo vai no pino VBUS do Pico. Segundo o datasheet, com alimentação de 5 V as entradas precisam de pelo menos 3,5 V para serem lidas como HIGH; os sinais de 3,3 V do Pico funcionam bem na maioria dos módulos, mas se notar instabilidade, adicione um conversor de nível lógico nas linhas DIN, CLK e CS. A corrente aumenta com o brilho e com o número de LEDs acesos: com os quatro módulos totalmente acesos no brilho máximo, o consumo pode chegar a centenas de miliampères.
Displays touch HMI Nextion
O Nextion é um display touch inteligente com processador e memória próprios. Você projeta a interface com botões, sliders e medidores no computador, no Nextion Editor, arrastando e soltando, e carrega no display; o Arduino só envia comandos curtos como t0.txt="25" pela porta serial (UART) e lê os eventos de toque. Assim, todo o trabalho de desenho fica no display, e até uma placa pequena como o Uno consegue controlar uma interface colorida de 7 polegadas. A velocidade padrão é 9600 baud. As desvantagens são o preço, uma corrente de 90 mA até no modelo de 2,4 polegadas e de até 500 mA no de 7 polegadas, e o fato de o projeto ser feito num programa à parte. No Uno, a porta serial de hardware é compartilhada com o USB, então usar SoftwareSerial ou escolher placas com várias portas seriais, como o Mega e o ESP32, facilita a vida.
Necessidade de memória: qual display cabe num Uno?
A maioria das bibliotecas de displays gráficos desenha a imagem primeiro num buffer na RAM e depois envia tudo para a tela. Tamanho do buffer = largura × altura × bits por pixel / 8. Quando você lembra que o Arduino Uno tem só 2 KB de RAM, e que parte disso vai para variáveis, porta serial e bibliotecas, o limite fica evidente na hora. Reunimos soluções gerais para problemas de memória no post Arduino sem memória.
| Display | Buffer completo | Arduino Uno (2 KB) | ESP32 (520 KB) / Pico (264 KB) |
|---|---|---|---|
| LCD 16x2 | Não precisa (o display guarda) | Tranquilo | Tranquilo |
| OLED 128×64 | 1.024 bytes | No limite; modo de página (128 bytes) recomendado | Tranquilo |
| OLED 128×32 | 512 bytes | Tranquilo | Tranquilo |
| E-paper 296×128 | 4.736 bytes | Só desenhando página por página | Tranquilo |
| TFT ST7789 240×240 | 115.200 bytes | Impossível; desenha direto na tela | Possível no ESP32, metade da RAM no Pico |
| TFT ILI9341 240×320 | 153.600 bytes | Impossível; desenha direto na tela | Possível, mas em geral se preferem sprites pequenos |
Consumo de energia e uso com bateria
Num projeto alimentado por bateria, o display muitas vezes gasta mais energia que o microcontrolador. Só a luz de fundo de um LCD 16x2 pode consumir mais de 20 mA; se você desligá-la (lcd.noBacklight()), o display continua legível sob o sol, mas não no escuro. A corrente de um OLED é proporcional ao número de pixels acesos: texto branco fino sobre fundo preto gasta várias vezes menos que um fundo branco. Nos TFTs, os LEDs da luz de fundo ficam sempre acesos; controlar o pino da luz de fundo com um transistor ou PWM economiza bastante. O e-paper quase não consome corrente enquanto você não muda a imagem. Para calcular a autonomia da bateria, use o método do post mAh.
Qual display para qual projeto?
| Projeto | Display recomendado | Por quê? |
|---|---|---|
| Indicador de temperatura e umidade | LCD I2C 16x2 ou OLED de 0,96" | Barato, dois fios, algumas linhas de texto bastam |
| Relógio digital e contagem regressiva | TM1637 ou MAX7219 | Dígitos grandes e brilhantes; legíveis a distância |
| Jogo de bolso (Pong, cobrinha, T-Rex) | OLED 128×64 ou matriz 8×8 | Atualização rápida, desenho no nível do pixel |
| Estação meteorológica (com bateria) | E-paper + deep sleep do ESP32 | A imagem fica sem gastar energia e é legível sob o sol |
| Painel de controle colorido e menu | ILI9341 + touch, ou Nextion | Cor, ícones e entrada por toque |
| Texto rolante e painel de mensagens | Módulos MAX7219 em cascata | Visível a metros de distância, cresce com um único CS |
| Dispositivo compacto com ESP32 | ST7789 de 1,14" ou 1,3" | Pequeno, colorido e rápido via SPI |
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| O LCD mostra só quadrados cheios | Contraste não ajustado ou display não inicializado | Gire o potenciômetro de contraste, confira o endereço e a chamada lcd.init() |
| Imagem deslocada e com ruído na borda num OLED de 1,3" | Um display SH1106 controlado com biblioteca de SSD1306 | Use o construtor SH1106 da U8g2 ou a biblioteca Adafruit SH110X |
| O sketch do OLED carrega, mas o Uno trava | O buffer do display esgotou a RAM | Use o modo de página da U8g2 e coloque os textos dentro de F() |
| O TFT fica totalmente branco | Driver errado, pinos errados ou sinal de 5 V | Confirme o driver (ILI9341, ST7789), confira os pinos DC e CS e respeite o nível de 3,3 V |
| O e-paper nunca muda | Pino BUSY não ligado ou modelo errado selecionado | Ligue o BUSY e escolha na GxEPD2 a classe exata do modelo do seu painel |
| Alguns segmentos ficam fracos no display de 7 segmentos | Ânodo comum e cátodo comum confundidos ou falta de resistor | Confira o tipo do display e coloque um resistor em cada segmento |
| O MAX7219 acende LEDs aleatórios | Fio solto, alimentação fraca ou sinal de 3,3 V no limite | Encurte os fios, reforce a alimentação de 5 V e, se preciso, adicione um conversor de nível lógico |
O display certo depende do que o seu projeto mostra, de onde ele será lido e de como é alimentado: LCD para texto, OLED para gráficos pequenos, TFT ou Nextion para interfaces coloridas, e-paper para dispositivos com bateria, e 7 segmentos e MAX7219 para dígitos grandes. No app BlueGrays você encontra projetos com LCD I2C, jogos e display de previsão do tempo em OLED, relógio com TM1637 e matriz de pontos MAX7219, passo a passo, com esquemas do circuito e código.
Perguntas frequentes
Qual é o melhor display para Arduino?
Não existe um único melhor display; a escolha depende do projeto. Um LCD I2C 16x2 serve para algumas linhas de texto, um OLED de 0,96 polegada para gráficos pequenos, um TFT ILI9341 para interface colorida e o e-paper para dispositivos com bateria.
OLED ou LCD: qual é melhor?
O OLED é mais nítido, tem alto contraste, desenha gráficos e é perfeitamente legível no escuro. O LCD de caracteres é mais barato, é mais legível sob o sol e quase não usa RAM do Arduino.
O Arduino Uno consegue controlar um display TFT colorido?
Sim, displays TFT SPI como o ILI9341 ou o ST7789 funcionam com o Uno, mas como não há RAM suficiente para um buffer de tela cheia, o desenho vai direto para a tela e é lento. Para interfaces coloridas fluidas, o ESP32 ou o Raspberry Pi Pico são uma escolha melhor.
Qual é a diferença entre o SSD1306 e o SH1106?
Os dois são drivers de OLED 128×64; o SSD1306 geralmente está em telas de 0,96 polegada e o SH1106 em telas de 1,3 polegada. Como a memória do SH1106 tem 132 colunas, a imagem se desloca quando ele é usado com uma biblioteca de SSD1306; você precisa de uma biblioteca adequada, como a U8g2 ou a Adafruit SH110X.
O display e-paper mantém a imagem quando a alimentação é desligada?
Sim. O e-paper forma a imagem movendo cápsulas de pigmento e, depois de desenhada, a imagem continua na tela sem nenhuma alimentação. Por isso ele é ideal para dispositivos com bateria que atualizam uma vez por hora.
O TM1637 é I2C?
Não. O protocolo de dois fios do TM1637 parece I2C, mas não usa endereços e não vai num barramento I2C. Ele é ligado em quaisquer dois pinos digitais e controlado com a própria biblioteca (por exemplo, TM1637Display); com vários módulos, cada um precisa do seu próprio par de pinos.
Projetos para montar depois desta leitura
Ver todos os projetos
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…

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…

Jogo de bola e raquetes - SSD1306
Uma bola, duas raquetes e você: jogue tênis de mesa, um dos primeiros videogames, em um pequeno display OLED.

Corrida do T-Rex no OLED: jogo do dinossauro com Arduino
O jogo do dinossauro que aparece quando a internet cai, agora na sua mesa: o dinossauro corre pelo pequeno display OLED, os cactos vêm na sua direção e você pula com um único botão.

ESP32 HTTPClient + API de clima (com display OLED SSD1306)
Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.

Display TM1637 de 4 dígitos e 7 segmentos com ESP32
Vamos controlar um módulo de display de 4 dígitos e 7 segmentos com driver TM1637 usando um ESP32. Com apenas 2 pinos GPIO (CLK e DIO), executamos um contador de 0 a 9.999, ajustamos o nível de brilho e exibimos o caractere de dois-pontos (:) no centro, como em um relógio. Com a biblioteca TM1637Display, fica muito fácil controlar números, valores hexadecimais, segmentos e strings.

Relógio e calendário de matriz de LEDs (MAX7219, DS1307)
Um painel luminoso para a mesa ou a parede que mostra a hora e a data em texto deslizante.

Relógio digital com display de 7 segmentos de 4 dígitos
Um relógio digital luminoso de quatro dígitos, parecido com o de um forno de cozinha.
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

