Componentes · 11 min de lectura

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.

Placa Arduino Uno
La shield TFT 2.4 se monta sobre esta placa y ocupa casi todos sus pines; solo quedan A5, D0–D1 y, si no usas la SD, D10–D13.

¿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ísticaValor
PantallaTFT de 2,4 pulgadas, 240×320 píxeles
Color16 bits (RGB565), 65 536 colores
InterfazParalela de 8 bits (D0–D7) + 5 líneas de control
ControladorVaría: ILI9341, ILI9325, ST7781, SPFD5408, HX8347 y otros
TáctilResistivo de 4 hilos, comparte pines con la pantalla
Ranura SDmicroSD, por SPI (D10–D13)
Alimentación5 V (con regulador de 3,3 V en la placa)
ConsumoUnos 80–120 mA, la mayor parte para la retroiluminación
Placas compatiblesArduino 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.

Módulo de pantalla TFT ILI9341 con interfaz SPI
La "hermana" de la shield: el módulo SPI se conecta con cables mediante una fila de pines y funciona mucho mejor con el ESP32 y la Pico.
CaracterísticaShield 2.4" para UnoMódulo SPI 2.4"
ConexiónSe monta sobre el Uno o el Mega, sin cables7 a 14 cables jumper
Pines que usaD2–D9, A0–A4 (con SD, D10–D13)5 para la pantalla, 8–9 con táctil y SD
Velocidad de dibujo en el UnoRápida (paralelo)Más lenta (SPI)
LibreríaMCUFRIEND_kbvAdafruit_ILI9341, TFT_eSPI
Lectura del táctilAnalógica, pines compartidos con la pantallaChip XPT2046, por SPI
ESP32 y PicoNo recomendableRecomendable
Pines libres para sensoresCasi ningunoMuchos

Tabla de pines: ¿qué pines ocupa la shield?

Pin de la shieldPin del Arduino UnoFunción
LCD_RDA0Señal de lectura
LCD_WRA1Señal de escritura (puede compartirse con el táctil)
LCD_RS (CD)A2¿Comando o dato? (compartido con el táctil)
LCD_CSA3Selección de la pantalla (puede compartirse con el táctil)
LCD_RSTA4Reset de la pantalla
LCD_D0, LCD_D1D8, D9Primeros dos bits del bus de datos
LCD_D2–LCD_D7D2–D7Los otros seis bits del bus de datos
SD_SS / SD_DI / SD_DO / SD_SCKD10 / D11 / D12 / D13Tarjeta microSD (SPI)
5V, 3V3, GND5V, 3.3V, GNDAlimentación
Con la shield puesta, al Uno casi no le quedan pines para sensores. Como A4 es la línea de reset de la pantalla, el I2C de A4/A5 no se puede usar: no podrás agregar sensores ni pantallas I2C. Quedan libres A5 (en la mayoría de las shields no está conectado), D0–D1, que se comparten con la carga por USB, y D10–D13 si no usas la tarjeta SD. Si necesitas más sensores, monta la shield en un Arduino Mega o pásate al módulo SPI.

Instalar la librería MCUFRIEND_kbv

  1. Abre el Gestor de librerías del Arduino IDE, busca MCUFRIEND_kbv e instálala.
  2. Desde el mismo lugar instala Adafruit GFX Library; de ahí salen las funciones de texto, líneas, círculos y botones.
  3. Para el táctil instala la librería Adafruit TouchScreen (en el código se incluye como TouchScreen.h).
  4. 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.

C++ (Arduino IDE)
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ídoControlador¿Qué hacer?
0x9341ILI9341El modelo más común; funciona directo
0x9325 / 0x9328ILI9325 / ILI9328Antiguo pero sin problemas; funciona directo
0x7783ST7781Funciona directo
0x5408SPFD5408Funciona directo; ya no necesitas la librería SPFD5408
0x4747 / 0x9595HX8347-D / HX8347-IFunciona directo
0x1505 / 0x0154R61505 / S6D0154Funciona directo
0xD3D3Shield sin línea de lectura conectadaEscribe el ID a mano en el código; en 2,4" prueba primero 0x9341
0x0000 o 0xFFFFNo respondeLa 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íntomaCausa probableSolución
Pantalla blanca usando una librería viejaLa librería no reconoce tu controladorInstala MCUFRIEND_kbv e inicia con readID
Pantalla blanca e ID 0x0000 o 0xFFFFLa shield no está bien encajada o hay un pin dobladoSaca la shield, endereza los pines y presiónala hasta el fondo
Pantalla blanca e ID 0xD3D3No hay línea de lectura y no se obtiene el IDIndica 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 distintotft.invertDisplay(true) después de begin
Rojo y azul intercambiadosEl ID escrito a mano no coincide con el chipUsa el ID que encuentra readID y actualiza la librería a la última versión
Textos en espejoEl ID escrito a mano no coincide con el panelObtén el ID con readID; revisa las cuatro orientaciones con el ejemplo aspect_kbv
La imagen se daña al tocar la pantallaLa lectura del táctil dejó los pines compartidos como entradaDespués de getPoint, vuelve a poner YP y XM como OUTPUT
Funciona en el Uno pero en el Mega queda blancaLa librería no conoce el mapeo de pines del MegaMCUFRIEND_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.

  1. Abre el ejemplo TouchScreen_Calibr_native desde Archivo > Ejemplos > MCUFRIEND_kbv y súbelo.
  2. Abre el monitor serie a 9600 baudios; el ejemplo primero detecta por sí solo los pines del táctil.
  3. 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.
  4. 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=....
  5. Pega esas dos líneas en lugar de los valores de ejemplo al inicio de los códigos siguientes.
C++ (Arduino IDE)
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íntomaCausaSolución
Toco a la derecha y el punto sale a la izquierdaEje X invertidoIntercambia los valores de TS_LEFT y TS_RT
Toco arriba y el punto sale abajoEje Y invertidoIntercambia los valores de TS_TOP y TS_BOT
En horizontal se mezclan X e YCon setRotation(1) los ejes giraronUsa p.y para x y p.x para y en map, o quédate en vertical
No detecta ningún toqueXP, XM, YP, YM incorrectosVuelve a correr el ejemplo de calibración y usa los pines que indica
Aparecen puntos sin tocarUmbral de presión demasiado bajoSube MINPRESSURE a 300–400
Los puntos salen corridos unos píxelesLa calibración se hizo con prisaRecalibra 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 Ω.

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

C++ (Arduino IDE)
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.
Si la pantalla parpadea, no borres toda la pantalla con fillScreen() en cada vuelta: limpia con fillRect() solo la zona que cambia y vuelve a escribir. Poner los textos fijos dentro de F() ahorra RAM. Para que el fondo de los números se borre solo cuando cambian, usa la forma setTextColor(texto, fondo).

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.

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
Texto que rebota de izquierda a derecha en LCD
AR-30Avanzado
Premium

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.

4.5(29)
40
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
Juego Arduino LCD Runner
AR-96Intermedio
Premium

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.

4.6(32)
56
Calculadora Arduino I2C
AR-94Intermedio
Premium

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.

5.0(31)
43
Cerradura con contraseña, teclado 4x4 y LCD
AR-64Avanzado
Premium

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…

4.8(59)
75