Display TFT 2.4 Arduino: shield touch con MCUFRIEND_kbv e SD
Display TFT 2.4 su Arduino: MCUFRIEND_kbv, ID del controller, soluzione allo schermo bianco, calibrazione del touch, pulsanti, immagini BMP dalla SD e pin.
Il display TFT 2.4 per Arduino in formato shield è uno schermo a colori touch da 240×320 pixel che si innesta direttamente sull'Arduino Uno. Niente cavi né saldature: appoggi lo shield sui connettori di Uno o Mega, installi la libreria giusta e in pochi minuti mostri testi colorati, forme, pulsanti touch e immagini dalla scheda SD. Visto che costa poco, si trova in tantissimi kit per principianti e progetti scolastici; per lo stesso motivo è uno dei componenti su cui nei forum si chiede più spesso "perché il mio schermo resta bianco?".
In questa guida vedrai perché a volte lo shield mostra solo uno schermo bianco e come la libreria MCUFRIEND_kbv risolve il problema. Leggerai l'ID del controller, calibrerai il pannello touch, correggerai un touch invertito, comanderai un LED con pulsanti sullo schermo e mostrerai immagini da una scheda microSD. Vedremo anche quali pin occupa lo shield, quali restano disponibili e a cosa fare attenzione con Mega, ESP32 e Pico.

Cos'è lo shield TFT da 2,4" e come funziona?
Sullo shield ci sono tre parti: il pannello TFT a colori, uno strato touch resistivo incollato sopra e uno slot per scheda microSD sul retro. Il display non si collega ad Arduino con un bus seriale come l'SPI, ma con un bus parallelo a 8 bit; dato che invia un byte intero alla volta, su Uno disegna più velocemente dei moduli SPI, ma occupa molti pin. Il controller del pannello lavora a 3,3 V; grazie al regolatore da 3,3 V e al traslatore di livello tipo 74HC245 sulla scheda, i segnali a 5 V di Uno si usano senza rischi.
| Caratteristica | Valore |
|---|---|
| Schermo | TFT da 2,4 pollici, 240×320 pixel |
| Colori | 16 bit (RGB565), 65.536 colori |
| Interfaccia | Parallela a 8 bit (D0–D7) + 5 linee di controllo |
| Controller | Varia: ILI9341, ILI9325, ST7781, SPFD5408, HX8347 e altri |
| Touch | Resistivo a 4 fili, condivide i pin con il display |
| Slot SD | microSD in SPI (D10–D13) |
| Alimentazione | 5 V (regolatore da 3,3 V sulla scheda) |
| Assorbimento | Circa 80–120 mA, quasi tutti per la retroilluminazione |
| Schede compatibili | Arduino Uno, Arduino Mega 2560 |
Shield o modulo SPI?
In commercio ci sono due prodotti diversi della stessa misura e tutti e due vengono chiamati "TFT 2.4". Lo shield è il modello parallelo che innesti su Uno e funziona subito. Il modulo SPI ha una sola fila di pin su un lato e si collega con i cavetti; il suo touch di solito si legge in SPI con un chip XPT2046. Questa guida parla dello shield; per il modulo SPI leggi la guida al display TFT ILI9341.

| Caratteristica | Shield 2,4" per Uno | Modulo SPI 2,4" |
|---|---|---|
| Collegamento | Si innesta su Uno o Mega, senza cavi | Da 7 a 14 cavetti jumper |
| Pin usati | D2–D9, A0–A4 (con la SD D10–D13) | 5 per il display, 8–9 con touch e SD |
| Velocità di disegno su Uno | Alta (parallelo) | Più bassa (SPI) |
| Libreria | MCUFRIEND_kbv | Adafruit_ILI9341, TFT_eSPI |
| Lettura del touch | Analogica, pin condivisi con il display | Chip XPT2046 in SPI |
| ESP32 e Pico | Sconsigliato | Adatto |
| Pin disponibili per sensori | Quasi nessuno | Molti |
Tabella dei pin: quali pin usa lo shield?
| Pin dello shield | Pin di Arduino Uno | Funzione |
|---|---|---|
| LCD_RD | A0 | Segnale di lettura |
| LCD_WR | A1 | Segnale di scrittura (a volte condiviso con il touch) |
| LCD_RS (CD) | A2 | Comando o dato? (condiviso con il touch) |
| LCD_CS | A3 | Selezione del display (a volte condiviso con il touch) |
| LCD_RST | A4 | Reset del display |
| LCD_D0, LCD_D1 | D8, D9 | Primi due bit del bus dati |
| LCD_D2–LCD_D7 | D2–D7 | Altri sei bit del bus dati |
| SD_SS / SD_DI / SD_DO / SD_SCK | D10 / D11 / D12 / D13 | Scheda microSD (SPI) |
| 5V, 3V3, GND | 5V, 3.3V, GND | Alimentazione |
Installare la libreria MCUFRIEND_kbv
- Apri il Gestore librerie dell'Arduino IDE, cerca MCUFRIEND_kbv e installala.
- Dallo stesso punto installa Adafruit GFX Library; da lì arrivano le funzioni per testo, linee, cerchi e pulsanti.
- Per il touch installa la libreria Adafruit TouchScreen (nel codice si include come TouchScreen.h).
- Per la scheda SD non serve installare nulla: la libreria SD è già inclusa nell'Arduino IDE.
Perché MCUFRIEND_kbv? Questi shield sembrano tutti uguali, ma dentro possono avere controller diversi: di due shield comprati dallo stesso venditore a due mesi di distanza, uno può montare un ILI9341 e l'altro un ST7781. Le librerie più vecchie come Adafruit_TFTLCD o SPFD5408 conoscono solo pochi chip; se il chip non corrisponde, il display non viene mai inizializzato e il risultato è il famoso schermo bianco. MCUFRIEND_kbv chiede prima al chip il suo ID e poi gli invia i comandi di avvio adatti.
Trovare l'ID del controller: readID()
Per prima cosa chiedi al tuo shield chi è. Il codice seguente scrive l'ID nel monitor seriale e sullo schermo, poi disegna tre riquadri colorati. Imposta il monitor seriale a 9600 baud.
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 letto | Chip | Cosa fare |
|---|---|---|
| 0x9341 | ILI9341 | Il modello più diffuso; funziona subito |
| 0x9325 / 0x9328 | ILI9325 / ILI9328 | Vecchio ma senza problemi; funziona subito |
| 0x7783 | ST7781 | Funziona subito |
| 0x5408 | SPFD5408 | Funziona subito; non serve più la vecchia libreria SPFD5408 |
| 0x4747 / 0x9595 | HX8347-D / HX8347-I | Funziona subito |
| 0x1505 / 0x0154 | R61505 / S6D0154 | Funziona subito |
| 0xD3D3 | Shield senza linea di lettura collegata | Scrivi l'ID a mano nel codice; sui 2,4" prova prima 0x9341 |
| 0x0000 o 0xFFFF | Nessuna risposta | Shield non inserito bene, pin piegato o scheda guasta |
Se i riquadri escono rosso, verde e blu in quest'ordine, è tutto a posto. Se vedi blu al posto del rosso, probabilmente hai impostato l'ID a mano e sono partiti i comandi di avvio sbagliati: usa il valore trovato da readID. Se i colori sembrano un negativo, aggiungi la riga tft.invertDisplay(true) dopo begin. Se l'ID ha un valore strano, l'esempio File > Esempi > MCUFRIEND_kbv > LCD_ID_readreg stampa tutti i registri del chip; quell'output è il modo più rapido per capire il problema. L'esempio graphictest_kbv invece prova tutte le funzioni del display in un colpo solo.
Lo schermo bianco e gli altri difetti di visualizzazione
Lo schermo bianco in realtà è un indizio: la retroilluminazione è alimentata, ma il controller non è mai stato inizializzato. Quando il pannello non riceve comandi, i pixel lasciano passare la luce e tutto appare bianco. Controlla la tabella dall'alto in basso:
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Schermo bianco con una libreria vecchia | La libreria non conosce il tuo chip | Installa MCUFRIEND_kbv e avvia con readID |
| Schermo bianco, ID 0x0000 o 0xFFFF | Shield non inserito bene o pin piegato | Togli lo shield, raddrizza i pin e spingilo fino in fondo |
| Schermo bianco, ID 0xD3D3 | Manca la linea di lettura, l'ID non si legge | Imposta l'ID a mano, per esempio tft.begin(0x9341); altrimenti prova 0x9325 e 0x7783 |
| Colori in negativo (il bianco sembra nero) | L'inversione del chip è impostata diversamente | tft.invertDisplay(true) dopo begin |
| Rosso e blu scambiati | L'ID impostato a mano non corrisponde al chip | Usa l'ID trovato da readID e aggiorna la libreria all'ultima versione |
| Testo a specchio | L'ID impostato a mano non corrisponde al pannello | Ricava l'ID con readID; controlla i quattro orientamenti con l'esempio aspect_kbv |
| L'immagine si rovina quando tocchi lo schermo | La lettura del touch ha lasciato i pin condivisi come ingressi | Dopo getPoint rimetti YP e XM in OUTPUT |
| Funziona su Uno ma su Mega resta bianco | La libreria non conosce la mappatura dei pin del Mega | MCUFRIEND_kbv supporta il Mega; disinstalla la libreria vecchia |
Calibrare il touch
Un pannello touch resistivo è fatto di due sottili strati resistivi separati da un piccolissimo spazio. Quando premi, gli strati si toccano; la libreria applica una tensione ai capi di uno strato e legge con un ingresso analogico la tensione sull'altro, e così ottiene la posizione X e Y. Queste letture grezze vanno all'incirca da 100 a 900 e cambiano da un pannello all'altro; per trasformarle in pixel serve una calibrazione. Inoltre il touch usa gli stessi pin del display, e quali quattro pin vanno al touch cambia da shield a shield.
- Apri l'esempio TouchScreen_Calibr_native da File > Esempi > MCUFRIEND_kbv e caricalo.
- Apri il monitor seriale a 9600 baud; l'esempio per prima cosa trova da solo i pin del touch.
- Premi una dopo l'altra le croci che compaiono sullo schermo, tenendo il dito o il pennino su ognuna finché il testo non cambia.
- Alla fine nel monitor seriale compaiono due righe sotto il titolo "COPY-PASTE": const int XP=...,XM=...,YP=...,YM=... e const int TS_LEFT=...,TS_RT=...,TS_TOP=...,TS_BOT=....
- Incolla queste due righe al posto dei valori di esempio all'inizio degli sketch seguenti.
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}Questo piccolo programma di disegno è il miglior test per la calibrazione: il punto deve comparire quasi esattamente sotto il dito. p.z è la pressione; se non è tra MINPRESSURE e MAXPRESSURE non conta come tocco, così vengono scartati sfioramenti e disturbi elettrici. Le righe pinMode dentro readTouch() sono fondamentali: durante la lettura la libreria TouchScreen trasforma i pin condivisi in ingressi analogici e li lascia così; senza queste righe i comandi di disegno successivi non arrivano al display e l'immagine si rovina. Un consiglio: il pannello resistivo funziona a pressione, quindi con l'unghia o un pennino disegni con più precisione che con il polpastrello.
| Sintomo | Causa | Soluzione |
|---|---|---|
| Tocco a destra e il punto compare a sinistra | Asse X invertito | Scambia i valori di TS_LEFT e TS_RT |
| Tocco in alto e il punto compare in basso | Asse Y invertito | Scambia i valori di TS_TOP e TS_BOT |
| In orizzontale X e Y si mescolano | Con setRotation(1) gli assi sono ruotati | Usa p.y per x e p.x per y in map, oppure resta in verticale |
| Nessun tocco rilevato | XP, XM, YP, YM sbagliati | Esegui di nuovo l'esempio di calibrazione e usa i pin che indica |
| Compaiono punti senza toccare | Soglia di pressione troppo bassa | Alza MINPRESSURE a 300–400 |
| I punti sono spostati di qualche pixel | Calibrazione fatta di fretta | Ricalibra premendo più a lungo il centro esatto di ogni croce |
Un'interfaccia con pulsanti touch
La classe Adafruit_GFX_Button della libreria Adafruit GFX disegna in poche righe pulsanti con bordo e scritta e calcola da sola se il tocco è caduto sul pulsante. Il codice seguente accende e spegne con due pulsanti un LED collegato ad A5; abbiamo scelto A5 perché, con lo shield montato, è praticamente l'unico pin libero di Uno. Non dimenticare la resistenza da 220 Ω in serie al LED.
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 a ogni giro se il pulsante è premuto in quel momento; justPressed() restituisce vero solo al primo giro della pressione e justReleased() solo al giro in cui lo lasci. Così, finché il dito resta sul pulsante, il LED non riceve lo stesso comando all'infinito e lo schermo non viene ridisegnato inutilmente. drawButton(true) inverte i colori del pulsante per dargli l'aspetto premuto. Se al posto del LED colleghi un modulo relè ad A5, puoi comandare una lampada dal touchscreen; per un collegamento sicuro leggi la guida al modulo relè.
Mostrare immagini dalla scheda SD
Lo slot microSD sul retro è il modo più semplice per mostrare immagini a colori. Sul computer porta l'immagine a 240×320 (verticale) e salvala come BMP a 24 bit: in Paint scegli "Bitmap a 24 bit", in GIMP l'opzione a 24 bit durante l'esportazione. Usa un nome file di massimo 8 caratteri (per esempio GATTO.BMP), perché la libreria SD lavora con nomi brevi, e sostituisci "KEDI.BMP" nel codice con il nome del tuo file. Formatta la scheda in FAT32 o FAT16; le schede oltre i 32 GB di solito sono in exFAT e non vengono riconosciute.
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}In un file BMP le righe sono salvate dal basso verso l'alto e la lunghezza di ogni riga viene completata fino a un multiplo di 4 byte; il codice gestisce entrambi i dettagli con il calcolo di rowSize e il flag bottomUp. Ogni pixel occupa 3 byte nell'ordine blu, verde, rosso, e color565() lo converte nel colore a 16 bit che il display capisce. Dato che Uno ha solo 2 KB di RAM e la libreria SD ne tiene 512 byte per il suo buffer, leggiamo i pixel a gruppi di 20. Su Uno un'immagine a schermo intero si disegna riga per riga in pochi secondi. Per la formattazione della scheda e la gestione dei file, leggi la guida al modulo scheda SD.
Usarlo con Arduino Mega
Lo shield si innesta nella stessa posizione sui connettori del Mega e, dato che MCUFRIEND_kbv riconosce il Mega, il codice di display e touch funziona senza modifiche. Il grande vantaggio sono i pin: D22–D53, A5–A15, tre porte seriali in più e l'I2C su D20–D21 restano liberi, per cui il Mega è la scelta più comoda per progetti grandi con sensori e display. L'unico problema è lo slot SD: lo shield collega la SD a D10–D13, ma l'SPI hardware del Mega è su D50–D53, quindi SD.begin() fallisce. La soluzione è usare la libreria SdFat con SPI software su D10–D13; l'esempio showBMP_not_Uno di MCUFRIEND_kbv lo mostra già pronto. Per tutti i pin del Mega, leggi la guida alla piedinatura di Arduino Mega.
Si può usare con ESP32 o Raspberry Pi Pico?
In breve: è sconsigliato. Lo shield parallelo richiede 13 pin e un connettore in formato Uno compatibile con i 5 V. Sulle schede ESP32 in formato Uno (ESPDuino-32, D1 R32 e simili) i connettori A2–A4 vanno quasi sempre ai GPIO 34–36, che possono essere solo ingressi; le linee di controllo del display non si possono pilotare da lì e il touch non trova pin adatti alle letture analogiche. C'è chi lo fa funzionare ricablando e con la configurazione parallela di TFT_eSPI, ma è un lavoro scomodo. Per ESP32 e Pico ha molto più senso un modulo SPI con la stessa risoluzione: si collega con quattro o cinque cavi e lascia liberi quasi tutti i pin. Trovi i dettagli nelle guide al display TFT ILI9341 e, per un'alternativa più piccola e più nitida, al display TFT ST7789.
Idee di progetti con il display TFT 2.4
- Calcolatrice touch: disegna una griglia di 4×4 pulsanti e mostra il risultato a caratteri grandi; la logica è la stessa della guida alla calcolatrice con Arduino.
- Cornice digitale: mostra in sequenza i file BMP della scheda SD e passa al successivo quando tocchi lo schermo.
- Serratura a combinazione: disegna un tastierino numerico sullo schermo e attiva il relè su A5 con il codice giusto; per la logica dei tasti leggi la guida al tastierino a matrice (keypad).
- Giochi: Pong, Snake o un tris touch; trovi idee nei progetti di giochi con Arduino.
- Grafico della temperatura: collega un DHT11 al Mega e mostra la temperatura dell'ultima ora con un grafico a linea che scorre.
- Oscilloscopio semplice: disegna come un'onda il segnale letto su A5; per i segnali lenti è uno strumento divertente per imparare.
Con la libreria giusta, il display TFT 2.4 in formato shield funziona in pochi minuti e, grazie al touch, dà ai tuoi progetti una vera interfaccia. Se preferisci iniziare con un display più semplice, nell'app BlueGrays trovi passo dopo passo, con schema e codice, i progetti LCD I2C, testo scorrevole su LCD 2x16, i giochi Pong e T-Rex su OLED e un gioco di corsa su LCD.
Domande frequenti
Perché il mio display TFT 2.4 resta bianco?
Lo schermo bianco indica che la retroilluminazione è accesa ma il controller non è stato inizializzato. La causa più comune è che la libreria che usi non riconosce il chip del tuo shield. Installare MCUFRIEND_kbv, leggere l'ID con tft.readID() e avviare con tft.begin(ID) risolve quasi sempre; se l'ID risulta 0x0000, lo shield non è inserito bene.
Quale libreria usare per il display TFT 2.4 di Arduino?
Per il display MCUFRIEND_kbv insieme ad Adafruit GFX Library, per il touch Adafruit TouchScreen e per la scheda la libreria SD inclusa nell'Arduino IDE. Le vecchie librerie SPFD5408 e Adafruit_TFTLCD supportano solo pochi chip, per questo sugli shield più recenti danno spesso lo schermo bianco.
Come capisco quale controller ha il mio display TFT?
Con MCUFRIEND_kbv chiama tft.readID() e stampa il risultato nel monitor seriale: 0x9341 indica ILI9341, 0x9325 ILI9325 e 0x7783 ST7781. L'esempio LCD_ID_readreg della libreria stampa anche tutti i registri del chip per informazioni più dettagliate.
Il display TFT 2.4 funziona con Arduino Mega?
Sì, lo shield si innesta anche sul Mega e MCUFRIEND_kbv lo supporta. Solo lo slot SD non funziona subito, perché i pin SPI del Mega sono su D50–D53; per la scheda SD serve la libreria SdFat con SPI software. In cambio guadagni tantissimi pin liberi.
Come correggo il touch invertito del display TFT 2.4?
Esegui di nuovo l'esempio TouchScreen_Calibr_native e copia nel codice i valori che stampa. Se destra e sinistra sono invertite, scambia TS_LEFT e TS_RT; se lo sono alto e basso, scambia TS_TOP e TS_BOT. Se in orizzontale gli assi si mescolano, usa p.y per x e p.x per y in map.
Quali pin restano liberi con lo shield TFT montato?
Su Uno restano solo A5, D0–D1 (condivisi con il caricamento via USB) e D10–D13 se non usi la scheda SD. Dato che A4 è il reset del display, l'I2C non si può usare. Se vuoi collegare più sensori, è meglio un Arduino Mega o un modulo TFT con interfaccia SPI.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

Visualizzare un messaggio su display LCD 2x16
Il tuo primo passo per scrivere testo su uno schermo. Il display LCD a due righe mostra prima un messaggio di attesa, poi scrive un saluto sulla riga in alto e batte una parola lettera per lettera su…

Testo che rimbalza a destra e sinistra su LCD
Sulla riga in alto del display LCD, la scritta BLUEGRAYS scorre da un bordo all'altro e rimbalza come una palla contro il muro, ancora e ancora senza fine.

Gioco delle Racchette - SSD1306
Una pallina, due racchette e tu: giochi a ping pong, uno dei primissimi videogiochi, su un piccolo display OLED.

OLED T-Rex Run: Gioco del dinosauro con Arduino
Il gioco del dinosauro che compare quando salta internet, ora sulla tua scrivania: il dinosauro corre sul piccolo display OLED, i cactus gli vengono incontro e tu salti con un solo pulsante.

Gioco runner su LCD con Arduino
Gioco endless runner a scorrimento laterale su schermo LCD a 16x2 caratteri. L'eroe corre automaticamente, il giocatore salta gli ostacoli premendo il pulsante. Sulla riga superiore e inferiore compaiono ostacoli casuali. Il cicalino passivo riproduce la melodia di apertura, il suono di salto, il suono di celebrazione dei 50 punti e la melodia di fine gioco. All'avvio viene visualizzata la schermata iniziale "BlueGrays - Arduino Projects".

Calcolatrice Arduino I2C
Si tratta di un progetto di calcolatore basato su Arduino che esegue operazioni di addizione, sottrazione, moltiplicazione e divisione utilizzando una tastiera a membrana 4x4 e un display LCD I2C 16x2. Grazie all'I2C, il collegamento del display avviene con soli 2 cavi, riducendo così l'ingombro dei cavi e mantenendo un maggior numero di pin utilizzabili. Sono inoltre disponibili l'ingresso di numeri decimali e il supporto di numeri negativi.

Serratura con password, tastierino 4x4 e LCD
Una piccola serratura elettronica che non fa entrare chi non conosce il codice. Premi il tasto cancelletto e digiti il codice sul tastierino; se è giusto, lo schermo indica accesso consentito, si…
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

