Guías · 11 min de lectura

Tipos de pantallas para Arduino: LCD, OLED, TFT, e-paper y más

Pantallas para Arduino comparadas: LCD 16x2, OLED, TFT, e-paper, TM1637, MAX7219 y Nextion; resolución, pines, memoria, consumo y cuál elegir en cada proyecto.

Los tipos de pantallas para Arduino confunden al principio: la misma palabra "pantalla" sirve para un LCD de 16 caracteres, una OLED del tamaño de una uña, una TFT a color como la de un móvil y un e-paper que conserva la imagen aunque se corte la corriente. Cada una cambia muchísimo en resolución, color, forma de conexión, memoria y energía. Una mala elección acaba en un Uno sin RAM, un indicador que no se lee al sol o un sensor que agota su batería en un día.

En esta guía repasamos una a una las siete familias de pantallas más usadas en proyectos con Arduino: LCD de caracteres (16x2 y 20x4), OLED (SSD1306 y SH1106), TFT a color (ILI9341 y ST7789), e-paper, 7 segmentos y TM1637, matrices LED MAX7219 y pantallas táctiles Nextion. Primero verás una gran tabla comparativa, luego una presentación breve y un código de ejemplo que funciona para cada pantalla, y al final una tabla de "qué pantalla para qué proyecto" y los errores más frecuentes.

Pantalla LCD 16x2 con adaptador I2C
LCD de caracteres 16x2 con adaptador I2C: la pantalla más barata y fácil de leer para Arduino, conectada con solo dos cables de datos.

Tipos de pantallas para Arduino: tabla comparativa rápida

PantallaResoluciónColorInterfazPines de datosCorriente típicaPrecio
LCD de caracteres 16x2 / 20x416×2 o 20×4 caracteresMonocromo, retroiluminadoParalelo o adaptador I2C6 (paralelo) / 2 (I2C)20–40 mAMuy barato
OLED SSD1306 / SH1106128×64 (0,96" y 1,3")Monocromo (blanco, azul, amarillo-azul)I2C o SPI2 (I2C) / 5 (SPI)10–25 mABarato
TFT ILI9341240×320 (2,4–3,2")65 mil coloresSPI o paralelo de 8 bits5 (SPI)50–100 mAMedio
TFT ST7789240×240, 240×320, 135×24065 mil coloresSPI4–530–80 mAMedio
E-paper (e-ink)200×200, 296×128, 250×122Blanco y negro (algunas rojo/amarillo)SPI6 (con BUSY)5–20 mA solo al refrescarMedio-alto
7 segmentos / TM16371–8 dígitosLED de un colorDirecto o 2 cables (TM1637)8–12 / 220–80 mAMuy barato
Matriz LED MAX72198×8, encadenada 32×8 o másLED de un color3 cables (tipo SPI)320–300 mA según el brilloBarato
Nextion HMIDe 320×240 a 800×48065 mil colores, táctilUART (TX/RX)290–500 mACaro

El número de "pines de datos" de la tabla no incluye la alimentación (VCC y GND). Las corrientes cambian mucho con la retroiluminación y el brillo; el e-paper solo consume mientras cambia la imagen y luego casi nada. Los precios están ordenados unos respecto a otros: por lo que cuesta una Nextion puedes comprar unas diez LCD 16x2.

En qué fijarte al elegir una pantalla

  • ¿Qué vas a mostrar? Solo números: 7 segmentos; unas líneas de texto: LCD de caracteres; gráficos e iconos: OLED; interfaz a color o fotos: TFT.
  • ¿Dónde se va a leer? El e-paper y el LCD se leen bien al sol; la OLED y la TFT sufren con luz fuerte. En la oscuridad, en cambio, el negro de una OLED es negro de verdad y no cansa la vista.
  • ¿Cuántos pines tienes libres? Las pantallas I2C se apañan con dos cables; un LCD en paralelo necesita seis, una TFT SPI cinco y un e-paper seis. Para las cuentas de pines, mira los artículos de I2C y SPI.
  • ¿Le basta la memoria a tu placa? Los 2 KB de RAM del Uno apenas dan para el búfer de una OLED y nunca para el de una TFT a color. En el ESP32 y la Pico esto casi no es problema.
  • ¿Va a funcionar con pilas? El e-paper, que mantiene la imagen sin gastar energía, no tiene rival para sensores que funcionan durante meses.
  • Nivel de tensión: la mayoría de los módulos TFT y e-paper usan lógica de 3,3 V; con un Uno puede hacer falta un conversor de nivel.
  • Soporte de librerías: las pantallas que funcionan con librerías populares como Adafruit GFX, U8g2, TFT_eSPI y LiquidCrystal_I2C facilitan muchísimo encontrar ejemplos y resolver problemas.

LCD de caracteres: 16x2 y 20x4

Los LCD de caracteres con controlador HD44780 son la pantalla clásica de Arduino. Cada carácter está formado por 5×8 puntos; el modelo 16x2 muestra 2 líneas de 16 caracteres y el 20x4, 4 líneas de 20. Como el propio controlador de la pantalla guarda la imagen, apenas gasta RAM en el Arduino. Con conexión directa necesita 6 pines (RS, E y D4–D7) y un potenciómetro para el contraste; explicamos este método en el artículo Conexión en paralelo del LCD 16x2. Con un adaptador I2C basado en el PCF8574 soldado detrás, bastan SDA y SCL. Puedes definir hasta 8 caracteres propios para dibujar el símbolo de grado, un icono de batería o letras con tilde. Tienes el uso detallado en el artículo Pantalla 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}
Si un LCD I2C no muestra nada, gira primero el potenciómetro azul de contraste de la parte trasera del adaptador; muchas veces viene mal ajustado de fábrica. Si sigue en blanco, la dirección puede ser 0x3F en lugar de 0x27; un sketch escáner I2C te da la dirección correcta en segundos.

OLED: SSD1306 y SH1106

Pantalla OLED I2C de 0,96 pulgadas
OLED I2C de 0,96 pulgadas: 128×64 píxeles que generan su propia luz y solo 4 pines de conexión.

En las pantallas OLED cada píxel produce su propia luz; no hay retroiluminación, el contraste es altísimo y la imagen se ve nítida desde cualquier ángulo. Los modelos de 0,96 pulgadas suelen llevar el controlador SSD1306 y los de 1,3 pulgadas, casi siempre, el SH1106. Por fuera son iguales, pero la memoria interna del SH1106 tiene 132 columnas; si manejas un SH1106 con una librería para SSD1306, la imagen se desplaza dos píxeles y aparece una franja con ruido en el borde. La solución es elegir la librería o el constructor adecuados para el controlador. La librería U8g2 admite los dos y, gracias al modo por páginas, puede funcionar en el Uno con un búfer de solo 128 bytes. Tienes lo básico del SSD1306 en el artículo Pantalla OLED (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}

El _1_ del nombre del constructor significa que la pantalla se dibuja en páginas de 8 filas: el bucle de firstPage() y nextPage() repite el mismo dibujo ocho veces y en cada una envía una franja de la pantalla. Es algo más lento, pero usa 128 bytes de RAM en lugar de 1 KB. En el ESP32 y la Pico, donde sobra memoria, puedes elegir la versión _F_ con búfer completo y conseguir animaciones más fluidas.

TFT a color: ILI9341 y ST7789

Módulo de pantalla TFT a color ILI9341
TFT a color de 2,8 pulgadas con controlador ILI9341: 240×320 píxeles, 65 mil colores y conexión SPI; algunos modelos también traen panel táctil y ranura para tarjeta SD.

Si quieres gráficos, menús, iconos e indicadores a color, pasas a las pantallas TFT. Cada píxel lleva color de 16 bits (RGB565), es decir, unos 65 mil colores. Los dos controladores más comunes son el ILI9341 y el ST7789. El ILI9341 se usa en pantallas de 240×320 de 2,4 a 3,2 pulgadas y muchas veces viene con un controlador táctil XPT2046. El ST7789 aparece en pantallas cuadradas de 1,3 y 1,54 pulgadas (240×240) y en las de 135×240 de placas como la TTGO T-Display. Funcionan con el Uno, pero despacio: incluso pintar una vez toda la pantalla tarda un tiempo visible. En el ESP32 se consiguen interfaces fluidas con SPI a 40 MHz y librerías optimizadas como TFT_eSPI. Tienes los detalles en los artículos Pantalla TFT ILI9341 y Pantalla TFT ST7789.

CaracterísticaILI9341ST7789
Tamaños habituales2,4", 2,8", 3,2"1,14", 1,3", 1,54", 2,0"
Resolución240×320135×240, 240×240, 240×320
InterfazSPI (las versiones shield para Uno usan paralelo de 8 bits)SPI (algunos modelos sin pin CS)
TáctilTáctil resistivo XPT2046 en la mayoría de modelosNormalmente no
LibreríaAdafruit_ILI9341, TFT_eSPIAdafruit_ST7789, TFT_eSPI
Tamaño del búfer de pantalla completa153.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}
La mayoría de los módulos TFT SPI trabajan con lógica de 3,3 V y no llevan conversor de nivel. Conectar directamente los pines de 5 V del Uno puede dañar la pantalla con el tiempo; pon resistencias en serie o un conversor de nivel entre medias. Los shields TFT de 2,4 pulgadas que se pinchan directamente en el Uno ocupan casi todos los pines y no dejan sitio para otros módulos. El ESP32 y la Pico trabajan a 3,3 V de serie, así que no tienen este problema.

Pantallas e-paper (e-ink)

El e-paper es la tecnología de pantalla de los lectores de libros electrónicos. Forma la imagen moviendo diminutas cápsulas de pigmento blanco y negro con un campo eléctrico; una vez dibujada, la imagen se queda en la pantalla aunque se corte la corriente. Por eso, junto con el modo deep sleep del ESP32, es ideal para estaciones que se despiertan una vez por hora, actualizan el tiempo y funcionan meses con pilas. Como parece papel, se lee perfectamente al sol. El inconveniente es la velocidad: un refresco completo tarda unos 2 segundos y la pantalla parpadea varias veces; en los modelos con refresco parcial baja a menos de medio segundo, pero los refrescos parciales frecuentes pueden dejar marcas tenues. Se conecta por SPI y necesita MOSI, SCK, CS, DC, RST y un pin BUSY que avisa de que la pantalla está ocupada. La librería más usada es GxEPD2.

CaracterísticaValor
Tamaños habituales1,54" (200×200), 2,13" (250×122), 2,9" (296×128), 4,2" (400×300)
ColorBlanco y negro; los modelos de tres colores añaden rojo o amarillo (refresco de 10–15 segundos)
Tiempo de refresco completoUnos 1–3 segundos
Refresco parcial0,3–0,5 segundos en los modelos que lo admiten
Corriente en reposoCasi cero mientras mantiene la imagen
Alimentación3,3 V (la mayoría de los módulos aceptan 5 V gracias a un regulador)

Displays de 7 segmentos y TM1637

Módulo display de 7 segmentos TM1637 de 4 dígitos
Módulo TM1637 de 4 dígitos con 7 segmentos: un display de reloj con dos puntos en el centro, conectado solo con los cables CLK y DIO.

Si solo necesitas mostrar números, los displays de 7 segmentos siguen siendo la opción más legible: grandes, brillantes y visibles a varios metros. Un display de un dígito necesita 8 pines para los 7 segmentos y el punto, y una resistencia por segmento; uno de 4 dígitos multiplexado usa 12 pines. Explicamos este cableado y la diferencia entre ánodo común y cátodo común en el artículo Display de 7 segmentos. La forma más fácil de librarte del problema de pines es el módulo TM1637: conectas el display de 4 dígitos, que lleva su propio controlador, solo con CLK y DIO y ajustas el brillo por software en 8 niveles. Aunque el protocolo del TM1637 se parece al I2C, no usa direcciones; por eso puede ir en dos pines digitales cualesquiera y cada módulo necesita su propio par de pines.

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 LED MAX7219

Módulo de matriz de puntos LED MAX7219 8x32
Módulo MAX7219 de 8×32 formado por cuatro matrices de 8×8: se encadena con una sola línea CS para texto deslizante, relojes y animaciones sencillas.

El MAX7219 es un integrado que controla por sí solo 64 LED (una matriz de 8×8 o un display de 7 segmentos de 8 dígitos) y se comunica por tres cables, DIN, CLK y CS, con un protocolo parecido a SPI. Los módulos se pueden encadenar; con los habituales módulos de 4 en 1 se hacen paneles de texto deslizante de 32×8, y con dos filas, de 32×16. Su brillo y su legibilidad a distancia lo hacen ideal para paneles de mensajes, marcadores y relojes. En Arduino se usan sobre todo las librerías MD_Parola y MD_MAX72XX; tienes los detalles en el artículo Matriz LED MAX7219. Abajo controlamos una sola matriz de 8×8 con una Raspberry Pi Pico sin librería, escribiendo directamente en los registros:

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)

Para que sus LED brillen con fuerza, el MAX7219 necesita 5 V; por eso el VCC del módulo va al pin VBUS de la Pico. Según la hoja de datos, con alimentación de 5 V las entradas necesitan al menos 3,5 V para considerarse HIGH; las señales de 3,3 V de la Pico funcionan sin problemas en la mayoría de los módulos, pero si ves inestabilidad, añade un conversor de nivel en las líneas DIN, CLK y CS. La corriente sube con el brillo y con el número de LED encendidos: con los cuatro módulos encendidos por completo a máximo brillo se pueden consumir cientos de miliamperios.

Pantallas táctiles HMI Nextion

Nextion es una pantalla táctil inteligente con su propio procesador y memoria. Diseñas la interfaz con botones, deslizadores e indicadores en el ordenador con Nextion Editor arrastrando y soltando, y la cargas en la pantalla; el Arduino solo envía por el puerto serie (UART) órdenes cortas como t0.txt="25" y lee los eventos táctiles. Así todo el trabajo de dibujo recae en la pantalla, e incluso una placa pequeña como el Uno puede manejar una interfaz a color de 7 pulgadas. La velocidad por defecto es de 9600 baudios. Los inconvenientes son el precio, un consumo de 90 mA incluso en el modelo de 2,4 pulgadas y de hasta 500 mA en el de 7, y que el diseño se hace en un programa aparte. En el Uno el puerto serie por hardware se comparte con el USB, así que usar SoftwareSerial o elegir placas con varios puertos serie, como el Mega y el ESP32, facilita las cosas.

Memoria necesaria: ¿qué pantalla cabe en un Uno?

La mayoría de las librerías de pantallas gráficas dibujan primero la imagen en un búfer en la RAM y después la envían entera a la pantalla. Tamaño del búfer = ancho × alto × bits por píxel / 8. Si recuerdas que el Arduino Uno solo tiene 2 KB de RAM y que parte se va en variables, el puerto serie y las librerías, el límite salta a la vista enseguida. Hemos reunido las soluciones generales a los problemas de memoria en el artículo Arduino sin memoria suficiente.

PantallaBúfer completoArduino Uno (2 KB)ESP32 (520 KB) / Pico (264 KB)
LCD 16x2No hace falta (la pantalla lo guarda)Sin problemaSin problema
OLED 128×641.024 bytesJusto; se recomienda el modo por páginas (128 bytes)Sin problema
OLED 128×32512 bytesSin problemaSin problema
E-paper 296×1284.736 bytesSolo dibujando página a páginaSin problema
TFT ST7789 240×240115.200 bytesImposible; se dibuja directamente en la pantallaPosible en el ESP32, la mitad de la RAM en la Pico
TFT ILI9341 240×320153.600 bytesImposible; se dibuja directamente en la pantallaPosible, aunque se suelen preferir sprites pequeños

Consumo y uso con pilas

En un proyecto con pilas, la pantalla gasta a menudo más energía que el microcontrolador. Solo la retroiluminación de un LCD 16x2 puede consumir más de 20 mA; si la apagas (lcd.noBacklight()), la pantalla se sigue leyendo al sol pero no en la oscuridad. La corriente de una OLED es proporcional a los píxeles encendidos: un texto blanco fino sobre fondo negro gasta varias veces menos que un fondo blanco. En las TFT los LED de retroiluminación están siempre encendidos; controlar el pin de retroiluminación con un transistor o con PWM ahorra mucho. El e-paper casi no consume mientras no cambies la imagen. Para calcular la duración de las pilas puedes usar el método del artículo sobre mAh.

¿Qué pantalla para qué proyecto?

ProyectoPantalla recomendada¿Por qué?
Indicador de temperatura y humedadLCD 16x2 I2C u OLED de 0,96"Barato, dos cables, bastan unas líneas de texto
Reloj digital y cuenta atrásTM1637 o MAX7219Dígitos grandes y brillantes; se leen de lejos
Juego de bolsillo (Pong, serpiente, T-Rex)OLED 128×64 o matriz 8×8Refresco rápido, dibujo a nivel de píxel
Estación meteorológica (con pilas)E-paper + deep sleep del ESP32La imagen se mantiene sin gastar energía, se lee al sol
Panel de control y menú a colorILI9341 con táctil o NextionColor, iconos y entrada táctil
Texto deslizante y panel de mensajesMódulos MAX7219 encadenadosSe ve a metros de distancia, crece con un solo CS
Dispositivo compacto con ESP32ST7789 de 1,14" o 1,3"Pequeña, a color y rápida por SPI

Errores frecuentes y soluciones

SíntomaCausa probableSolución
El LCD solo muestra cuadros llenosContraste sin ajustar o pantalla sin iniciarGira el potenciómetro de contraste, revisa la dirección y la llamada a lcd.init()
Imagen desplazada y ruido en el borde en una OLED de 1,3"Una pantalla SH1106 manejada con una librería para SSD1306Usa el constructor SH1106 de U8g2 o la librería Adafruit SH110X
El sketch de la OLED se sube pero el Uno se cuelgaEl búfer de pantalla ha agotado la RAMUsa el modo por páginas de U8g2, mete los textos en F()
La TFT se queda en blancoControlador equivocado, pines equivocados o señal de 5 VConfirma el controlador (ILI9341, ST7789), revisa los pines DC y CS, cuida el nivel de 3,3 V
El e-paper nunca cambiaPin BUSY sin conectar o modelo equivocadoConecta BUSY y elige en GxEPD2 la clase exacta de tu panel
Algunos segmentos del display de 7 segmentos se ven tenuesÁnodo común y cátodo común confundidos o falta una resistenciaComprueba el tipo de display, pon una resistencia en cada segmento
El MAX7219 enciende LED al azarCable flojo, alimentación débil o señal de 3,3 V en el límiteAcorta los cables, refuerza la alimentación de 5 V, añade un conversor de nivel si hace falta
Antes de meter una pantalla en tu proyecto, ejecuta el ejemplo de la propia librería. Si el ejemplo funciona y tu código no, el problema está en tu código; si el ejemplo tampoco funciona, céntrate en el cableado, la dirección o el controlador elegido. Este simple paso convierte horas de prueba y error en unos minutos.

La pantalla adecuada depende de lo que muestre tu proyecto, de dónde se lea y de con qué se alimente: LCD para texto, OLED para gráficos pequeños, TFT o Nextion para interfaces a color, e-paper para equipos con pilas, y 7 segmentos y MAX7219 para dígitos grandes. En la app BlueGrays encontrarás proyectos con LCD I2C, juegos y pantalla del tiempo en OLED, reloj con TM1637 y matriz de puntos MAX7219, paso a paso con esquemas de circuito y código.

Preguntas frecuentes

¿Cuál es la mejor pantalla para Arduino?

No hay una única mejor pantalla; la elección depende del proyecto. Para unas líneas de texto va bien un LCD 16x2 I2C, para gráficos pequeños una OLED de 0,96 pulgadas, para una interfaz a color una TFT ILI9341 y para equipos con pilas un e-paper.

¿Qué es mejor, OLED o LCD?

La OLED es más nítida, tiene mucho contraste, puede dibujar gráficos y se lee perfectamente a oscuras. El LCD de caracteres es más barato, se lee mejor al sol y apenas gasta RAM en el Arduino.

¿Puede un Arduino Uno manejar una pantalla TFT a color?

Sí, las TFT SPI como la ILI9341 o la ST7789 funcionan con el Uno, pero como no hay RAM para un búfer de pantalla completa, se dibuja directamente en la pantalla y despacio. Para interfaces a color fluidas es mejor un ESP32 o una Raspberry Pi Pico.

¿Qué diferencia hay entre el SSD1306 y el SH1106?

Los dos son controladores para OLED de 128×64; el SSD1306 suele ir en pantallas de 0,96 pulgadas y el SH1106 en las de 1,3. Como la memoria del SH1106 tiene 132 columnas, la imagen se desplaza si se usa con una librería para SSD1306; hace falta una librería adecuada como U8g2 o Adafruit SH110X.

¿Una pantalla e-paper conserva la imagen sin corriente?

Sí. El e-paper forma la imagen moviendo cápsulas de pigmento y, una vez dibujada, la imagen se queda en la pantalla sin energía. Por eso es ideal para equipos con pilas que se actualizan una vez por hora.

¿El TM1637 es I2C?

No. El protocolo de dos cables del TM1637 se parece al I2C, pero no usa direcciones y no va en un bus I2C. Se conecta a dos pines digitales cualesquiera y se controla con su propia librería (por ejemplo, TM1637Display); varios módulos necesitan cada uno su propio par de pines.

Ver todos los proyectos
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

Uso de la pantalla LCD con I2C

Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

4.8(53)
70
Mostrar un mensaje en una pantalla LCD 2x16
AR-29Avanzado
Premium

Mostrar un mensaje en una pantalla LCD 2x16

Tu primer paso para escribir texto en una pantalla. La pantalla LCD de dos líneas muestra primero un mensaje de espera, luego escribe un saludo en la línea de arriba y teclea una palabra letra a…

4.6(37)
51
Juego de Raquetas - SSD1306
AR-86Intermedio
Premium

Juego de Raquetas - SSD1306

Una pelota, dos palas y tú: juegas al tenis de mesa, uno de los primeros videojuegos de la historia, en una pequeña pantalla OLED.

4.5(47)
65
OLED T-Rex Run: Juego del dinosaurio con Arduino
AR-87Avanzado
Premium

OLED T-Rex Run: Juego del dinosaurio con Arduino

El juego del dinosaurio que aparece cuando se va internet, ahora en tu mesa: el dinosaurio corre por la pequeña pantalla OLED, los cactus se le echan encima y tú saltas con un solo botón.

4.7(33)
53
ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
ES-32Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.

4.3(10)
22
ESP32 TM1637 Pantalla de 4 dígitos y 7 segmentos
ES-23Intermedio
Premium

ESP32 TM1637 Pantalla de 4 dígitos y 7 segmentos

Controlamos el módulo de pantalla de 7 segmentos y 4 dígitos con controlador TM1637 mediante un ESP32. Utilizando solo 2 GPIO (CLK y DIO), hacemos funcionar un contador de 0 a 9999, ajustamos el nivel de brillo y mostramos el carácter de dos puntos (:) en el centro en formato de reloj. Gracias a la biblioteca TM1637Display, el control de números, hexadecimales, segmentos y cadenas es muy sencillo.

4.7(20)
32
Reloj y calendario de matriz de puntos (MAX7219, DS1307)
AR-84Intermedio
Premium

Reloj y calendario de matriz de puntos (MAX7219, DS1307)

Un panel luminoso para tu mesa o tu pared que muestra la hora y la fecha con texto en movimiento.

5.0(37)
59
Reloj digital con display de 7 segmentos de 4 dígitos
AR-48Intermedio
Premium

Reloj digital con display de 7 segmentos de 4 dígitos

Un reloj digital luminoso de cuatro cifras, parecido al del horno de la cocina. El módulo de reloj DS1302 guarda la hora y cada segundo el Arduino lee las horas y los minutos y los muestra en el…

4.8(56)
73