Pantalla TFT 2.4 Arduino: shield táctil con MCUFRIEND_kbv y SD
Pantalla TFT 2.4 con Arduino: librería MCUFRIEND_kbv, ID del controlador, solución a la pantalla blanca, calibrar el táctil, botones, imágenes de la SD y pines.
La pantalla TFT 2.4 para Arduino en formato shield es una pantalla a color y táctil de 240×320 píxeles que se monta directamente sobre el Arduino Uno. No hay cables ni soldadura: la encajas en los pines del Uno o del Mega, instalas la librería correcta y en pocos minutos muestras textos de colores, figuras, botones táctiles e imágenes desde la tarjeta SD. Como es barata, aparece en muchísimos kits de inicio y proyectos escolares en toda Latinoamérica y España; por la misma razón, es una de las piezas por las que más se pregunta en los foros "¿por qué mi pantalla se queda en blanco?".
En esta guía vas a ver por qué la shield a veces muestra una pantalla blanca y cómo se resuelve con la librería MCUFRIEND_kbv. Vas a averiguar el ID del controlador, calibrar el panel táctil, corregir el táctil invertido, controlar un LED con botones en pantalla y mostrar imágenes desde una tarjeta microSD. También te contamos qué pines ocupa la shield, cuáles quedan libres y qué tener en cuenta con el Mega, el ESP32 y la Pico.

¿Qué es la shield TFT 2.4 y cómo funciona?
La shield tiene tres partes: el panel TFT a color, una capa táctil resistiva pegada encima y una ranura para tarjeta microSD en la parte de atrás. La pantalla no se conecta al Arduino por un bus serie como SPI, sino por un bus paralelo de 8 bits; como envía un byte completo cada vez, en el Uno dibuja más rápido que los módulos SPI, pero usa muchos pines. El controlador del panel trabaja a 3,3 V; gracias al regulador de 3,3 V y al adaptador de niveles tipo 74HC245 de la placa, las señales de 5 V del Uno se usan sin riesgo.
| Característica | Valor |
|---|---|
| Pantalla | TFT de 2,4 pulgadas, 240×320 píxeles |
| Color | 16 bits (RGB565), 65 536 colores |
| Interfaz | Paralela de 8 bits (D0–D7) + 5 líneas de control |
| Controlador | Varía: ILI9341, ILI9325, ST7781, SPFD5408, HX8347 y otros |
| Táctil | Resistivo de 4 hilos, comparte pines con la pantalla |
| Ranura SD | microSD, por SPI (D10–D13) |
| Alimentación | 5 V (con regulador de 3,3 V en la placa) |
| Consumo | Unos 80–120 mA, la mayor parte para la retroiluminación |
| Placas compatibles | Arduino Uno, Arduino Mega 2560 |
¿Shield o módulo SPI?
Se venden dos productos distintos del mismo tamaño y a los dos se les dice "TFT 2.4". La shield es el modelo paralelo que encajas sobre el Uno y listo. El módulo SPI es el que trae una sola fila de pines en el borde y se conecta con cables; su táctil suele leerse por SPI con el chip XPT2046. Esta guía trata de la shield; para el módulo SPI mira la guía de la pantalla TFT ILI9341.

| Característica | Shield 2.4" para Uno | Módulo SPI 2.4" |
|---|---|---|
| Conexión | Se monta sobre el Uno o el Mega, sin cables | 7 a 14 cables jumper |
| Pines que usa | D2–D9, A0–A4 (con SD, D10–D13) | 5 para la pantalla, 8–9 con táctil y SD |
| Velocidad de dibujo en el Uno | Rápida (paralelo) | Más lenta (SPI) |
| Librería | MCUFRIEND_kbv | Adafruit_ILI9341, TFT_eSPI |
| Lectura del táctil | Analógica, pines compartidos con la pantalla | Chip XPT2046, por SPI |
| ESP32 y Pico | No recomendable | Recomendable |
| Pines libres para sensores | Casi ninguno | Muchos |
Tabla de pines: ¿qué pines ocupa la shield?
| Pin de la shield | Pin del Arduino Uno | Función |
|---|---|---|
| LCD_RD | A0 | Señal de lectura |
| LCD_WR | A1 | Señal de escritura (puede compartirse con el táctil) |
| LCD_RS (CD) | A2 | ¿Comando o dato? (compartido con el táctil) |
| LCD_CS | A3 | Selección de la pantalla (puede compartirse con el táctil) |
| LCD_RST | A4 | Reset de la pantalla |
| LCD_D0, LCD_D1 | D8, D9 | Primeros dos bits del bus de datos |
| LCD_D2–LCD_D7 | D2–D7 | Los otros seis bits del bus de datos |
| SD_SS / SD_DI / SD_DO / SD_SCK | D10 / D11 / D12 / D13 | Tarjeta microSD (SPI) |
| 5V, 3V3, GND | 5V, 3.3V, GND | Alimentación |
Instalar la librería MCUFRIEND_kbv
- Abre el Gestor de librerías del Arduino IDE, busca MCUFRIEND_kbv e instálala.
- Desde el mismo lugar instala Adafruit GFX Library; de ahí salen las funciones de texto, líneas, círculos y botones.
- Para el táctil instala la librería Adafruit TouchScreen (en el código se incluye como TouchScreen.h).
- Para la tarjeta SD no hace falta instalar nada: la librería SD viene con el Arduino IDE.
¿Por qué MCUFRIEND_kbv? Aunque estas shields se ven iguales, por dentro pueden tener controladores distintos: de dos shields compradas al mismo vendedor con dos meses de diferencia, una puede traer ILI9341 y la otra ST7781. Las librerías viejas como Adafruit_TFTLCD o SPFD5408 solo reconocen unos pocos chips; si el chip no coincide, la pantalla nunca se inicializa y el resultado es la famosa pantalla blanca. MCUFRIEND_kbv primero le pregunta al chip su identificación y después le envía los comandos de arranque que le corresponden.
Averiguar el ID del controlador: readID()
Lo primero es preguntarle a tu shield quién es. El siguiente código escribe el ID en el monitor serie y en la pantalla, y después dibuja tres cuadros de colores. Pon el monitor serie a 9600 baudios.
1#include <Adafruit_GFX.h>
2#include <MCUFRIEND_kbv.h>
3
4MCUFRIEND_kbv tft;
5
6void setup() {
7 Serial.begin(9600);
8 uint16_t id = tft.readID(); // sürücü kimliğini oku / read the driver ID
9 Serial.print(F("TFT ID = 0x"));
10 Serial.println(id, HEX);
11 if (id == 0xD3D3) id = 0x9341; // salt yazılır shield: kimliği elle ver / write-only shield: set the ID by hand
12 tft.begin(id);
13 tft.setRotation(1); // yatay, 320x240 / landscape, 320x240
14 tft.fillScreen(0x0000); // siyah / black
15 tft.setTextColor(0xFFFF); // beyaz / white
16 tft.setTextSize(3);
17 tft.setCursor(20, 20);
18 tft.print(F("BlueGrays"));
19 tft.setTextSize(2);
20 tft.setCursor(20, 70);
21 tft.print(F("ID: 0x"));
22 tft.print(id, HEX);
23 tft.fillRect(20, 120, 80, 60, 0xF800); // kırmızı / red
24 tft.fillRect(120, 120, 80, 60, 0x07E0); // yeşil / green
25 tft.fillRect(220, 120, 80, 60, 0x001F); // mavi / blue
26}
27
28void loop() {
29}| ID leído | Controlador | ¿Qué hacer? |
|---|---|---|
| 0x9341 | ILI9341 | El modelo más común; funciona directo |
| 0x9325 / 0x9328 | ILI9325 / ILI9328 | Antiguo pero sin problemas; funciona directo |
| 0x7783 | ST7781 | Funciona directo |
| 0x5408 | SPFD5408 | Funciona directo; ya no necesitas la librería SPFD5408 |
| 0x4747 / 0x9595 | HX8347-D / HX8347-I | Funciona directo |
| 0x1505 / 0x0154 | R61505 / S6D0154 | Funciona directo |
| 0xD3D3 | Shield sin línea de lectura conectada | Escribe el ID a mano en el código; en 2,4" prueba primero 0x9341 |
| 0x0000 o 0xFFFF | No responde | La shield no está bien encajada, hay un pin doblado o la placa está dañada |
Si los cuadros salen rojo, verde y azul en ese orden, todo está bien. Si ves azul en lugar de rojo, probablemente escribiste el ID a mano y se enviaron comandos de arranque equivocados: usa el valor que encontró readID. Si los colores se ven como un negativo, agrega la línea tft.invertDisplay(true) después de begin. Si el ID sale con un valor raro, el ejemplo Archivo > Ejemplos > MCUFRIEND_kbv > LCD_ID_readreg vuelca todos los registros del chip; esa salida es la forma más rápida de entender el problema. El ejemplo graphictest_kbv, por su parte, prueba todas las funciones de la pantalla de una sola vez.
La pantalla blanca y otros errores de imagen
La pantalla blanca es en realidad una pista: la retroiluminación recibe energía, pero el controlador nunca se inicializó. Cuando el panel no recibe comandos, los píxeles dejan pasar la luz y todo se ve blanco. Revisa la tabla de arriba hacia abajo:
| Síntoma | Causa probable | Solución |
|---|---|---|
| Pantalla blanca usando una librería vieja | La librería no reconoce tu controlador | Instala MCUFRIEND_kbv e inicia con readID |
| Pantalla blanca e ID 0x0000 o 0xFFFF | La shield no está bien encajada o hay un pin doblado | Saca la shield, endereza los pines y presiónala hasta el fondo |
| Pantalla blanca e ID 0xD3D3 | No hay línea de lectura y no se obtiene el ID | Indica el ID a mano, como tft.begin(0x9341); si no funciona, prueba 0x9325 y 0x7783 |
| Colores en negativo (lo blanco se ve negro) | El ajuste de inversión del chip es distinto | tft.invertDisplay(true) después de begin |
| Rojo y azul intercambiados | El ID escrito a mano no coincide con el chip | Usa el ID que encuentra readID y actualiza la librería a la última versión |
| Textos en espejo | El ID escrito a mano no coincide con el panel | Obtén el ID con readID; revisa las cuatro orientaciones con el ejemplo aspect_kbv |
| La imagen se daña al tocar la pantalla | La lectura del táctil dejó los pines compartidos como entrada | Después de getPoint, vuelve a poner YP y XM como OUTPUT |
| Funciona en el Uno pero en el Mega queda blanca | La librería no conoce el mapeo de pines del Mega | MCUFRIEND_kbv sí reconoce el Mega; desinstala la librería vieja |
Calibrar el táctil
El panel táctil resistivo está formado por dos capas resistivas finas separadas por un pequeño espacio. Al presionar, las capas se tocan; la librería aplica voltaje a los extremos de una capa y lee con una entrada analógica el voltaje en la otra, y así obtiene la posición X e Y. Esas lecturas son números en bruto, más o menos entre 100 y 900, y cambian de un panel a otro; para convertirlas en píxeles hace falta calibrar. Además, el táctil usa los mismos pines que la pantalla, y cuáles cuatro pines van al táctil cambia de una shield a otra.
- Abre el ejemplo TouchScreen_Calibr_native desde Archivo > Ejemplos > MCUFRIEND_kbv y súbelo.
- Abre el monitor serie a 9600 baudios; el ejemplo primero detecta por sí solo los pines del táctil.
- Presiona en orden las cruces que aparecen en la pantalla y mantén el dedo o el lápiz en cada una hasta que cambie el texto.
- Al terminar, en el monitor serie aparecen dos líneas bajo el título "COPY-PASTE": const int XP=...,XM=...,YP=...,YM=... y const int TS_LEFT=...,TS_RT=...,TS_TOP=...,TS_BOT=....
- Pega esas dos líneas en lugar de los valores de ejemplo al inicio de los códigos siguientes.
1#include <Adafruit_GFX.h>
2#include <MCUFRIEND_kbv.h>
3#include <TouchScreen.h>
4
5MCUFRIEND_kbv tft;
6
7// Kalibrasyon örneğinin çıktısını buraya yapıştır / paste the calibration sketch output here
8const int XP = 6, XM = A2, YP = A1, YM = 7;
9const int TS_LEFT = 907, TS_RT = 136, TS_TOP = 942, TS_BOT = 139;
10
11TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300); // 300 ohm X plakası / 300 ohm X plate
12const int MINPRESSURE = 200;
13const int MAXPRESSURE = 1000;
14
15bool readTouch(int &x, int &y) {
16 TSPoint p = ts.getPoint();
17 pinMode(YP, OUTPUT); // ortak pinleri ekrana geri ver / give the shared pins back to the display
18 pinMode(XM, OUTPUT);
19 digitalWrite(YP, HIGH);
20 digitalWrite(XM, HIGH);
21 if (p.z < MINPRESSURE || p.z > MAXPRESSURE) return false;
22 x = map(p.x, TS_LEFT, TS_RT, 0, tft.width()); // dikey yön için / for portrait
23 y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());
24 return true;
25}
26
27void setup() {
28 tft.begin(tft.readID());
29 tft.setRotation(0); // dikey, kalibrasyonla aynı / portrait, same as calibration
30 tft.fillScreen(0x0000);
31 tft.fillRect(0, 0, 240, 30, 0x001F);
32 tft.setTextColor(0xFFFF);
33 tft.setTextSize(2);
34 tft.setCursor(10, 8);
35 tft.print(F("Ciz / Draw"));
36}
37
38void loop() {
39 int x, y;
40 if (readTouch(x, y)) {
41 if (y < 30) tft.fillRect(0, 30, 240, 290, 0x0000); // başlığa dokun: temizle / tap the header: clear
42 else tft.fillCircle(x, y, 3, 0xFFE0); // sarı nokta / yellow dot
43 }
44}Este pequeño programa de dibujo es la mejor forma de probar la calibración: el punto debe aparecer prácticamente debajo de tu dedo. p.z es la presión; si no está entre MINPRESSURE y MAXPRESSURE no cuenta como toque, así se descartan roces leves y el ruido eléctrico. Las líneas pinMode dentro de readTouch() son clave: al leer, la librería TouchScreen pone los pines compartidos como entradas analógicas y los deja así; sin esas líneas, los siguientes comandos de dibujo no llegan a la pantalla y la imagen se estropea. Un consejo: el panel resistivo funciona por presión, así que con la uña o un lápiz táctil dibujas con más precisión que con la yema del dedo.
| Síntoma | Causa | Solución |
|---|---|---|
| Toco a la derecha y el punto sale a la izquierda | Eje X invertido | Intercambia los valores de TS_LEFT y TS_RT |
| Toco arriba y el punto sale abajo | Eje Y invertido | Intercambia los valores de TS_TOP y TS_BOT |
| En horizontal se mezclan X e Y | Con setRotation(1) los ejes giraron | Usa p.y para x y p.x para y en map, o quédate en vertical |
| No detecta ningún toque | XP, XM, YP, YM incorrectos | Vuelve a correr el ejemplo de calibración y usa los pines que indica |
| Aparecen puntos sin tocar | Umbral de presión demasiado bajo | Sube MINPRESSURE a 300–400 |
| Los puntos salen corridos unos píxeles | La calibración se hizo con prisa | Recalibra presionando el centro exacto de cada cruz y por más tiempo |
Botones táctiles en pantalla
La clase Adafruit_GFX_Button de la librería Adafruit GFX dibuja botones con borde y texto en pocas líneas, y además calcula sola si el toque cayó sobre el botón. El siguiente código enciende y apaga con dos botones un LED conectado a A5; elegimos A5 porque es prácticamente el único pin que queda libre en el Uno con la shield puesta. No olvides conectar el LED con una resistencia de 220 Ω.
1#include <Adafruit_GFX.h>
2#include <MCUFRIEND_kbv.h>
3#include <TouchScreen.h>
4
5MCUFRIEND_kbv tft;
6const int XP = 6, XM = A2, YP = A1, YM = 7; // kendi değerlerin / your own values
7const int TS_LEFT = 907, TS_RT = 136, TS_TOP = 942, TS_BOT = 139;
8TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
9
10const int LED_PIN = A5; // shield'in boş bıraktığı pin / the pin the shield leaves unused
11Adafruit_GFX_Button onBtn, offBtn;
12char onLabel[] = "ON";
13char offLabel[] = "OFF";
14
15bool readTouch(int &x, int &y) {
16 TSPoint p = ts.getPoint();
17 pinMode(YP, OUTPUT);
18 pinMode(XM, OUTPUT);
19 digitalWrite(YP, HIGH);
20 digitalWrite(XM, HIGH);
21 if (p.z < 200 || p.z > 1000) return false;
22 x = map(p.x, TS_LEFT, TS_RT, 0, tft.width());
23 y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());
24 return true;
25}
26
27void showState(bool on) {
28 tft.fillRect(20, 40, 200, 60, on ? 0x07E0 : 0x7BEF); // yeşil ya da gri / green or grey
29 tft.setTextColor(0x0000);
30 tft.setTextSize(3);
31 tft.setCursor(50, 58);
32 tft.print(on ? F("LED ON") : F("LED OFF"));
33}
34
35void setup() {
36 pinMode(LED_PIN, OUTPUT);
37 tft.begin(tft.readID());
38 tft.setRotation(0);
39 tft.fillScreen(0x0000);
40 // merkez x, merkez y, genişlik, yükseklik, çerçeve, dolgu, yazı rengi, etiket, yazı boyu
41 // center x, center y, width, height, outline, fill, text colour, label, text size
42 onBtn.initButton(&tft, 120, 170, 160, 60, 0xFFFF, 0x07E0, 0x0000, onLabel, 3);
43 offBtn.initButton(&tft, 120, 260, 160, 60, 0xFFFF, 0xF800, 0xFFFF, offLabel, 3);
44 onBtn.drawButton();
45 offBtn.drawButton();
46 showState(false);
47}
48
49void loop() {
50 int x = 0, y = 0;
51 bool down = readTouch(x, y);
52 onBtn.press(down && onBtn.contains(x, y));
53 offBtn.press(down && offBtn.contains(x, y));
54 if (onBtn.justPressed()) {
55 onBtn.drawButton(true); // basılı görünüm / pressed look
56 digitalWrite(LED_PIN, HIGH);
57 showState(true);
58 }
59 if (offBtn.justPressed()) {
60 offBtn.drawButton(true);
61 digitalWrite(LED_PIN, LOW);
62 showState(false);
63 }
64 if (onBtn.justReleased()) onBtn.drawButton();
65 if (offBtn.justReleased()) offBtn.drawButton();
66 delay(20);
67}press() registra en cada vuelta si el botón está presionado en ese momento; justPressed() solo devuelve verdadero en la primera vuelta en que se presiona y justReleased() solo en la vuelta en que se suelta. Así, mientras el dedo sigue sobre el botón, no se le manda la orden al LED una y otra vez ni se redibuja la pantalla sin necesidad. drawButton(true) invierte los colores del botón para que se vea presionado. Si en vez del LED conectas un módulo relé a A5, puedes manejar una lámpara desde la pantalla táctil; para conectarlo con seguridad, revisa la guía del módulo relé.
Mostrar imágenes desde la tarjeta SD
La ranura microSD de la parte trasera es la forma más fácil de mostrar imágenes a todo color. En tu computadora ajusta la imagen a 240×320 (vertical) y guárdala como BMP de 24 bits: en Paint basta con elegir "Mapa de bits de 24 bits" y en GIMP la opción de 24 bits al exportar. Usa un nombre de archivo de 8 caracteres como máximo (por ejemplo GATO.BMP), porque la librería SD trabaja con nombres cortos, y cambia en el código "KEDI.BMP" por el nombre de tu archivo. Formatea la tarjeta en FAT32 o FAT16; las tarjetas de más de 32 GB suelen venir en exFAT y no se reconocen.
1#include <SPI.h>
2#include <SD.h>
3#include <Adafruit_GFX.h>
4#include <MCUFRIEND_kbv.h>
5
6MCUFRIEND_kbv tft;
7const int SD_CS = 10; // shield üzerindeki SD seçme pini / SD chip select on the shield
8const byte CHUNK = 20; // tek seferde okunan piksel / pixels read per step (az RAM / low RAM)
9
10uint16_t read16(File &f) { uint16_t v; f.read((uint8_t *)&v, 2); return v; }
11uint32_t read32(File &f) { uint32_t v; f.read((uint8_t *)&v, 4); return v; }
12
13bool drawBMP(const char *name, int x, int y) {
14 File bmp = SD.open(name);
15 if (!bmp) return false;
16 if (read16(bmp) != 0x4D42) { bmp.close(); return false; } // "BM" imzası / "BM" signature
17 read32(bmp); read32(bmp); // dosya boyutu, ayrılmış / file size, reserved
18 uint32_t offset = read32(bmp); // piksel verisinin başı / start of pixel data
19 read32(bmp); // başlık boyutu / header size
20 int32_t w = read32(bmp);
21 int32_t h = read32(bmp);
22 if (read16(bmp) != 1 || read16(bmp) != 24 || read32(bmp) != 0) { // 1 düzlem, 24 bit, sıkıştırmasız / 1 plane, 24-bit, uncompressed
23 bmp.close();
24 return false;
25 }
26 bool bottomUp = true; // BMP satırları alttan üste / BMP rows are bottom-up
27 if (h < 0) { h = -h; bottomUp = false; }
28 uint32_t rowSize = (w * 3 + 3) & ~3UL; // satır 4 bayta tamamlanır / rows padded to 4 bytes
29 uint8_t raw[CHUNK * 3];
30 uint16_t px[CHUNK];
31 for (int32_t row = 0; row < h; row++) {
32 bmp.seek(offset + (bottomUp ? (h - 1 - row) : row) * rowSize);
33 tft.setAddrWindow(x, y + row, x + w - 1, y + row); // tek satırlık pencere / one-row window
34 bool first = true;
35 for (int32_t col = 0; col < w; col += CHUNK) {
36 int n = (w - col < CHUNK) ? (w - col) : CHUNK;
37 bmp.read(raw, n * 3);
38 for (int i = 0; i < n; i++) {
39 px[i] = tft.color565(raw[i * 3 + 2], raw[i * 3 + 1], raw[i * 3]); // BGR -> RGB565
40 }
41 tft.pushColors(px, n, first);
42 first = false;
43 }
44 }
45 tft.setAddrWindow(0, 0, tft.width() - 1, tft.height() - 1); // pencereyi sıfırla / reset the window
46 bmp.close();
47 return true;
48}
49
50void setup() {
51 Serial.begin(9600);
52 tft.begin(tft.readID());
53 tft.setRotation(0); // dikey, 240x320 / portrait, 240x320
54 tft.fillScreen(0x0000);
55 if (!SD.begin(SD_CS)) {
56 Serial.println(F("SD kart yok / no SD card"));
57 return;
58 }
59 if (!drawBMP("KEDI.BMP", 0, 0)) {
60 Serial.println(F("BMP okunamadi / BMP not readable"));
61 }
62}
63
64void loop() {
65}En un archivo BMP las filas se guardan de abajo hacia arriba y el largo de cada fila se completa hasta un múltiplo de 4 bytes; el código resuelve esos dos detalles con el cálculo de rowSize y la bandera bottomUp. Cada píxel ocupa 3 bytes en el orden azul, verde, rojo, y color565() lo convierte al color de 16 bits que entiende la pantalla. Como el Uno solo tiene 2 KB de RAM y la librería SD se queda con 512 bytes para su búfer, leemos los píxeles de 20 en 20. En el Uno, una imagen de pantalla completa se dibuja fila por fila en unos pocos segundos. Para el formato de la tarjeta y el manejo de archivos, revisa la guía del módulo de tarjeta SD.
Usarla con el Arduino Mega
La shield encaja en los mismos conectores del Mega y, como MCUFRIEND_kbv reconoce el Mega, los códigos de pantalla y táctil funcionan sin cambios. La gran ventaja está en los pines: quedan libres D22–D53, A5–A15, tres puertos serie adicionales y el I2C de D20–D21, así que para proyectos grandes con sensores y pantalla el Mega es la opción más cómoda. El único problema es la ranura SD: la shield conecta la SD a D10–D13, pero el SPI por hardware del Mega está en D50–D53, por eso SD.begin() falla. La solución es usar la librería SdFat con SPI por software sobre D10–D13; el ejemplo showBMP_not_Uno de MCUFRIEND_kbv lo muestra listo para usar. Para todos los pines del Mega, revisa la guía de pines del Arduino Mega.
¿Se puede usar con ESP32 o Raspberry Pi Pico?
Respuesta corta: no es recomendable. La shield paralela espera 13 pines y un conector tipo Uno compatible con 5 V. En las placas ESP32 con formato Uno (ESPDuino-32, D1 R32 y similares), los conectores A2–A4 suelen ir a los GPIO 34–36, que solo pueden ser entradas; las líneas de control de la pantalla no se pueden manejar desde ahí y el táctil tampoco encuentra pines adecuados para la lectura analógica. Hay quien la hace funcionar recableando y con la configuración paralela de TFT_eSPI, pero es un trabajo engorroso. Para el ESP32 y la Pico tiene mucho más sentido el módulo SPI de la misma resolución: se conecta con cuatro o cinco cables y deja libres la mayoría de los pines. Tienes los detalles en las guías de la pantalla TFT ILI9341 y, para una opción más pequeña y nítida, de la pantalla TFT ST7789.
Ideas de proyectos con la pantalla TFT 2.4
- Calculadora táctil: dibuja una cuadrícula de botones de 4×4 y muestra el resultado con letra grande; la lógica es la misma que en la guía de la calculadora con Arduino.
- Marco de fotos digital: muestra en orden los archivos BMP de la tarjeta SD y pasa al siguiente al tocar la pantalla.
- Cerradura con clave: dibuja un teclado numérico en pantalla y activa el relé de A5 con la clave correcta; para la lógica de teclas mira la guía del teclado matricial (keypad).
- Juegos: Pong, la viborita o un gato (tres en raya) táctil; tienes ideas en proyectos de juegos con Arduino.
- Gráfica de temperatura: conecta un DHT11 al Mega y muestra la temperatura de la última hora en una gráfica de línea que se desplaza.
- Osciloscopio sencillo: dibuja como una onda la señal leída en A5; para señales lentas es una herramienta divertida para aprender.
La pantalla TFT 2.4 en formato shield funciona en minutos con la librería correcta y, gracias al táctil, le da a tus proyectos una interfaz de verdad. Si prefieres empezar con pantallas usando un modelo más sencillo, en la app BlueGrays encontrarás paso a paso, con diagrama y código, los proyectos de LCD I2C, texto que se desplaza en un LCD 2x16, los juegos Pong y T-Rex en OLED y el juego de carreras en LCD.
Preguntas frecuentes
¿Por qué mi pantalla TFT 2.4 se queda en blanco?
La pantalla blanca indica que la retroiluminación está encendida pero el controlador no se inicializó. La causa más común es que la librería que usas no reconoce el chip de tu shield. Instalar MCUFRIEND_kbv, leer el ID con tft.readID() e iniciar con tft.begin(ID) lo resuelve casi siempre; si el ID sale 0x0000, la shield no está bien encajada.
¿Qué librería se usa para la pantalla TFT 2.4 de Arduino?
Para la pantalla, MCUFRIEND_kbv junto con Adafruit GFX Library; para el táctil, Adafruit TouchScreen; y para la tarjeta SD, la librería SD que ya trae el Arduino IDE. Las librerías antiguas SPFD5408 y Adafruit_TFTLCD solo admiten unos pocos chips, por eso en las shields nuevas suelen dar pantalla blanca.
¿Cómo sé qué controlador tiene mi pantalla TFT?
Con MCUFRIEND_kbv llama a tft.readID() e imprime el resultado en el monitor serie: 0x9341 es ILI9341, 0x9325 es ILI9325 y 0x7783 es ST7781. El ejemplo LCD_ID_readreg de la librería vuelca todos los registros del chip y da información más detallada.
¿La pantalla TFT 2.4 funciona con Arduino Mega?
Sí, la shield también encaja en el Mega y MCUFRIEND_kbv lo reconoce. Lo único que no funciona directo es la ranura SD, porque los pines SPI del Mega están en D50–D53; para la SD tienes que usar la librería SdFat con SPI por software. A cambio ganas muchísimos pines libres.
¿Cómo calibro el táctil de la pantalla TFT 2.4?
Sube el ejemplo TouchScreen_Calibr_native de MCUFRIEND_kbv, presiona las cruces que aparecen y copia las dos líneas que salen en el monitor serie a tu código. Si el táctil queda invertido de izquierda a derecha, intercambia TS_LEFT y TS_RT; si queda invertido de arriba abajo, intercambia TS_TOP y TS_BOT.
¿Qué pines quedan libres con la shield TFT puesta?
En el Uno solo quedan A5, D0–D1 (compartidos con la carga por USB) y D10–D13 si no usas la tarjeta SD. Como A4 es el reset de la pantalla, no puedes usar I2C. Si quieres conectar más sensores, conviene un Arduino Mega o un módulo TFT con interfaz SPI.
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…

Texto que rebota de izquierda a derecha en LCD
En la fila de arriba de la pantalla LCD, la palabra BLUEGRAYS se desliza de un borde a otro y rebota como una pelota contra la pared, una y otra vez sin parar.

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.

Juego Arduino LCD Runner
Juego endless runner de desplazamiento lateral que se ejecuta en una pantalla LCD de 16x2 caracteres. El héroe corre automáticamente, el jugador salta los obstáculos pulsando el botón. Aparecen obstáculos aleatorios en las filas superior e inferior. El zumbador pasivo reproduce la melodía de apertura, el sonido de salto, el sonido de celebración de 50 puntos y la melodía de fin de partida. La pantalla de inicio "BlueGrays - Arduino Projects" se muestra al arrancar.

Calculadora Arduino I2C
Se trata de un proyecto de calculadora basado en Arduino que realiza operaciones de suma, resta, multiplicación y división utilizando un teclado de membrana 4x4 y una pantalla LCD 16x2 I2C. Gracias a I2C, la conexión de la pantalla se realiza con sólo 2 cables, reduciendo así el desorden de cables y manteniendo más pines abiertos para su uso. También dispone de entrada de números decimales y soporte de números negativos.

Cerradura con contraseña, teclado 4x4 y LCD
Una pequeña cerradura electrónica que no deja pasar a quien no sepa la clave. Pulsas la tecla de almohadilla y escribes la clave en el teclado; si es correcta, la pantalla indica acceso permitido, se…
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

