Guias · 11 min de leitura

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.

Display LCD 16x2 com módulo I2C
LCD de caracteres 16x2 com módulo I2C: o display para Arduino mais barato e mais fácil de ler, ligado com apenas dois fios de dados.

Tipos de display para Arduino: tabela comparativa rápida

DisplayResoluçãoCorInterfacePinos de dadosCorrente típicaPreço
LCD de caracteres 16x2 / 20x416×2 ou 20×4 caracteresMonocromático, com luz de fundoParalela ou módulo I2C6 (paralela) / 2 (I2C)20–40 mAMuito barato
OLED SSD1306 / SH1106128×64 (0,96" e 1,3")Monocromático (branco, azul, amarelo-azul)I2C ou SPI2 (I2C) / 5 (SPI)10–25 mABarato
TFT ILI9341240×320 (2,4–3,2")65 mil coresSPI ou paralela de 8 bits5 (SPI)50–100 mAMédio
TFT ST7789240×240, 240×320, 135×24065 mil coresSPI4–530–80 mAMédio
E-paper (e-ink)200×200, 296×128, 250×122Preto e branco (alguns com vermelho/amarelo)SPI6 (incluindo BUSY)5–20 mA só durante a atualizaçãoMédio a caro
7 segmentos / TM16371–8 dígitosLED de uma corDireta ou 2 fios (TM1637)8–12 / 220–80 mAMuito barato
Matriz de LED MAX72198×8, em cascata até 32×8 ou maisLED de uma cor3 fios (parecido com SPI)320–300 mA conforme o brilhoBarato
Nextion HMIDe 320×240 até 800×48065 mil cores, touchUART (TX/RX)290–500 mACaro

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.

C++ (Arduino IDE)
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}
Se nada aparecer no LCD I2C, primeiro gire o potenciômetro azul de contraste na parte de trás do módulo; muitas vezes ele vem mal ajustado de fábrica. Se continuar em branco, o endereço pode ser 0x3F em vez de 0x27; um sketch scanner I2C mostra o endereço certo em segundos.

OLED: SSD1306 e SH1106

Display OLED I2C de 0,96 polegada
OLED I2C de 0,96 polegada: 128×64 pixels que produzem a própria luz e apenas 4 pinos de ligação.

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

C++ (Arduino IDE)
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

Módulo display colorido TFT ILI9341
TFT colorido de 2,8 polegadas com driver ILI9341: 240×320 pixels, 65 mil cores e ligação SPI; alguns modelos também têm painel touch e slot para cartão SD.

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ísticaILI9341ST7789
Tamanhos comuns2,4", 2,8", 3,2"1,14", 1,3", 1,54", 2,0"
Resolução240×320135×240, 240×240, 240×320
InterfaceSPI (as versões shield para Uno usam paralela de 8 bits)SPI (alguns modelos não têm pino CS)
TouchTouch resistivo XPT2046 na maioria dos modelosGeralmente não tem
BibliotecaAdafruit_ILI9341, TFT_eSPIAdafruit_ST7789, TFT_eSPI
Tamanho do buffer de tela cheia153.600 bytes115.200 bytes (240×240)
C++ (Arduino IDE)
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}
A maioria dos módulos TFT SPI funciona com lógica de 3,3 V e não tem conversor de nível lógico na placa. Ligar diretamente os pinos de 5 V do Uno pode danificar o display com o tempo; coloque resistores em série ou um conversor de nível lógico no meio. Já os shields TFT de 2,4 polegadas que encaixam direto no Uno usam quase todos os pinos e não deixam espaço para outros módulos. O ESP32 e o Pico já trabalham em 3,3 V, então não têm esse problema.

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ísticaValor
Tamanhos comuns1,54" (200×200), 2,13" (250×122), 2,9" (296×128), 4,2" (400×300)
CorPreto e branco; modelos de três cores acrescentam vermelho ou amarelo (atualização de 10–15 segundos)
Tempo de atualização completaCerca de 1–3 segundos
Atualização parcial0,3–0,5 segundo nos modelos que suportam
Corrente em esperaPerto de zero enquanto mantém a imagem
Alimentação3,3 V (a maioria dos módulos aceita 5 V por meio de um regulador)

Displays de 7 segmentos e TM1637

Módulo display de 7 segmentos com 4 dígitos TM1637
Módulo de 7 segmentos com 4 dígitos TM1637: um display de relógio com dois-pontos no meio, ligado só com os fios CLK e DIO.

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.

C++ (Arduino IDE)
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

Módulo de LED matriz de pontos MAX7219 8x32
Módulo MAX7219 8×32 formado por quatro matrizes 8×8: ligado em cascata numa única linha CS para texto rolante, relógios e animações simples.

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:

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

DisplayBuffer completoArduino Uno (2 KB)ESP32 (520 KB) / Pico (264 KB)
LCD 16x2Não precisa (o display guarda)TranquiloTranquilo
OLED 128×641.024 bytesNo limite; modo de página (128 bytes) recomendadoTranquilo
OLED 128×32512 bytesTranquiloTranquilo
E-paper 296×1284.736 bytesSó desenhando página por páginaTranquilo
TFT ST7789 240×240115.200 bytesImpossível; desenha direto na telaPossível no ESP32, metade da RAM no Pico
TFT ILI9341 240×320153.600 bytesImpossível; desenha direto na telaPossí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?

ProjetoDisplay recomendadoPor quê?
Indicador de temperatura e umidadeLCD I2C 16x2 ou OLED de 0,96"Barato, dois fios, algumas linhas de texto bastam
Relógio digital e contagem regressivaTM1637 ou MAX7219Dígitos grandes e brilhantes; legíveis a distância
Jogo de bolso (Pong, cobrinha, T-Rex)OLED 128×64 ou matriz 8×8Atualização rápida, desenho no nível do pixel
Estação meteorológica (com bateria)E-paper + deep sleep do ESP32A imagem fica sem gastar energia e é legível sob o sol
Painel de controle colorido e menuILI9341 + touch, ou NextionCor, ícones e entrada por toque
Texto rolante e painel de mensagensMódulos MAX7219 em cascataVisível a metros de distância, cresce com um único CS
Dispositivo compacto com ESP32ST7789 de 1,14" ou 1,3"Pequeno, colorido e rápido via SPI

Erros comuns e como resolver

SintomaCausa provávelSolução
O LCD mostra só quadrados cheiosContraste não ajustado ou display não inicializadoGire 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 SSD1306Use o construtor SH1106 da U8g2 ou a biblioteca Adafruit SH110X
O sketch do OLED carrega, mas o Uno travaO buffer do display esgotou a RAMUse o modo de página da U8g2 e coloque os textos dentro de F()
O TFT fica totalmente brancoDriver errado, pinos errados ou sinal de 5 VConfirme o driver (ILI9341, ST7789), confira os pinos DC e CS e respeite o nível de 3,3 V
O e-paper nunca mudaPino BUSY não ligado ou modelo errado selecionadoLigue 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 resistorConfira o tipo do display e coloque um resistor em cada segmento
O MAX7219 acende LEDs aleatóriosFio solto, alimentação fraca ou sinal de 3,3 V no limiteEncurte os fios, reforce a alimentação de 5 V e, se preciso, adicione um conversor de nível lógico
Antes de ligar um display no seu projeto, rode o sketch de exemplo da própria biblioteca. Se o exemplo funciona e o seu não, o problema está no seu código; se o exemplo também não funciona, concentre-se na ligação, no endereço ou na escolha do driver. Esse único passo transforma horas de tentativa e erro em poucos minutos.

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.

Ver todos os projetos
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
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
Jogo de bola e raquetes - SSD1306
AR-86Intermediário
Premium

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.

4.5(47)
65
Corrida do T-Rex no OLED: jogo do dinossauro com Arduino
AR-87Avançado
Premium

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.

4.7(33)
53
ESP32 HTTPClient + API de clima (com display OLED SSD1306)
ES-32Avançado
Premium

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.

4.3(10)
22
Display TM1637 de 4 dígitos e 7 segmentos com ESP32
ES-23Intermediário
Premium

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.

4.7(20)
32
Relógio e calendário de matriz de LEDs (MAX7219, DS1307)
AR-84Intermediário
Premium

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.

5.0(37)
59
Relógio digital com display de 7 segmentos de 4 dígitos
AR-48Intermediário
Premium

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.

4.8(56)
73