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.

Tipos de pantallas para Arduino: tabla comparativa rápida
| Pantalla | Resolución | Color | Interfaz | Pines de datos | Corriente típica | Precio |
|---|---|---|---|---|---|---|
| LCD de caracteres 16x2 / 20x4 | 16×2 o 20×4 caracteres | Monocromo, retroiluminado | Paralelo o adaptador I2C | 6 (paralelo) / 2 (I2C) | 20–40 mA | Muy barato |
| OLED SSD1306 / SH1106 | 128×64 (0,96" y 1,3") | Monocromo (blanco, azul, amarillo-azul) | I2C o SPI | 2 (I2C) / 5 (SPI) | 10–25 mA | Barato |
| TFT ILI9341 | 240×320 (2,4–3,2") | 65 mil colores | SPI o paralelo de 8 bits | 5 (SPI) | 50–100 mA | Medio |
| TFT ST7789 | 240×240, 240×320, 135×240 | 65 mil colores | SPI | 4–5 | 30–80 mA | Medio |
| E-paper (e-ink) | 200×200, 296×128, 250×122 | Blanco y negro (algunas rojo/amarillo) | SPI | 6 (con BUSY) | 5–20 mA solo al refrescar | Medio-alto |
| 7 segmentos / TM1637 | 1–8 dígitos | LED de un color | Directo o 2 cables (TM1637) | 8–12 / 2 | 20–80 mA | Muy barato |
| Matriz LED MAX7219 | 8×8, encadenada 32×8 o más | LED de un color | 3 cables (tipo SPI) | 3 | 20–300 mA según el brillo | Barato |
| Nextion HMI | De 320×240 a 800×480 | 65 mil colores, táctil | UART (TX/RX) | 2 | 90–500 mA | Caro |
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.
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 y SH1106

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

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ística | ILI9341 | ST7789 |
|---|---|---|
| Tamaños habituales | 2,4", 2,8", 3,2" | 1,14", 1,3", 1,54", 2,0" |
| Resolución | 240×320 | 135×240, 240×240, 240×320 |
| Interfaz | SPI (las versiones shield para Uno usan paralelo de 8 bits) | SPI (algunos modelos sin pin CS) |
| Táctil | Táctil resistivo XPT2046 en la mayoría de modelos | Normalmente no |
| Librería | Adafruit_ILI9341, TFT_eSPI | Adafruit_ST7789, TFT_eSPI |
| Tamaño del búfer de pantalla completa | 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}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ística | Valor |
|---|---|
| Tamaños habituales | 1,54" (200×200), 2,13" (250×122), 2,9" (296×128), 4,2" (400×300) |
| Color | Blanco y negro; los modelos de tres colores añaden rojo o amarillo (refresco de 10–15 segundos) |
| Tiempo de refresco completo | Unos 1–3 segundos |
| Refresco parcial | 0,3–0,5 segundos en los modelos que lo admiten |
| Corriente en reposo | Casi cero mientras mantiene la imagen |
| Alimentación | 3,3 V (la mayoría de los módulos aceptan 5 V gracias a un regulador) |
Displays de 7 segmentos y TM1637

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

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:
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.
| Pantalla | Búfer completo | Arduino Uno (2 KB) | ESP32 (520 KB) / Pico (264 KB) |
|---|---|---|---|
| LCD 16x2 | No hace falta (la pantalla lo guarda) | Sin problema | Sin problema |
| OLED 128×64 | 1.024 bytes | Justo; se recomienda el modo por páginas (128 bytes) | Sin problema |
| OLED 128×32 | 512 bytes | Sin problema | Sin problema |
| E-paper 296×128 | 4.736 bytes | Solo dibujando página a página | Sin problema |
| TFT ST7789 240×240 | 115.200 bytes | Imposible; se dibuja directamente en la pantalla | Posible en el ESP32, la mitad de la RAM en la Pico |
| TFT ILI9341 240×320 | 153.600 bytes | Imposible; se dibuja directamente en la pantalla | Posible, 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?
| Proyecto | Pantalla recomendada | ¿Por qué? |
|---|---|---|
| Indicador de temperatura y humedad | LCD 16x2 I2C u OLED de 0,96" | Barato, dos cables, bastan unas líneas de texto |
| Reloj digital y cuenta atrás | TM1637 o MAX7219 | Dígitos grandes y brillantes; se leen de lejos |
| Juego de bolsillo (Pong, serpiente, T-Rex) | OLED 128×64 o matriz 8×8 | Refresco rápido, dibujo a nivel de píxel |
| Estación meteorológica (con pilas) | E-paper + deep sleep del ESP32 | La imagen se mantiene sin gastar energía, se lee al sol |
| Panel de control y menú a color | ILI9341 con táctil o Nextion | Color, iconos y entrada táctil |
| Texto deslizante y panel de mensajes | Módulos MAX7219 encadenados | Se ve a metros de distancia, crece con un solo CS |
| Dispositivo compacto con ESP32 | ST7789 de 1,14" o 1,3" | Pequeña, a color y rápida por SPI |
Errores frecuentes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| El LCD solo muestra cuadros llenos | Contraste sin ajustar o pantalla sin iniciar | Gira 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 SSD1306 | Usa el constructor SH1106 de U8g2 o la librería Adafruit SH110X |
| El sketch de la OLED se sube pero el Uno se cuelga | El búfer de pantalla ha agotado la RAM | Usa el modo por páginas de U8g2, mete los textos en F() |
| La TFT se queda en blanco | Controlador equivocado, pines equivocados o señal de 5 V | Confirma el controlador (ILI9341, ST7789), revisa los pines DC y CS, cuida el nivel de 3,3 V |
| El e-paper nunca cambia | Pin BUSY sin conectar o modelo equivocado | Conecta 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 resistencia | Comprueba el tipo de display, pon una resistencia en cada segmento |
| El MAX7219 enciende LED al azar | Cable flojo, alimentación débil o señal de 3,3 V en el límite | Acorta los cables, refuerza la alimentación de 5 V, añade un conversor de nivel si hace falta |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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…

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.

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.

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.

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.

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.

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…
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

