Écran TFT 2.4 Arduino : shield tactile, MCUFRIEND_kbv et carte SD
Écran TFT 2.4 sur Arduino : MCUFRIEND_kbv, lire l'ID du contrôleur, régler l'écran blanc, calibrer le tactile, boutons, images BMP de la carte SD et brochage.
L'écran TFT 2.4 pour Arduino au format shield est un écran couleur tactile de 240×320 pixels qui s'enfiche directement sur l'Arduino Uno. Ni câbles ni soudure : tu poses le shield sur les connecteurs de l'Uno ou du Mega, tu installes la bonne bibliothèque et, en quelques minutes, tu affiches du texte en couleur, des formes, des boutons tactiles et des images depuis la carte SD. Comme il est bon marché, on le trouve dans beaucoup de kits de démarrage et de projets scolaires ; pour la même raison, c'est l'une des pièces qui fait le plus souvent poser la question « pourquoi mon écran reste blanc ? » sur les forums.
Dans ce guide, tu vas voir pourquoi le shield affiche parfois un écran blanc et comment la bibliothèque MCUFRIEND_kbv règle le problème. Tu vas lire l'ID du contrôleur, calibrer la dalle tactile, corriger un tactile inversé, piloter une LED avec des boutons à l'écran et afficher des images depuis une carte microSD. On voit aussi quelles broches le shield occupe, lesquelles restent disponibles et à quoi faire attention avec le Mega, l'ESP32 et le Pico.

Le shield TFT 2,4", c'est quoi et comment ça marche ?
Le shield regroupe trois éléments : la dalle TFT couleur, une couche tactile résistive collée dessus et un lecteur de carte microSD au dos. L'écran n'est pas relié à l'Arduino par un bus série comme le SPI, mais par un bus parallèle 8 bits ; comme il envoie un octet entier à chaque fois, il dessine plus vite qu'un module SPI sur un Uno, mais il consomme beaucoup de broches. Le contrôleur de la dalle fonctionne en 3,3 V ; grâce au régulateur 3,3 V et au convertisseur de niveaux de type 74HC245 présents sur la carte, les signaux 5 V de l'Uno s'utilisent sans risque.
| Caractéristique | Valeur |
|---|---|
| Écran | TFT 2,4 pouces, 240×320 pixels |
| Couleurs | 16 bits (RGB565), 65 536 couleurs |
| Interface | Parallèle 8 bits (D0–D7) + 5 lignes de contrôle |
| Contrôleur | Variable : ILI9341, ILI9325, ST7781, SPFD5408, HX8347 et d'autres |
| Tactile | Résistif 4 fils, broches partagées avec l'écran |
| Lecteur SD | microSD en SPI (D10–D13) |
| Alimentation | 5 V (régulateur 3,3 V sur la carte) |
| Consommation | Environ 80 à 120 mA, surtout pour le rétroéclairage |
| Cartes compatibles | Arduino Uno, Arduino Mega 2560 |
Shield ou module SPI ?
Deux produits différents de même taille sont vendus et on les appelle tous les deux « TFT 2.4 ». Le shield est le modèle parallèle qu'on enfiche sur l'Uno et qui marche tout de suite. Le module SPI possède une seule rangée de broches sur un bord et se câble avec des fils ; son tactile se lit en général en SPI avec une puce XPT2046. Ce guide traite du shield ; pour le module SPI, consulte notre article sur l'écran TFT ILI9341.

| Critère | Shield 2,4" pour Uno | Module SPI 2,4" |
|---|---|---|
| Connexion | S'enfiche sur l'Uno ou le Mega, sans fil | 7 à 14 câbles Dupont |
| Broches utilisées | D2–D9, A0–A4 (D10–D13 avec la SD) | 5 pour l'écran, 8 ou 9 avec tactile et SD |
| Vitesse d'affichage sur Uno | Rapide (parallèle) | Plus lente (SPI) |
| Bibliothèque | MCUFRIEND_kbv | Adafruit_ILI9341, TFT_eSPI |
| Lecture du tactile | Analogique, broches partagées avec l'écran | Puce XPT2046 en SPI |
| ESP32 et Pico | Déconseillé | Adapté |
| Broches disponibles pour des capteurs | Presque aucune | Beaucoup |
Brochage : quelles broches le shield utilise-t-il ?
| Broche du shield | Broche Arduino Uno | Rôle |
|---|---|---|
| LCD_RD | A0 | Signal de lecture |
| LCD_WR | A1 | Signal d'écriture (parfois partagé avec le tactile) |
| LCD_RS (CD) | A2 | Commande ou donnée ? (partagé avec le tactile) |
| LCD_CS | A3 | Sélection de l'écran (parfois partagé avec le tactile) |
| LCD_RST | A4 | Reset de l'écran |
| LCD_D0, LCD_D1 | D8, D9 | Deux premiers bits du bus de données |
| LCD_D2–LCD_D7 | D2–D7 | Six autres bits du bus de données |
| SD_SS / SD_DI / SD_DO / SD_SCK | D10 / D11 / D12 / D13 | Carte microSD (SPI) |
| 5V, 3V3, GND | 5V, 3.3V, GND | Alimentation |
Installer la bibliothèque MCUFRIEND_kbv
- Ouvre le gestionnaire de bibliothèques de l'Arduino IDE, cherche MCUFRIEND_kbv et installe-la.
- Au même endroit, installe Adafruit GFX Library ; c'est d'elle que viennent les fonctions de texte, de lignes, de cercles et de boutons.
- Pour le tactile, installe la bibliothèque Adafruit TouchScreen (incluse dans le code sous le nom TouchScreen.h).
- Pour la carte SD, rien à installer : la bibliothèque SD est fournie avec l'Arduino IDE.
Pourquoi MCUFRIEND_kbv ? Ces shields se ressemblent tous, mais ils peuvent cacher des contrôleurs différents : de deux shields commandés au même vendeur à deux mois d'écart, l'un peut contenir un ILI9341 et l'autre un ST7781. Les anciennes bibliothèques comme Adafruit_TFTLCD ou SPFD5408 ne connaissent que quelques puces ; si la puce ne correspond pas, l'écran n'est jamais initialisé et on obtient le fameux écran blanc. MCUFRIEND_kbv demande d'abord son identifiant à la puce, puis lui envoie les commandes de démarrage qui lui conviennent.
Lire l'ID du contrôleur : readID()
Première étape : demander à ton shield qui il est. Le code ci-dessous affiche l'ID dans le moniteur série et à l'écran, puis dessine trois rectangles de couleur. Règle le moniteur série sur 9600 bauds.
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 lu | Puce | Que faire ? |
|---|---|---|
| 0x9341 | ILI9341 | Le modèle le plus courant ; fonctionne directement |
| 0x9325 / 0x9328 | ILI9325 / ILI9328 | Ancien mais sans souci ; fonctionne directement |
| 0x7783 | ST7781 | Fonctionne directement |
| 0x5408 | SPFD5408 | Fonctionne directement ; plus besoin de la vieille bibliothèque SPFD5408 |
| 0x4747 / 0x9595 | HX8347-D / HX8347-I | Fonctionne directement |
| 0x1505 / 0x0154 | R61505 / S6D0154 | Fonctionne directement |
| 0xD3D3 | Shield sans ligne de lecture reliée | Écris l'ID à la main dans le code ; en 2,4", essaie d'abord 0x9341 |
| 0x0000 ou 0xFFFF | Pas de réponse | Shield mal enfiché, broche tordue ou carte défectueuse |
Si les rectangles apparaissent rouge, vert et bleu dans cet ordre, tout va bien. Si tu vois du bleu à la place du rouge, tu as sans doute fixé l'ID à la main et de mauvaises commandes de démarrage ont été envoyées : utilise la valeur trouvée par readID. Si les couleurs ressemblent à un négatif, ajoute la ligne tft.invertDisplay(true) après begin. Si l'ID est étrange, l'exemple Fichier > Exemples > MCUFRIEND_kbv > LCD_ID_readreg affiche tous les registres de la puce ; c'est le moyen le plus rapide de comprendre le problème. L'exemple graphictest_kbv, lui, teste toutes les fonctions de l'écran d'un coup.
L'écran blanc et les autres problèmes d'affichage
Un écran blanc est en fait un indice : le rétroéclairage est alimenté, mais le contrôleur n'a jamais été initialisé. Quand la dalle ne reçoit aucune commande, les pixels laissent passer la lumière et tout paraît blanc. Vérifie le tableau de haut en bas :
| Symptôme | Cause probable | Solution |
|---|---|---|
| Écran blanc avec une ancienne bibliothèque | La bibliothèque ne connaît pas ta puce | Installe MCUFRIEND_kbv et démarre avec readID |
| Écran blanc, ID 0x0000 ou 0xFFFF | Shield mal enfiché ou broche tordue | Retire le shield, redresse les broches et enfonce-le à fond |
| Écran blanc, ID 0xD3D3 | Pas de ligne de lecture, l'ID est illisible | Indique l'ID à la main, par exemple tft.begin(0x9341) ; sinon essaie 0x9325 et 0x7783 |
| Couleurs en négatif (le blanc paraît noir) | Le réglage d'inversion de la puce est différent | tft.invertDisplay(true) après begin |
| Rouge et bleu inversés | L'ID fixé à la main ne correspond pas à la puce | Utilise l'ID trouvé par readID et mets la bibliothèque à jour |
| Texte en miroir | L'ID fixé à la main ne correspond pas à la dalle | Récupère l'ID avec readID ; vérifie les quatre orientations avec l'exemple aspect_kbv |
| L'image se dégrade quand on touche l'écran | La lecture du tactile a laissé les broches partagées en entrée | Après getPoint, remets YP et XM en OUTPUT |
| Marche sur l'Uno mais reste blanc sur le Mega | La bibliothèque ne connaît pas le brochage du Mega | MCUFRIEND_kbv gère le Mega ; supprime l'ancienne bibliothèque |
Calibrer le tactile
Une dalle tactile résistive se compose de deux fines couches résistives séparées par un tout petit espace. Quand tu appuies, les couches se touchent ; la bibliothèque applique une tension aux extrémités d'une couche et mesure avec une entrée analogique la tension sur l'autre, ce qui donne la position X et Y. Ces mesures brutes vont à peu près de 100 à 900 et changent d'une dalle à l'autre ; pour les convertir en pixels, il faut calibrer. En plus, le tactile utilise les mêmes broches que l'écran, et les quatre broches qui vont au tactile changent d'un shield à l'autre.
- Ouvre l'exemple TouchScreen_Calibr_native dans Fichier > Exemples > MCUFRIEND_kbv et téléverse-le.
- Ouvre le moniteur série à 9600 bauds ; l'exemple commence par trouver tout seul les broches du tactile.
- Appuie l'une après l'autre sur les croix qui s'affichent, en gardant le doigt ou le stylet sur chacune jusqu'à ce que le texte change.
- À la fin, deux lignes apparaissent dans le moniteur série sous le titre « COPY-PASTE » : const int XP=...,XM=...,YP=...,YM=... et const int TS_LEFT=...,TS_RT=...,TS_TOP=...,TS_BOT=....
- Colle ces deux lignes à la place des valeurs d'exemple en haut des programmes suivants.
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}Ce petit programme de dessin est le meilleur test de calibrage : le point doit apparaître presque exactement sous ton doigt. p.z est la pression ; si elle n'est pas comprise entre MINPRESSURE et MAXPRESSURE, ce n'est pas compté comme un appui, ce qui élimine les effleurements et le bruit électrique. Les lignes pinMode dans readTouch() sont essentielles : pendant la lecture, la bibliothèque TouchScreen passe les broches partagées en entrées analogiques et les laisse ainsi ; sans ces lignes, les commandes de dessin suivantes n'arrivent plus à l'écran et l'image se dégrade. Astuce : une dalle résistive réagit à la pression, donc avec l'ongle ou un stylet tu dessines plus précisément qu'avec le bout du doigt.
| Symptôme | Cause | Solution |
|---|---|---|
| J'appuie à droite, le point apparaît à gauche | Axe X inversé | Échange les valeurs de TS_LEFT et TS_RT |
| J'appuie en haut, le point apparaît en bas | Axe Y inversé | Échange les valeurs de TS_TOP et TS_BOT |
| En paysage, X et Y sont mélangés | setRotation(1) a fait tourner les axes | Utilise p.y pour x et p.x pour y dans map, ou reste en portrait |
| Aucun appui détecté | XP, XM, YP, YM incorrects | Relance l'exemple de calibrage et utilise les broches qu'il indique |
| Des points apparaissent sans appui | Seuil de pression trop bas | Monte MINPRESSURE à 300–400 |
| Les points sont décalés de quelques pixels | Calibrage fait trop vite | Recalibre en appuyant plus longtemps au centre exact de chaque croix |
Une interface à boutons tactiles
La classe Adafruit_GFX_Button de la bibliothèque Adafruit GFX dessine en quelques lignes des boutons avec contour et texte, et calcule elle-même si l'appui tombe sur le bouton. Le code suivant allume et éteint avec deux boutons une LED branchée sur A5 ; on a choisi A5 parce que c'est pratiquement la seule broche qui reste libre sur l'Uno avec le shield. N'oublie pas la résistance de 220 Ω en série avec la 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() enregistre à chaque tour si le bouton est appuyé à cet instant ; justPressed() ne renvoie vrai qu'au premier tour de l'appui et justReleased() qu'au tour où on relâche. Ainsi, tant que le doigt reste sur le bouton, la LED ne reçoit pas la même commande en boucle et l'écran n'est pas redessiné pour rien. drawButton(true) inverse les couleurs du bouton pour lui donner l'air enfoncé. En remplaçant la LED par un module relais sur A5, tu peux commander une lampe depuis l'écran tactile ; pour un câblage sûr, consulte notre article sur le module relais.
Afficher des images depuis la carte SD
Le lecteur microSD au dos est le moyen le plus simple d'afficher des images en couleur. Sur ton ordinateur, redimensionne l'image en 240×320 (portrait) et enregistre-la en BMP 24 bits : dans Paint, choisis « Bitmap 24 bits », dans GIMP l'option 24 bits à l'export. Limite le nom du fichier à 8 caractères (par exemple CHAT.BMP), car la bibliothèque SD travaille avec des noms courts, et remplace « KEDI.BMP » par ce nom dans le code. Formate la carte en FAT32 ou FAT16 ; les cartes de plus de 32 Go sont en général en exFAT et ne sont pas reconnues.
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}Dans un fichier BMP, les lignes sont stockées de bas en haut et chaque ligne est complétée jusqu'à un multiple de 4 octets ; le code gère ces deux détails avec le calcul de rowSize et l'indicateur bottomUp. Chaque pixel occupe 3 octets dans l'ordre bleu, vert, rouge, et color565() le convertit dans la couleur 16 bits que comprend l'écran. Comme l'Uno n'a que 2 Ko de RAM et que la bibliothèque SD en garde 512 octets pour son tampon, on lit les pixels par paquets de 20. Sur un Uno, une image plein écran se dessine ligne par ligne en quelques secondes. Pour le formatage de la carte et la gestion des fichiers, vois notre article sur le module carte SD.
L'utiliser avec un Arduino Mega
Le shield s'enfiche au même endroit sur les connecteurs du Mega et, comme MCUFRIEND_kbv reconnaît le Mega, les codes d'affichage et de tactile fonctionnent sans changement. Le gros avantage, ce sont les broches : D22–D53, A5–A15, trois ports série supplémentaires et le bus I2C sur D20–D21 restent libres ; pour les gros projets avec capteurs et écran, le Mega est le choix le plus confortable. Seul souci : le lecteur SD. Le shield relie la carte SD à D10–D13, alors que le SPI matériel du Mega se trouve sur D50–D53, si bien que SD.begin() échoue. La solution consiste à utiliser la bibliothèque SdFat en SPI logiciel sur D10–D13 ; l'exemple showBMP_not_Uno de MCUFRIEND_kbv le montre tout prêt. Pour toutes les broches du Mega, vois notre article sur le brochage de l'Arduino Mega.
Peut-on l'utiliser avec un ESP32 ou un Raspberry Pi Pico ?
Réponse courte : c'est déconseillé. Le shield parallèle attend 13 broches et un connecteur au format Uno compatible 5 V. Sur les cartes ESP32 au format Uno (ESPDuino-32, D1 R32 et consorts), les connecteurs A2–A4 arrivent le plus souvent sur les GPIO 34 à 36, qui ne peuvent être que des entrées ; les lignes de contrôle de l'écran ne peuvent pas être pilotées par là, et le tactile ne trouve pas de broches adaptées à ses lectures analogiques. Certains y arrivent en recâblant et avec la configuration parallèle de TFT_eSPI, mais c'est laborieux. Pour l'ESP32 et le Pico, un module SPI de même résolution est bien plus logique : il se branche avec quatre ou cinq fils et laisse la plupart des broches libres. Tous les détails sont dans nos articles sur l'écran TFT ILI9341 et, pour une option plus petite et plus nette, sur l'écran TFT ST7789.
Idées de projets avec l'écran TFT 2.4
- Calculatrice tactile : dessine une grille de 4×4 boutons et affiche le résultat en gros caractères ; la logique est la même que dans notre article sur la calculatrice Arduino.
- Cadre photo numérique : affiche à tour de rôle les fichiers BMP de la carte SD et passe au suivant quand on touche l'écran.
- Serrure à code : dessine un pavé numérique à l'écran et active le relais sur A5 avec le bon code ; pour la logique des touches, vois l'article sur le clavier matriciel (keypad).
- Jeux : Pong, Snake ou un morpion tactile ; tu trouveras des idées dans nos projets de jeux Arduino.
- Courbe de température : branche un DHT11 sur le Mega et affiche la température de la dernière heure sous forme de courbe défilante.
- Oscilloscope simple : trace sous forme d'onde le signal lu sur A5 ; pour les signaux lents, c'est un outil ludique pour apprendre.
Avec la bonne bibliothèque, l'écran TFT 2.4 au format shield fonctionne en quelques minutes et, grâce au tactile, donne à tes projets une vraie interface. Si tu préfères débuter avec un écran plus simple, l'application BlueGrays propose pas à pas, avec schéma et code, les projets LCD I2C, texte défilant sur un LCD 2x16, Pong et T-Rex sur écran OLED et un jeu de course sur LCD.
Questions fréquentes
Pourquoi mon écran TFT 2.4 reste-t-il blanc ?
Un écran blanc signifie que le rétroéclairage est allumé mais que le contrôleur n'a pas été initialisé. La cause la plus fréquente : ta bibliothèque ne reconnaît pas la puce de ton shield. Installer MCUFRIEND_kbv, lire l'ID avec tft.readID() et démarrer avec tft.begin(ID) règle presque toujours le problème ; si l'ID vaut 0x0000, le shield est mal enfiché.
Quelle bibliothèque utiliser pour l'écran TFT 2.4 Arduino ?
Pour l'affichage, MCUFRIEND_kbv avec Adafruit GFX Library ; pour le tactile, Adafruit TouchScreen ; pour la carte, la bibliothèque SD fournie avec l'Arduino IDE. Les anciennes bibliothèques SPFD5408 et Adafruit_TFTLCD ne gèrent que quelques puces, d'où l'écran blanc fréquent sur les shields récents.
Comment connaître le contrôleur de mon écran TFT ?
Appelle tft.readID() avec MCUFRIEND_kbv et affiche le résultat dans le moniteur série : 0x9341 correspond à l'ILI9341, 0x9325 à l'ILI9325 et 0x7783 au ST7781. L'exemple LCD_ID_readreg de la bibliothèque affiche en plus tous les registres de la puce.
L'écran TFT 2.4 fonctionne-t-il avec un Arduino Mega ?
Oui, le shield s'enfiche aussi sur le Mega et MCUFRIEND_kbv le prend en charge. Seul le lecteur SD ne marche pas directement, car les broches SPI du Mega sont sur D50–D53 ; pour la carte SD, il faut SdFat en SPI logiciel. En échange, tu gagnes énormément de broches libres.
Comment corriger un tactile inversé sur l'écran TFT 2.4 ?
Relance d'abord l'exemple TouchScreen_Calibr_native et copie les valeurs affichées dans ton code. Si la gauche et la droite sont inversées, échange TS_LEFT et TS_RT ; si le haut et le bas le sont, échange TS_TOP et TS_BOT. Si les axes se mélangent en mode paysage, utilise p.y pour x et p.x pour y dans map.
Quelles broches restent libres avec le shield TFT ?
Sur l'Uno, il ne reste que A5, D0–D1 (partagées avec le téléversement USB) et D10–D13 si tu n'utilises pas la carte SD. Comme A4 est le reset de l'écran, l'I2C est inutilisable. Pour brancher davantage de capteurs, un Arduino Mega ou un module TFT en SPI convient mieux.
Projets à réaliser après cet article
Voir tous les projets
Utilisation de l'écran LCD avec I2C
Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

Afficher un message sur un écran LCD 2x16
Ta première étape pour écrire du texte sur un écran. L'écran LCD à deux lignes affiche d'abord un message d'attente, puis écrit un bonjour sur la ligne du haut et tape un mot lettre par lettre sur…

Texte qui rebondit de gauche à droite sur un écran LCD
Sur la ligne du haut de l'écran LCD, le mot BLUEGRAYS glisse d'un bord à l'autre et rebondit comme une balle contre un mur, encore et encore sans fin.

Jeu de Raquettes - SSD1306
Une balle, deux raquettes et toi : tu joues au tennis de table, l'un des tout premiers jeux vidéo, sur un petit écran OLED.

OLED T-Rex Run : Jeu de dinosaures Arduino
Le jeu du dinosaure qui apparaît quand internet est coupé, maintenant sur ton bureau : le dinosaure court sur le petit écran OLED, les cactus foncent sur lui et tu sautes avec un seul bouton.

Jeu Arduino LCD Runner
Jeu de course sans fin à défilement latéral fonctionnant sur un écran LCD de 16x2 caractères. Le héros court automatiquement, le joueur saute par-dessus les obstacles en appuyant sur le bouton. Des obstacles aléatoires apparaissent sur les rangées du haut et du bas. Un buzzer passif joue la mélodie d'ouverture, le son de saut, le son de célébration des 50 points et la mélodie de fin de partie. L'écran d'accueil "BlueGrays - Arduino Projects" s'affiche au démarrage.

Calculatrice Arduino I2C
Il s'agit d'un projet de calculatrice basé sur Arduino qui effectue des opérations d'addition, de soustraction, de multiplication et de division à l'aide d'un clavier à membrane 4x4 et d'un écran LCD I2C 16x2. Grâce à l'I2C, la connexion de l'écran n'est assurée que par deux câbles, ce qui réduit l'encombrement des câbles et permet d'utiliser plus de broches. L'entrée de nombres décimaux et la prise en charge des nombres négatifs sont également disponibles.

Serrure à code avec clavier 4x4 et écran LCD
Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

