Componenti · 10 min di lettura

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.

Scheda Arduino Uno
Lo shield TFT da 2,4" si appoggia su questa scheda e usa quasi tutti i pin; restano solo A5, D0–D1 e, senza scheda SD, D10–D13.

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.

CaratteristicaValore
SchermoTFT da 2,4 pollici, 240×320 pixel
Colori16 bit (RGB565), 65.536 colori
InterfacciaParallela a 8 bit (D0–D7) + 5 linee di controllo
ControllerVaria: ILI9341, ILI9325, ST7781, SPFD5408, HX8347 e altri
TouchResistivo a 4 fili, condivide i pin con il display
Slot SDmicroSD in SPI (D10–D13)
Alimentazione5 V (regolatore da 3,3 V sulla scheda)
AssorbimentoCirca 80–120 mA, quasi tutti per la retroilluminazione
Schede compatibiliArduino 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.

Modulo display TFT ILI9341 con interfaccia SPI
Il "fratello" dello shield: il modulo SPI si collega con i cavetti tramite una fila di pin e va molto più d'accordo con ESP32 e Pico.
CaratteristicaShield 2,4" per UnoModulo SPI 2,4"
CollegamentoSi innesta su Uno o Mega, senza caviDa 7 a 14 cavetti jumper
Pin usatiD2–D9, A0–A4 (con la SD D10–D13)5 per il display, 8–9 con touch e SD
Velocità di disegno su UnoAlta (parallelo)Più bassa (SPI)
LibreriaMCUFRIEND_kbvAdafruit_ILI9341, TFT_eSPI
Lettura del touchAnalogica, pin condivisi con il displayChip XPT2046 in SPI
ESP32 e PicoSconsigliatoAdatto
Pin disponibili per sensoriQuasi nessunoMolti

Tabella dei pin: quali pin usa lo shield?

Pin dello shieldPin di Arduino UnoFunzione
LCD_RDA0Segnale di lettura
LCD_WRA1Segnale di scrittura (a volte condiviso con il touch)
LCD_RS (CD)A2Comando o dato? (condiviso con il touch)
LCD_CSA3Selezione del display (a volte condiviso con il touch)
LCD_RSTA4Reset del display
LCD_D0, LCD_D1D8, D9Primi due bit del bus dati
LCD_D2–LCD_D7D2–D7Altri sei bit del bus dati
SD_SS / SD_DI / SD_DO / SD_SCKD10 / D11 / D12 / D13Scheda microSD (SPI)
5V, 3V3, GND5V, 3.3V, GNDAlimentazione
Con lo shield montato, a Uno non restano quasi pin per i sensori. Dato che A4 è la linea di reset del display, l'I2C su A4/A5 non si può usare: niente sensori o display I2C. Restano disponibili A5 (non collegato sulla maggior parte degli shield), D0–D1, condivisi con il caricamento via USB, e D10–D13 se non usi la scheda SD. Se ti servono più sensori, monta lo shield su un Arduino Mega o passa al modulo SPI.

Installare la libreria MCUFRIEND_kbv

  1. Apri il Gestore librerie dell'Arduino IDE, cerca MCUFRIEND_kbv e installala.
  2. Dallo stesso punto installa Adafruit GFX Library; da lì arrivano le funzioni per testo, linee, cerchi e pulsanti.
  3. Per il touch installa la libreria Adafruit TouchScreen (nel codice si include come TouchScreen.h).
  4. 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.

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 lettoChipCosa fare
0x9341ILI9341Il modello più diffuso; funziona subito
0x9325 / 0x9328ILI9325 / ILI9328Vecchio ma senza problemi; funziona subito
0x7783ST7781Funziona subito
0x5408SPFD5408Funziona subito; non serve più la vecchia libreria SPFD5408
0x4747 / 0x9595HX8347-D / HX8347-IFunziona subito
0x1505 / 0x0154R61505 / S6D0154Funziona subito
0xD3D3Shield senza linea di lettura collegataScrivi l'ID a mano nel codice; sui 2,4" prova prima 0x9341
0x0000 o 0xFFFFNessuna rispostaShield 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:

SintomoCausa probabileSoluzione
Schermo bianco con una libreria vecchiaLa libreria non conosce il tuo chipInstalla MCUFRIEND_kbv e avvia con readID
Schermo bianco, ID 0x0000 o 0xFFFFShield non inserito bene o pin piegatoTogli lo shield, raddrizza i pin e spingilo fino in fondo
Schermo bianco, ID 0xD3D3Manca la linea di lettura, l'ID non si leggeImposta 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 diversamentetft.invertDisplay(true) dopo begin
Rosso e blu scambiatiL'ID impostato a mano non corrisponde al chipUsa l'ID trovato da readID e aggiorna la libreria all'ultima versione
Testo a specchioL'ID impostato a mano non corrisponde al pannelloRicava l'ID con readID; controlla i quattro orientamenti con l'esempio aspect_kbv
L'immagine si rovina quando tocchi lo schermoLa lettura del touch ha lasciato i pin condivisi come ingressiDopo getPoint rimetti YP e XM in OUTPUT
Funziona su Uno ma su Mega resta biancoLa libreria non conosce la mappatura dei pin del MegaMCUFRIEND_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.

  1. Apri l'esempio TouchScreen_Calibr_native da File > Esempi > MCUFRIEND_kbv e caricalo.
  2. Apri il monitor seriale a 9600 baud; l'esempio per prima cosa trova da solo i pin del touch.
  3. Premi una dopo l'altra le croci che compaiono sullo schermo, tenendo il dito o il pennino su ognuna finché il testo non cambia.
  4. 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=....
  5. Incolla queste due righe al posto dei valori di esempio all'inizio degli sketch seguenti.
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}

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.

SintomoCausaSoluzione
Tocco a destra e il punto compare a sinistraAsse X invertitoScambia i valori di TS_LEFT e TS_RT
Tocco in alto e il punto compare in bassoAsse Y invertitoScambia i valori di TS_TOP e TS_BOT
In orizzontale X e Y si mescolanoCon setRotation(1) gli assi sono ruotatiUsa p.y per x e p.x per y in map, oppure resta in verticale
Nessun tocco rilevatoXP, XM, YP, YM sbagliatiEsegui di nuovo l'esempio di calibrazione e usa i pin che indica
Compaiono punti senza toccareSoglia di pressione troppo bassaAlza MINPRESSURE a 300–400
I punti sono spostati di qualche pixelCalibrazione fatta di frettaRicalibra 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.

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

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}

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.
Se lo schermo sfarfalla, non cancellare tutto con fillScreen() a ogni giro: pulisci con fillRect() solo la zona che cambia e ridisegnala. Mettere i testi fissi dentro F() fa risparmiare RAM. Perché lo sfondo dietro ai numeri che cambiano si cancelli da solo, usa la forma setTextColor(testo, sfondo).

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.

Vedi tutti i progetti
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Visualizzare un messaggio su display LCD 2x16
AR-29Avanzato
Premium

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…

4.6(37)
51
Testo che rimbalza a destra e sinistra su LCD
AR-30Avanzato
Premium

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.

4.5(29)
40
Gioco delle Racchette - SSD1306
AR-86Intermedio
Premium

Gioco delle Racchette - SSD1306

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

4.5(47)
65
OLED T-Rex Run: Gioco del dinosauro con Arduino
AR-87Avanzato
Premium

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.

4.7(33)
53
Gioco runner su LCD con Arduino
AR-96Intermedio
Premium

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

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

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.

5.0(31)
43
Serratura con password, tastierino 4x4 e LCD
AR-64Avanzato
Premium

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…

4.8(59)
75