2.4 TFT Shield Arduino: MCUFRIEND_kbv, Touch und SD-Karte
2,4-Zoll-TFT-Shield am Arduino: MCUFRIEND_kbv, Treiber-ID auslesen, weißer Bildschirm, Touch kalibrieren, Buttons, BMP-Bilder von der SD-Karte und Pinbelegung.
Das 2.4 TFT Shield für Arduino ist ein farbiger Touchscreen mit 240×320 Pixeln, der direkt auf den Arduino Uno gesteckt wird. Keine Kabel, kein Löten: Du setzt das Shield auf die Buchsenleisten von Uno oder Mega, installierst die richtige Bibliothek und zeigst nach wenigen Minuten farbige Texte, Formen, Touch-Buttons und Bilder von der SD-Karte. Weil es günstig ist, steckt es in vielen Starter-Kits und Schulprojekten; aus demselben Grund gehört es zu den Bauteilen, zu denen in Foren am häufigsten gefragt wird: „Warum bleibt mein Display weiß?“
In dieser Anleitung siehst du, warum das Shield manchmal nur weiß leuchtet und wie die Bibliothek MCUFRIEND_kbv das löst. Du liest die Treiber-ID aus, kalibrierst den Touchscreen, korrigierst einen spiegelverkehrten Touch, schaltest eine LED über Bildschirm-Buttons und zeigst Bilder von einer microSD-Karte. Außerdem erfährst du, welche Pins das Shield belegt, welche übrig bleiben und worauf du bei Mega, ESP32 und Pico achten musst.

Was ist das 2,4-Zoll-TFT-Shield und wie funktioniert es?
Auf dem Shield stecken drei Teile: das farbige TFT-Panel, eine darauf geklebte resistive Touch-Schicht und auf der Rückseite ein microSD-Kartenslot. Das Display hängt nicht an einem seriellen Bus wie SPI, sondern an einem 8-Bit-Parallelbus; weil jeweils ein ganzes Byte übertragen wird, zeichnet es auf dem Uno schneller als SPI-Module, braucht aber viele Pins. Der Treiberchip des Panels arbeitet mit 3,3 V; dank des 3,3-V-Spannungsreglers und eines Pegelwandlers vom Typ 74HC245 auf der Platine sind die 5-V-Signale des Uno unbedenklich.
| Merkmal | Wert |
|---|---|
| Display | 2,4-Zoll-TFT, 240×320 Pixel |
| Farbe | 16 Bit (RGB565), 65.536 Farben |
| Schnittstelle | 8 Bit parallel (D0–D7) + 5 Steuerleitungen |
| Treiberchip | Unterschiedlich: ILI9341, ILI9325, ST7781, SPFD5408, HX8347 und andere |
| Touch | 4-Draht resistiv, teilt sich Pins mit dem Display |
| SD-Slot | microSD über SPI (D10–D13) |
| Versorgung | 5 V (3,3-V-Regler auf der Platine) |
| Stromaufnahme | Etwa 80–120 mA, das meiste für die Hintergrundbeleuchtung |
| Passende Boards | Arduino Uno, Arduino Mega 2560 |
Shield oder SPI-Modul?
Es gibt zwei verschiedene Produkte in derselben Größe, und beide heißen „2.4 TFT“. Das Shield ist das Parallelmodell, das du aufsteckst und loslegst. Das SPI-Modul hat am Rand eine einzelne Stiftleiste und wird mit Kabeln verbunden; sein Touch wird meist über SPI mit einem XPT2046-Chip gelesen. In diesem Artikel geht es um das Shield; für das SPI-Modul lies den Artikel zum ILI9341-TFT-Display.

| Merkmal | 2,4"-Uno-Shield | 2,4"-SPI-Modul |
|---|---|---|
| Anschluss | Auf Uno oder Mega gesteckt, keine Kabel | 7 bis 14 Jumperkabel |
| Belegte Pins | D2–D9, A0–A4 (mit SD D10–D13) | 5 für das Display, 8–9 mit Touch und SD |
| Zeichentempo am Uno | Schnell (parallel) | Langsamer (SPI) |
| Bibliothek | MCUFRIEND_kbv | Adafruit_ILI9341, TFT_eSPI |
| Touch-Auswertung | Analog, Pins mit dem Display geteilt | XPT2046-Chip über SPI |
| ESP32 und Pico | Nicht geeignet | Geeignet |
| Freie Pins für Sensoren | Fast keine | Viele |
Pinbelegung: Welche Pins belegt das Shield?
| Shield-Pin | Arduino-Uno-Pin | Funktion |
|---|---|---|
| LCD_RD | A0 | Lesesignal |
| LCD_WR | A1 | Schreibsignal (teils mit Touch geteilt) |
| LCD_RS (CD) | A2 | Befehl oder Daten? (mit Touch geteilt) |
| LCD_CS | A3 | Display-Auswahl (teils mit Touch geteilt) |
| LCD_RST | A4 | Display-Reset |
| LCD_D0, LCD_D1 | D8, D9 | Die ersten zwei Bits des Datenbusses |
| LCD_D2–LCD_D7 | D2–D7 | Die übrigen sechs Bits des Datenbusses |
| SD_SS / SD_DI / SD_DO / SD_SCK | D10 / D11 / D12 / D13 | microSD-Karte (SPI) |
| 5V, 3V3, GND | 5V, 3.3V, GND | Versorgung |
Die Bibliothek MCUFRIEND_kbv installieren
- Öffne in der Arduino IDE den Bibliotheksverwalter, suche MCUFRIEND_kbv und installiere sie.
- Installiere an derselben Stelle die Adafruit GFX Library; von ihr stammen die Funktionen für Text, Linien, Kreise und Buttons.
- Für den Touchscreen installierst du die Bibliothek Adafruit TouchScreen (im Code als TouchScreen.h eingebunden).
- Für die SD-Karte musst du nichts installieren; die Bibliothek SD ist bei der Arduino IDE schon dabei.
Warum MCUFRIEND_kbv? Die Shields sehen gleich aus, können aber unterschiedliche Treiberchips enthalten: Von zwei Shields, die du im Abstand von zwei Monaten beim selben Händler bestellst, hat eines vielleicht einen ILI9341 und das andere einen ST7781. Ältere Bibliotheken wie Adafruit_TFTLCD oder SPFD5408 kennen nur wenige Chips; passt der Chip nicht, wird das Display nie initialisiert, und es bleibt beim berühmten weißen Bildschirm. MCUFRIEND_kbv fragt den Chip zuerst nach seiner ID und schickt dann die passenden Startbefehle.
Treiber-ID auslesen: readID()
Als Erstes fragst du dein Shield, wer es ist. Der folgende Code gibt die ID im seriellen Monitor und auf dem Display aus und zeichnet danach drei farbige Kästen. Stell den seriellen Monitor auf 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}| Gelesene ID | Chip | Was tun? |
|---|---|---|
| 0x9341 | ILI9341 | Das häufigste Modell; läuft sofort |
| 0x9325 / 0x9328 | ILI9325 / ILI9328 | Älter, aber problemlos; läuft sofort |
| 0x7783 | ST7781 | Läuft sofort |
| 0x5408 | SPFD5408 | Läuft sofort; die alte SPFD5408-Bibliothek brauchst du nicht |
| 0x4747 / 0x9595 | HX8347-D / HX8347-I | Läuft sofort |
| 0x1505 / 0x0154 | R61505 / S6D0154 | Läuft sofort |
| 0xD3D3 | Shield ohne angeschlossene Leseleitung | ID von Hand in den Code schreiben; bei 2,4 Zoll zuerst 0x9341 probieren |
| 0x0000 oder 0xFFFF | Keine Antwort | Shield sitzt nicht richtig, ein Pin ist verbogen oder die Platine ist defekt |
Erscheinen die Kästen in der Reihenfolge Rot, Grün, Blau, ist alles in Ordnung. Siehst du Blau statt Rot, hast du die ID vermutlich von Hand gesetzt und es gingen falsche Startbefehle raus; nimm dann den Wert, den readID gefunden hat. Wirken die Farben wie ein Negativ, ergänze nach begin die Zeile tft.invertDisplay(true). Kommt eine merkwürdige ID heraus, gibt das Beispiel Datei > Beispiele > MCUFRIEND_kbv > LCD_ID_readreg alle Register des Chips aus; diese Ausgabe ist der schnellste Weg zur Diagnose. Das Beispiel graphictest_kbv testet alle Displayfunktionen auf einmal.
Weißer Bildschirm und andere Anzeigefehler
Ein weißer Bildschirm ist eigentlich ein Hinweis: Die Hintergrundbeleuchtung bekommt Strom, aber der Treiberchip wurde nie initialisiert. Bekommt das Panel keine Befehle, lassen die Pixel das Licht durch, und alles erscheint weiß. Geh die Tabelle von oben nach unten durch:
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Weißer Bildschirm mit einer alten Bibliothek | Die Bibliothek kennt deinen Chip nicht | MCUFRIEND_kbv installieren und mit readID starten |
| Weißer Bildschirm, ID 0x0000 oder 0xFFFF | Shield sitzt nicht richtig oder ein Pin ist verbogen | Shield abziehen, Pins geradebiegen und bis zum Anschlag aufstecken |
| Weißer Bildschirm, ID 0xD3D3 | Keine Leseleitung, die ID lässt sich nicht lesen | ID von Hand setzen, z. B. tft.begin(0x9341); sonst 0x9325 und 0x7783 probieren |
| Farben wie ein Negativ (Weiß erscheint schwarz) | Die Invertierung des Chips ist anders eingestellt | Nach begin tft.invertDisplay(true) |
| Rot und Blau vertauscht | Die von Hand gesetzte ID passt nicht zum Chip | Die ID von readID verwenden und die Bibliothek aktualisieren |
| Spiegelverkehrte Schrift | Die von Hand gesetzte ID passt nicht zum Panel | ID mit readID holen; alle vier Ausrichtungen mit dem Beispiel aspect_kbv prüfen |
| Bild zerfällt beim Berühren | Das Touch-Lesen hat die geteilten Pins als Eingang zurückgelassen | Nach getPoint YP und XM wieder auf OUTPUT setzen |
| Läuft am Uno, am Mega bleibt es weiß | Die Bibliothek kennt die Pinzuordnung des Mega nicht | MCUFRIEND_kbv unterstützt den Mega; alte Bibliothek entfernen |
Touchscreen kalibrieren
Ein resistiver Touchscreen besteht aus zwei dünnen Widerstandsschichten mit einem winzigen Abstand dazwischen. Drückst du, berühren sich die Schichten; die Bibliothek legt an die Enden der einen Schicht eine Spannung an und misst über einen Analogeingang die Spannung an der anderen, daraus ergibt sich die X- und Y-Position. Diese Rohwerte liegen etwa zwischen 100 und 900 und unterscheiden sich von Panel zu Panel; um sie in Pixel umzurechnen, musst du kalibrieren. Außerdem nutzt der Touch dieselben Pins wie das Display, und welche vier Pins zum Touch führen, ist von Shield zu Shield verschieden.
- Öffne über Datei > Beispiele > MCUFRIEND_kbv das Beispiel TouchScreen_Calibr_native und lade es hoch.
- Öffne den seriellen Monitor mit 9600 Baud; das Beispiel findet die Touch-Pins zuerst selbst.
- Drück nacheinander auf die Kreuze, die auf dem Display erscheinen, und halte Finger oder Stift jeweils, bis sich der Text ändert.
- Am Ende stehen im seriellen Monitor unter der Überschrift „COPY-PASTE“ zwei Zeilen: const int XP=...,XM=...,YP=...,YM=... und const int TS_LEFT=...,TS_RT=...,TS_TOP=...,TS_BOT=....
- Füge diese zwei Zeilen anstelle der Beispielwerte oben in die folgenden Sketche ein.
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}Dieses kleine Malprogramm ist der beste Kalibrierungstest: Der Punkt sollte fast genau unter deinem Finger erscheinen. p.z ist der Druck; liegt er nicht zwischen MINPRESSURE und MAXPRESSURE, zählt es nicht als Berührung, so werden leichtes Streifen und elektrisches Rauschen ausgefiltert. Die pinMode-Zeilen in readTouch() sind entscheidend: Beim Lesen macht die TouchScreen-Bibliothek die geteilten Pins zu Analogeingängen und lässt sie so; ohne diese Zeilen kommen die nächsten Zeichenbefehle nicht beim Display an, und das Bild zerfällt. Ein Tipp: Ein resistiver Touchscreen reagiert auf Druck, mit dem Fingernagel oder einem Stift zeichnest du genauer als mit der Fingerkuppe.
| Symptom | Ursache | Lösung |
|---|---|---|
| Rechts tippen, Punkt erscheint links | X-Achse gespiegelt | Werte von TS_LEFT und TS_RT tauschen |
| Oben tippen, Punkt erscheint unten | Y-Achse gespiegelt | Werte von TS_TOP und TS_BOT tauschen |
| Im Querformat sind X und Y vertauscht | setRotation(1) hat die Achsen gedreht | Für x p.y und für y p.x mappen oder im Hochformat bleiben |
| Gar keine Berührung erkannt | XP, XM, YP, YM falsch | Kalibrierbeispiel erneut ausführen und die angezeigten Pins verwenden |
| Punkte erscheinen ohne Berührung | Druckschwelle zu niedrig | MINPRESSURE auf 300–400 erhöhen |
| Punkte liegen ein paar Pixel daneben | Kalibrierung zu hastig | Neu kalibrieren, die Kreuzmitte genau und länger drücken |
Eine Oberfläche mit Touch-Buttons
Die Klasse Adafruit_GFX_Button aus der Adafruit GFX Library zeichnet Buttons mit Rahmen und Beschriftung in wenigen Zeilen und rechnet selbst aus, ob eine Berührung auf dem Button lag. Der folgende Code schaltet mit zwei Buttons eine LED an A5 ein und aus; A5 haben wir gewählt, weil er mit aufgestecktem Shield praktisch der einzige freie Pin am Uno ist. Vergiss den 220-Ω-Vorwiderstand für die LED nicht.
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() merkt sich in jedem Durchlauf, ob der Button gerade gedrückt ist; justPressed() liefert nur im ersten Durchlauf nach dem Drücken true, justReleased() nur im Durchlauf nach dem Loslassen. So bekommt die LED nicht immer wieder denselben Befehl, solange der Finger auf dem Button liegt, und das Display wird nicht unnötig neu gezeichnet. drawButton(true) invertiert die Farben des Buttons für einen gedrückten Look. Hängst du statt der LED ein Relaismodul an A5, schaltest du eine Lampe per Touchscreen; wie das sicher geht, steht im Artikel zum Relaismodul.
Bilder von der SD-Karte anzeigen
Der microSD-Slot auf der Rückseite ist der einfachste Weg, farbige Bilder anzuzeigen. Bring das Bild am Rechner auf 240×320 (Hochformat) und speichere es als 24-Bit-BMP: In Paint wählst du „24-Bit-Bitmap“, in GIMP beim Exportieren die 24-Bit-Option. Der Dateiname darf höchstens 8 Zeichen haben (etwa KATZE.BMP), weil die SD-Bibliothek mit kurzen Namen arbeitet; ersetze im Code „KEDI.BMP“ durch deinen Dateinamen. Formatiere die Karte mit FAT32 oder FAT16; Karten über 32 GB sind meist mit exFAT formatiert und werden nicht erkannt.
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 einer BMP-Datei liegen die Zeilen von unten nach oben, und jede Zeile wird auf ein Vielfaches von 4 Byte aufgefüllt; der Code erledigt beides mit der Berechnung von rowSize und dem Flag bottomUp. Jedes Pixel belegt 3 Byte in der Reihenfolge Blau, Grün, Rot, und color565() wandelt das in die 16-Bit-Farbe des Displays um. Weil der Uno nur 2 KB RAM hat und die SD-Bibliothek davon 512 Byte für ihren Puffer belegt, lesen wir die Pixel in Portionen zu je 20. Ein bildschirmfüllendes Bild baut sich auf dem Uno in ein paar Sekunden Zeile für Zeile auf. Zum Formatieren der Karte und zur Arbeit mit Dateien lies den Artikel zum SD-Kartenmodul.
Einsatz mit dem Arduino Mega
Das Shield passt an derselben Stelle auf die Buchsenleisten des Mega, und weil MCUFRIEND_kbv den Mega kennt, laufen Display- und Touch-Code unverändert. Der große Gewinn sind die Pins: D22–D53, A5–A15, drei zusätzliche serielle Schnittstellen und der I2C-Bus an D20–D21 bleiben frei, damit ist der Mega für große Projekte mit Sensoren und Display die bequemste Wahl. Einziges Problem ist der SD-Slot: Das Shield verbindet die SD-Karte mit D10–D13, das Hardware-SPI des Mega liegt aber an D50–D53, deshalb schlägt SD.begin() fehl. Die Lösung ist die Bibliothek SdFat mit Software-SPI an D10–D13; das Beispiel showBMP_not_Uno von MCUFRIEND_kbv zeigt das fertig. Alle Pins des Mega findest du im Artikel zur Pinbelegung des Arduino Mega.
Geht das auch mit ESP32 oder Raspberry Pi Pico?
Kurz gesagt: nicht zu empfehlen. Das Parallel-Shield erwartet 13 Pins und eine 5-V-taugliche Uno-Buchsenleiste. Auf ESP32-Boards im Uno-Format (ESPDuino-32, D1 R32 und ähnliche) führen die Anschlüsse A2–A4 meist zu GPIO 34–36, die nur Eingänge sein können; die Steuerleitungen des Displays lassen sich darüber nicht treiben, und der Touch findet keine passenden Pins für die Analogmessung. Manche bringen es mit Umverdrahtung und den Parallel-Einstellungen von TFT_eSPI zum Laufen, aber das ist eine Bastelei. Für ESP32 und Pico ist ein SPI-Modul mit derselben Auflösung viel sinnvoller: Es braucht vier oder fünf Kabel und lässt die meisten Pins frei. Details findest du im Artikel zum ILI9341-TFT-Display und, als kleinere, schärfere Alternative, zum ST7789-TFT-Display.
Projektideen mit dem 2,4-Zoll-TFT-Shield
- Touch-Taschenrechner: Zeichne ein 4×4-Tastenfeld und zeig das Ergebnis in großer Schrift; die Logik ist dieselbe wie im Artikel zum Arduino-Taschenrechner.
- Digitaler Bilderrahmen: Zeig die BMP-Dateien der SD-Karte nacheinander an und spring bei Berührung zum nächsten Bild.
- Codeschloss: Zeichne ein Ziffernfeld auf das Display und schalte das Relais an A5 bei richtigem Code; die Tastenlogik erklärt der Artikel zum Keypad.
- Spiele: Pong, Snake oder Tic-Tac-Toe per Touch; Ideen findest du bei den Arduino-Spieleprojekten.
- Temperaturverlauf: Schließ einen DHT11 an den Mega an und zeig die Temperatur der letzten Stunde als laufende Liniengrafik.
- Einfaches Oszilloskop: Stell das an A5 gemessene Signal als Kurve dar; für langsame Signale ein lehrreiches Spielzeug.
Mit der richtigen Bibliothek läuft das 2,4-Zoll-TFT-Shield in wenigen Minuten, und der Touchscreen verschafft deinen Projekten eine echte Bedienoberfläche. Möchtest du lieber mit einem einfacheren Display anfangen, findest du in der BlueGrays-App Schritt für Schritt, mit Schaltplan und Code, die Projekte I2C-LCD, Lauftext auf dem 2x16-LCD, Pong und T-Rex auf dem OLED sowie ein Läuferspiel auf dem LCD.
Häufige Fragen
Warum bleibt mein 2.4 TFT Shield weiß?
Ein weißer Bildschirm heißt: Die Hintergrundbeleuchtung ist an, aber der Treiberchip wurde nicht initialisiert. Meist erkennt die verwendete Bibliothek den Chip auf deinem Shield nicht. MCUFRIEND_kbv installieren, die ID mit tft.readID() lesen und mit tft.begin(ID) starten löst das fast immer; kommt 0x0000 als ID, sitzt das Shield nicht richtig.
Welche Bibliothek brauche ich für das 2.4 TFT Shield?
Für das Display MCUFRIEND_kbv zusammen mit der Adafruit GFX Library, für den Touch Adafruit TouchScreen und für die Karte die SD-Bibliothek, die bei der Arduino IDE dabei ist. Die alten Bibliotheken SPFD5408 und Adafruit_TFTLCD unterstützen nur wenige Chips und liefern bei neueren Shields deshalb oft einen weißen Bildschirm.
Wie finde ich heraus, welchen Treiberchip mein TFT-Display hat?
Ruf mit MCUFRIEND_kbv tft.readID() auf und gib das Ergebnis im seriellen Monitor aus: 0x9341 steht für ILI9341, 0x9325 für ILI9325 und 0x7783 für ST7781. Das Beispiel LCD_ID_readreg der Bibliothek gibt zusätzlich alle Register des Chips aus.
Funktioniert das 2.4 TFT Shield mit dem Arduino Mega?
Ja, das Shield passt auch auf den Mega, und MCUFRIEND_kbv unterstützt ihn. Nur der SD-Slot läuft nicht direkt, weil die SPI-Pins des Mega an D50–D53 liegen; für die SD-Karte brauchst du SdFat mit Software-SPI. Dafür gewinnst du jede Menge freie Pins.
Der Touch reagiert spiegelverkehrt. Wie behebe ich das?
Führ zuerst das Beispiel TouchScreen_Calibr_native erneut aus und übernimm die ausgegebenen Werte. Sind links und rechts vertauscht, tausch TS_LEFT und TS_RT; sind oben und unten vertauscht, tausch TS_TOP und TS_BOT. Geraten die Achsen im Querformat durcheinander, mappe für x den Wert p.y und für y den Wert p.x.
Welche Pins bleiben mit aufgestecktem TFT-Shield frei?
Am Uno bleiben nur A5, D0–D1 (geteilt mit dem USB-Upload) und, ohne SD-Karte, D10–D13 frei. Weil A4 die Reset-Leitung des Displays ist, fällt I2C weg. Willst du mehr Sensoren anschließen, ist ein Arduino Mega oder ein TFT-Modul mit SPI-Schnittstelle die bessere Wahl.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

Text auf 2x16-LCD-Bildschirm anzeigen
Dein erster Schritt, um Text auf ein Display zu bringen. Das zweizeilige LCD-Display zeigt zuerst eine Wartemeldung, schreibt dann einen Gruß in die obere Zeile und tippt in der unteren Zeile ein…

Hin- und herlaufender Text auf dem LCD
In der oberen Zeile des LCD-Displays gleitet das Wort BLUEGRAYS von einem Rand zum anderen und prallt zurück wie ein Ball von der Wand, immer wieder ohne Ende.

Paddle-Ball-Spiel - SSD1306
Ein Ball, zwei Schläger und du: Du spielst Tischtennis, eines der allerersten Videospiele, auf einem kleinen OLED-Display.

OLED T-Rex Run: Arduino Dinosaurier Spiel
Das Dinosaurierspiel, das erscheint, wenn das Internet weg ist, jetzt auf deinem Schreibtisch: Der Dino rennt über das kleine OLED-Display, Kakteen kommen auf ihn zu, und du springst mit einem…

Arduino LCD-Runner-Spiel
Seitlich scrollendes Endlos-Laufspiel, das auf einem 16x2-Zeichen-LCD-Bildschirm läuft. Der Held läuft automatisch, der Spieler springt über Hindernisse, indem er die Taste drückt. Zufällige Hindernisse erscheinen in der oberen und unteren Reihe. Passiver Buzzer spielt Eröffnungsmelodie, Sprunggeräusch, 50-Punkte-Feierton und Spielende-Melodie. Beim Start wird der Splash-Screen "BlueGrays - Arduino Projects" angezeigt.

Arduino I2C-Rechner
Es handelt sich um ein Arduino-basiertes Taschenrechnerprojekt, das Addition, Subtraktion, Multiplikation und Division mit einer 4x4-Folientastatur und einem 16x2 I2C-LCD-Display durchführt. Dank I2C ist der Anschluss des Displays mit nur 2 Kabeln möglich, was den Kabelsalat reduziert und mehr Pins für die Verwendung offen hält. Die Eingabe von Dezimalzahlen und die Unterstützung negativer Zahlen sind ebenfalls möglich.

Passwortschloss mit 4x4-Tastenfeld und LCD
Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

