Arduino Display Arten im Vergleich: LCD, OLED, TFT, E-Paper
Arduino-Displays im Vergleich: 16x2-LCD, OLED, TFT, E-Paper, TM1637, MAX7219 und Nextion; Auflösung, Pins, Speicher, Strom und das passende Display je Projekt.
Die vielen Arduino-Display-Arten verwirren am Anfang: Dasselbe Wort "Display" steht für ein LCD mit 16 Zeichen, ein fingernagelgroßes OLED, ein buntes TFT wie ein Handybildschirm und ein E-Paper, das sein Bild sogar ohne Strom behält. Auflösung, Farbe, Anschlussart, Speicherbedarf und Energieverbrauch unterscheiden sich enorm. Eine falsche Wahl endet bei einem Uno ohne freien RAM, einer Anzeige, die man in der Sonne nicht lesen kann, oder einem Sensor, der seine Batterie an einem Tag leert.
In diesem Ratgeber gehen wir die sieben in Arduino-Projekten am häufigsten genutzten Display-Familien einzeln durch: Text-LCD (16x2 und 20x4), OLED (SSD1306 und SH1106), Farb-TFT (ILI9341 und ST7789), E-Paper, 7-Segment und TM1637, MAX7219-LED-Matrix und Nextion-Touchdisplays. Zuerst kommt eine große Vergleichstabelle, dann für jedes Display eine kurze Vorstellung mit funktionierendem Beispielcode und am Ende eine Tabelle "welches Display für welches Projekt" sowie die häufigsten Fehler.

Arduino-Display-Arten: Vergleichstabelle auf einen Blick
| Display | Auflösung | Farbe | Schnittstelle | Datenpins | Typischer Strom | Preis |
|---|---|---|---|---|---|---|
| 16x2- / 20x4-Text-LCD | 16×2 oder 20×4 Zeichen | Einfarbig, beleuchtet | Parallel oder I2C-Adapter | 6 (parallel) / 2 (I2C) | 20–40 mA | Sehr günstig |
| OLED SSD1306 / SH1106 | 128×64 (0,96" und 1,3") | Einfarbig (weiß, blau, gelb-blau) | I2C oder SPI | 2 (I2C) / 5 (SPI) | 10–25 mA | Günstig |
| TFT ILI9341 | 240×320 (2,4–3,2") | 65.000 Farben | SPI oder 8 Bit parallel | 5 (SPI) | 50–100 mA | Mittel |
| TFT ST7789 | 240×240, 240×320, 135×240 | 65.000 Farben | SPI | 4–5 | 30–80 mA | Mittel |
| E-Paper (E-Ink) | 200×200, 296×128, 250×122 | Schwarz-weiß (manche rot/gelb) | SPI | 6 (mit BUSY) | 5–20 mA nur beim Auffrischen | Mittel bis teuer |
| 7-Segment / TM1637 | 1–8 Stellen | Einfarbige LED | Direkt oder 2 Leitungen (TM1637) | 8–12 / 2 | 20–80 mA | Sehr günstig |
| MAX7219-LED-Matrix | 8×8, verkettet 32×8 und mehr | Einfarbige LED | 3 Leitungen (SPI-ähnlich) | 3 | 20–300 mA je nach Helligkeit | Günstig |
| Nextion HMI | 320×240 bis 800×480 | 65.000 Farben, Touch | UART (TX/RX) | 2 | 90–500 mA | Teuer |
Die Zahl der "Datenpins" in der Tabelle enthält keine Versorgung (VCC und GND). Die Stromwerte schwanken stark mit Hintergrundlicht und Helligkeit; E-Paper zieht nur Strom, während sich das Bild ändert, und verbraucht danach fast nichts. Die Preise sind relativ zueinander geordnet: Für den Preis eines Nextion bekommst du etwa zehn 16x2-LCDs.
Worauf du bei der Wahl eines Displays achten solltest
- Was willst du anzeigen? Nur Zahlen: 7-Segment; ein paar Zeilen Text: Text-LCD; Grafiken und Symbole: OLED; farbige Oberfläche oder Fotos: TFT.
- Wo wird es abgelesen? E-Paper und LCD sind in der Sonne gut lesbar, OLED und TFT tun sich bei hellem Licht schwer. Im Dunkeln dagegen ist das Schwarz eines OLED wirklich schwarz und schont die Augen.
- Wie viele Pins sind frei? I2C-Displays kommen mit zwei Leitungen aus; ein paralleles LCD braucht sechs, ein SPI-TFT fünf und E-Paper sechs. Zur Pin-Rechnung siehe die Beiträge I2C und SPI.
- Reicht der Speicher deines Boards? Die 2 KB RAM des Uno fassen einen OLED-Puffer gerade so, einen Farb-TFT-Puffer nie. Beim ESP32 und Pico ist das kaum ein Thema.
- Läuft es mit Batterie? E-Paper, das sein Bild ohne Energie hält, ist für monatelang laufende Sensoren unschlagbar.
- Spannungspegel: Die meisten TFT- und E-Paper-Module arbeiten mit 3,3-V-Logik; am Uno brauchst du eventuell einen Pegelwandler.
- Bibliotheksunterstützung: Displays, die mit verbreiteten Bibliotheken wie Adafruit GFX, U8g2, TFT_eSPI und LiquidCrystal_I2C laufen, erleichtern die Suche nach Beispielen und die Fehlersuche enorm.
Text-LCD: 16x2 und 20x4
Text-LCDs mit dem Controller HD44780 sind die klassische Arduino-Anzeige. Jedes Zeichen besteht aus 5×8 Punkten; das 16x2-Modell zeigt 2 Zeilen mit je 16 Zeichen, das 20x4-Modell 4 Zeilen mit je 20. Weil der Controller des Displays das Bild selbst speichert, verbraucht es auf dem Arduino fast keinen RAM. Direkt angeschlossen braucht es 6 Pins (RS, E und D4–D7) und ein Potentiometer für den Kontrast; diese Methode erklären wir im Beitrag 16x2-LCD parallel anschließen. Mit einem aufgelöteten I2C-Adapter auf Basis des PCF8574 genügen SDA und SCL. Bis zu 8 eigene Zeichen lassen sich definieren, etwa ein Gradzeichen, ein Batteriesymbol oder Umlaute. Ausführlich geht es im Beitrag I2C-LCD-Display weiter.
1// I2C 16x2 LCD: sıcaklık gibi bir değeri göstermek / I2C 16x2 LCD: showing a value such as temperature
2// SDA -> A4, SCL -> A5, VCC -> 5V, GND -> GND
3#include <Wire.h>
4#include <LiquidCrystal_I2C.h>
5
6LiquidCrystal_I2C lcd(0x27, 16, 2); // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8byte degree[8] = { // kendi karakterin: derece işareti / custom character: degree sign
9 0b00110, 0b01001, 0b01001, 0b00110,
10 0b00000, 0b00000, 0b00000, 0b00000
11};
12
13void setup() {
14 lcd.init();
15 lcd.backlight();
16 lcd.createChar(0, degree); // 8 özel karakterden ilki / first of 8 custom characters
17 lcd.setCursor(0, 0);
18 lcd.print("BlueGrays LCD");
19}
20
21void loop() {
22 int raw = analogRead(A0); // A0'a bağlı bir sensör / a sensor on A0
23 float value = raw * 100.0 / 1023.0;
24 lcd.setCursor(0, 1);
25 lcd.print("Deger: ");
26 lcd.print(value, 1);
27 lcd.write(byte(0)); // derece işaretini yaz / print the degree sign
28 lcd.print(" "); // eski karakterleri sil / clear leftover characters
29 delay(500);
30}OLED: SSD1306 und SH1106

Bei OLED-Displays erzeugt jedes Pixel sein eigenes Licht; es gibt keine Hintergrundbeleuchtung, der Kontrast ist sehr hoch und das Bild ist aus jedem Winkel scharf. Die 0,96-Zoll-Modelle haben meist einen SSD1306, die 1,3-Zoll-Modelle meist einen SH1106. Von außen sehen beide gleich aus, aber der interne Speicher des SH1106 hat 132 Spalten; wird ein SH1106 mit einer SSD1306-Bibliothek betrieben, verschiebt sich das Bild um zwei Pixel und am Rand erscheint ein verrauschter Streifen. Die Lösung ist eine Bibliothek bzw. ein Konstruktor passend zum Treiber. Die Bibliothek U8g2 unterstützt beide und kommt dank Seitenmodus auf dem Uno mit nur 128 Byte Puffer aus. Die Grundlagen zum SSD1306 findest du im Beitrag OLED-Display (SSD1306).
1// U8g2 ile 1,3" SH1106 OLED (sayfa modu, Uno'da az RAM) / 1.3" SH1106 OLED with U8g2 (page mode, low RAM on the Uno)
2// SDA -> A4, SCL -> A5. 0,96" SSD1306 için yorumdaki satırı kullan / for a 0.96" SSD1306 use the commented line
3#include <U8g2lib.h>
4#include <Wire.h>
5
6U8G2_SH1106_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
7// U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
8
9void setup() {
10 oled.begin();
11}
12
13void loop() {
14 int level = map(analogRead(A0), 0, 1023, 0, 120); // A0'daki potansiyometre / potentiometer on A0
15 oled.firstPage();
16 do { // her sayfa için aynı çizim tekrarlanır / the same drawing repeats per page
17 oled.setFont(u8g2_font_ncenB08_tr);
18 oled.drawStr(0, 12, "BlueGrays OLED");
19 oled.drawFrame(0, 40, 124, 14); // çubuk çerçevesi / bar frame
20 oled.drawBox(2, 42, level, 10); // dolu çubuk / filled bar
21 } while (oled.nextPage());
22 delay(100);
23}Das _1_ im Namen des Konstruktors bedeutet, dass der Bildschirm in Seiten zu 8 Zeilen gezeichnet wird: Die Schleife aus firstPage() und nextPage() wiederholt dieselbe Zeichnung achtmal und sendet jedes Mal einen Streifen des Bildschirms. Das ist etwas langsamer, belegt aber 128 Byte statt 1 KB RAM. Auf ESP32 und Pico mit reichlich Speicher wählst du die Vollpuffer-Variante _F_ und bekommst flüssigere Animationen.
Farb-TFT: ILI9341 und ST7789

Willst du Grafiken, Menüs, Symbole und farbige Anzeigen, steigst du auf TFT-Displays um. Jedes Pixel trägt 16-Bit-Farbe (RGB565), also etwa 65.000 Farben. Die beiden häufigsten Treiber sind ILI9341 und ST7789. Der ILI9341 steckt in 240×320-Displays von 2,4 bis 3,2 Zoll und kommt oft mit einem XPT2046-Touch-Controller. Den ST7789 findest du in quadratischen 1,3- und 1,54-Zoll-Displays (240×240) und in 135×240-Displays auf Boards wie dem TTGO T-Display. Am Uno laufen sie, aber langsam: Schon das einmalige Füllen des ganzen Bildschirms dauert sichtbar. Auf dem ESP32 sind mit 40 MHz SPI und optimierten Bibliotheken wie TFT_eSPI flüssige Oberflächen möglich. Details in den Beiträgen ILI9341-TFT-Display und ST7789-TFT-Display.
| Merkmal | ILI9341 | ST7789 |
|---|---|---|
| Übliche Größen | 2,4", 2,8", 3,2" | 1,14", 1,3", 1,54", 2,0" |
| Auflösung | 240×320 | 135×240, 240×240, 240×320 |
| Schnittstelle | SPI (Uno-Shield-Varianten 8 Bit parallel) | SPI (manche Modelle ohne CS-Pin) |
| Touch | Bei den meisten Modellen resistiver Touch mit XPT2046 | Meist keiner |
| Bibliothek | Adafruit_ILI9341, TFT_eSPI | Adafruit_ST7789, TFT_eSPI |
| Größe eines Vollbildpuffers | 153.600 Byte | 115.200 Byte (240×240) |
1// ESP32 + 2,8" ILI9341 TFT: renkli sıcaklık göstergesi / colour temperature gauge
2// SCK 18, MOSI 23, MISO 19 (isteğe bağlı / optional), CS 5, DC 16, RST 17, VCC 3V3, LED 3V3
3#include <SPI.h>
4#include <Adafruit_GFX.h>
5#include <Adafruit_ILI9341.h>
6
7const int TFT_CS = 5;
8const int TFT_DC = 16;
9const int TFT_RST = 17;
10
11Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST); // donanım SPI (VSPI) / hardware SPI (VSPI)
12
13void setup() {
14 tft.begin(40000000); // 40 MHz SPI
15 tft.setRotation(1); // yatay 320x240 / landscape 320x240
16 tft.fillScreen(ILI9341_BLACK);
17 tft.setTextColor(ILI9341_WHITE);
18 tft.setTextSize(2);
19 tft.setCursor(10, 10);
20 tft.print("BlueGrays TFT");
21 tft.drawRect(10, 180, 300, 30, ILI9341_WHITE); // çubuk çerçevesi / bar frame
22}
23
24void loop() {
25 float temp = 20.0 + (analogReadMilliVolts(34) / 3300.0) * 20.0; // örnek değer / example value
26 uint16_t color = temp < 26 ? ILI9341_GREEN : (temp < 33 ? ILI9341_YELLOW : ILI9341_RED);
27
28 tft.fillRect(10, 60, 300, 80, ILI9341_BLACK); // yalnız değişen alanı sil / clear only the changing area
29 tft.setTextSize(6);
30 tft.setTextColor(color);
31 tft.setCursor(20, 70);
32 tft.print(temp, 1);
33 tft.print(" C");
34
35 int w = (int)((temp - 20.0) / 20.0 * 296);
36 tft.fillRect(12, 182, w, 26, color);
37 tft.fillRect(12 + w, 182, 296 - w, 26, ILI9341_BLACK);
38 delay(500);
39}E-Paper-Displays (E-Ink)
E-Paper ist die Displaytechnik der E-Book-Reader. Das Bild entsteht, indem winzige schwarze und weiße Pigmentkapseln per elektrischem Feld bewegt werden; ist es einmal gezeichnet, bleibt es auch ohne Strom stehen. Zusammen mit dem Deep Sleep des ESP32 ist es damit ideal für Stationen, die einmal pro Stunde aufwachen, das Wetter aktualisieren und monatelang mit Batterie laufen. Weil es wie Papier aussieht, ist es in der Sonne perfekt lesbar. Der Nachteil ist die Geschwindigkeit: Ein vollständiges Auffrischen dauert etwa 2 Sekunden, und der Bildschirm blinkt mehrmals; bei Modellen mit Teilauffrischung sinkt das auf unter eine halbe Sekunde, häufige Teilauffrischungen können aber blasse Geisterbilder hinterlassen. Der Anschluss erfolgt per SPI mit MOSI, SCK, CS, DC, RST und einem BUSY-Pin, der meldet, dass das Display beschäftigt ist. Die verbreitetste Bibliothek ist GxEPD2.
| Merkmal | Wert |
|---|---|
| Übliche Größen | 1,54" (200×200), 2,13" (250×122), 2,9" (296×128), 4,2" (400×300) |
| Farbe | Schwarz-weiß; dreifarbige Modelle zusätzlich rot oder gelb (10–15 Sekunden Auffrischung) |
| Vollständige Auffrischung | Etwa 1–3 Sekunden |
| Teilauffrischung | 0,3–0,5 Sekunden bei unterstützten Modellen |
| Ruhestrom | Nahezu null, während das Bild gehalten wird |
| Versorgung | 3,3 V (die meisten Module akzeptieren über einen Regler auch 5 V) |
7-Segment- und TM1637-Anzeigen

Musst du nur Zahlen anzeigen, sind 7-Segment-Anzeigen immer noch am besten lesbar: groß, hell und auf Meter zu sehen. Eine einstellige Anzeige braucht 8 Pins für die 7 Segmente und den Punkt sowie je Segment einen Widerstand; eine gemultiplexte 4-stellige Anzeige belegt 12 Pins. Diese Verdrahtung und den Unterschied zwischen gemeinsamer Anode und Kathode erklären wir im Beitrag 7-Segment-Anzeige. Am einfachsten entkommst du dem Pin-Problem mit dem TM1637-Modul: Die 4-stellige Anzeige mit eigenem Treiber hängt nur an CLK und DIO, die Helligkeit stellst du per Software in 8 Stufen ein. Das TM1637-Protokoll ähnelt I2C, nutzt aber keine Adressen; deshalb passt es an zwei beliebige Digitalpins und jedes Modul braucht sein eigenes Pinpaar.
1// TM1637 4 haneli gösterge ile sayaç ve saat / Counter and clock with a TM1637 4-digit display
2// CLK -> D2, DIO -> D3, VCC -> 5V, GND -> GND
3#include <TM1637Display.h>
4
5TM1637Display display(2, 3); // CLK, DIO
6unsigned long lastTick = 0;
7int seconds = 0;
8
9void setup() {
10 display.setBrightness(4); // 0 (sönük) - 7 (en parlak) / 0 (dim) - 7 (brightest)
11 display.clear();
12}
13
14void loop() {
15 if (millis() - lastTick >= 1000) {
16 lastTick = millis();
17 seconds++;
18 int mm = (seconds / 60) % 100;
19 int ss = seconds % 60;
20 // 0b01000000: ortadaki iki nokta / the colon in the middle
21 display.showNumberDecEx(mm * 100 + ss, 0b01000000, true);
22 }
23}MAX7219-LED-Matrix

Der MAX7219 treibt allein 64 LEDs (eine 8×8-Matrix oder eine 8-stellige 7-Segment-Anzeige) und kommuniziert über drei Leitungen, DIN, CLK und CS, mit einem SPI-ähnlichen Protokoll. Module lassen sich verketten; mit den verbreiteten 4-in-1-Modulen entstehen 32×8-, mit zwei Reihen 32×16-Laufschriften. Helligkeit und Fernwirkung machen ihn ideal für Anzeigetafeln, Spielstände und Uhren. Am Arduino werden meist die Bibliotheken MD_Parola und MD_MAX72XX genutzt; Details im Beitrag MAX7219-LED-Matrix. Unten treiben wir eine einzelne 8×8-Matrix mit dem Raspberry Pi Pico ohne Bibliothek und schreiben direkt in die Register:
1# Raspberry Pi Pico: kütüphanesiz MAX7219 8x8 matris / MAX7219 8x8 matrix without a library
2# GP18 -> CLK, GP19 -> DIN, GP17 -> CS, VCC -> VBUS (5 V), GND -> GND
3from machine import Pin, SPI
4import time
5
6spi = SPI(0, baudrate=1_000_000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
7cs = Pin(17, Pin.OUT, value=1)
8
9def write_reg(reg, value):
10 cs.value(0)
11 spi.write(bytearray([reg, value])) # önce yazmaç, sonra değer / register first, then value
12 cs.value(1)
13
14def init():
15 write_reg(0x0F, 0x00) # test modu kapalı / display test off
16 write_reg(0x09, 0x00) # kod çözme yok (matris) / no decode (matrix)
17 write_reg(0x0B, 0x07) # 8 satırın hepsi / scan all 8 rows
18 write_reg(0x0A, 0x03) # parlaklık 0-15 / brightness 0-15
19 write_reg(0x0C, 0x01) # uyku modundan çık / leave shutdown mode
20
21SMILE = [0x3C, 0x42, 0xA5, 0x81, 0xA5, 0x99, 0x42, 0x3C]
22HEART = [0x00, 0x66, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18]
23
24def show(image):
25 for row in range(8):
26 write_reg(row + 1, image[row]) # satır yazmaçları 1-8 / row registers 1-8
27
28init()
29while True:
30 show(SMILE)
31 time.sleep(1)
32 show(HEART)
33 time.sleep(1)Damit die LEDs des MAX7219 hell leuchten, braucht er 5 V; deshalb geht VCC des Moduls an den VBUS-Pin des Pico. Laut Datenblatt müssen die Eingänge bei 5 V Versorgung mindestens 3,5 V sehen, um als HIGH zu gelten; die 3,3-V-Signale des Pico funktionieren bei den meisten Modulen problemlos, siehst du aber Instabilität, setze einen Pegelwandler in die Leitungen DIN, CLK und CS. Der Strom steigt mit Helligkeit und Zahl der leuchtenden LEDs: Leuchten alle vier Module voll auf, können Hunderte Milliampere fließen.
Nextion-Touch-HMI-Displays
Nextion ist ein intelligentes Touchdisplay mit eigenem Prozessor und Speicher. Die Oberfläche mit Tasten, Schiebereglern und Anzeigen entwirfst du am Rechner im Nextion Editor per Drag-and-drop und lädst sie auf das Display; der Arduino schickt über die serielle Schnittstelle (UART) nur kurze Befehle wie t0.txt="25" und liest die Touch-Ereignisse. So liegt die gesamte Zeichenarbeit beim Display, und selbst ein kleines Board wie der Uno kann eine farbige 7-Zoll-Oberfläche steuern. Die Standardgeschwindigkeit ist 9600 Baud. Nachteile sind der Preis, ein Strom von 90 mA schon beim 2,4-Zoll-Modell und bis zu 500 mA beim 7-Zoll-Modell sowie die Gestaltung in einem separaten Programm. Beim Uno teilt sich die Hardware-Seriell-Schnittstelle die Leitung mit USB; SoftwareSerial oder Boards mit mehreren seriellen Schnittstellen wie Mega und ESP32 machen es einfacher.
Speicherbedarf: welches Display passt auf einen Uno?
Die meisten Grafikbibliotheken zeichnen das Bild zuerst in einen Puffer im RAM und schicken ihn dann komplett ans Display. Puffergröße = Breite × Höhe × Bits pro Pixel / 8. Bedenkt man, dass der Arduino Uno nur 2 KB RAM hat und davon ein Teil für Variablen, serielle Schnittstelle und Bibliotheken draufgeht, wird die Grenze sofort sichtbar. Allgemeine Lösungen für Speicherprobleme haben wir im Beitrag Arduino: Speicher reicht nicht gesammelt.
| Display | Vollpuffer | Arduino Uno (2 KB) | ESP32 (520 KB) / Pico (264 KB) |
|---|---|---|---|
| 16x2-LCD | Nicht nötig (das Display speichert) | Problemlos | Problemlos |
| OLED 128×64 | 1.024 Byte | Knapp; Seitenmodus (128 Byte) empfohlen | Problemlos |
| OLED 128×32 | 512 Byte | Problemlos | Problemlos |
| E-Paper 296×128 | 4.736 Byte | Nur mit seitenweisem Zeichnen | Problemlos |
| TFT ST7789 240×240 | 115.200 Byte | Unmöglich; es wird direkt aufs Display gezeichnet | Auf dem ESP32 möglich, beim Pico die Hälfte des RAM |
| TFT ILI9341 240×320 | 153.600 Byte | Unmöglich; es wird direkt aufs Display gezeichnet | Möglich, meist nimmt man aber kleine Sprites |
Stromverbrauch und Batteriebetrieb
In einem batteriebetriebenen Projekt verbraucht das Display oft mehr Energie als der Mikrocontroller. Allein die Hintergrundbeleuchtung eines 16x2-LCD kann über 20 mA ziehen; schaltest du sie aus (lcd.noBacklight()), ist die Anzeige in der Sonne noch lesbar, im Dunkeln aber nicht. Der Strom eines OLED ist proportional zur Zahl leuchtender Pixel: dünne weiße Schrift auf schwarzem Grund verbraucht ein Mehrfaches weniger als ein weißer Hintergrund. Bei TFTs leuchten die Hintergrund-LEDs ständig; den Pin der Hintergrundbeleuchtung per Transistor oder PWM zu steuern spart viel. E-Paper zieht praktisch keinen Strom, solange du das Bild nicht änderst. Zur Berechnung der Laufzeit nutzt du die Methode aus dem Beitrag mAh.
Welches Display für welches Projekt?
| Projekt | Empfohlenes Display | Warum? |
|---|---|---|
| Anzeige für Temperatur und Luftfeuchte | 16x2-I2C-LCD oder 0,96"-OLED | Günstig, zwei Leitungen, einige Zeilen Text genügen |
| Digitaluhr und Countdown | TM1637 oder MAX7219 | Große, helle Ziffern; aus der Ferne lesbar |
| Taschenspiel (Pong, Snake, T-Rex) | OLED 128×64 oder 8×8-Matrix | Schnelles Auffrischen, Zeichnen auf Pixelebene |
| Wetterstation (Batterie) | E-Paper + ESP32-Deep-Sleep | Das Bild bleibt ohne Energie stehen, in der Sonne lesbar |
| Farbiges Bedienfeld und Menü | ILI9341 mit Touch oder Nextion | Farbe, Symbole und Touch-Eingabe |
| Laufschrift und Anzeigetafel | Verkettete MAX7219-Module | Auf Meter sichtbar, wächst an einem CS |
| Kompaktes ESP32-Gerät | ST7789 1,14" oder 1,3" | Klein, farbig und über SPI schnell |
Häufige Fehler und Lösungen
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Das LCD zeigt nur volle Kästchen | Kontrast nicht eingestellt oder Display nicht initialisiert | Kontrastpoti drehen, Adresse und Aufruf von lcd.init() prüfen |
| Bild verschoben, Rauschen am Rand beim 1,3"-OLED | Ein SH1106 wird mit einer SSD1306-Bibliothek betrieben | In U8g2 den SH1106-Konstruktor oder die Bibliothek Adafruit SH110X nutzen |
| Der OLED-Sketch wird hochgeladen, aber der Uno hängt | Der Displaypuffer hat den RAM aufgebraucht | U8g2-Seitenmodus nutzen, Texte in F() packen |
| Das TFT bleibt weiß | Falscher Treiber, falsche Pins oder 5-V-Signal | Treiber (ILI9341, ST7789) prüfen, DC- und CS-Pin kontrollieren, auf 3,3-V-Pegel achten |
| Das E-Paper ändert sich nie | BUSY-Pin nicht angeschlossen oder falsches Modell gewählt | BUSY anschließen, in GxEPD2 die genaue Modellklasse wählen |
| Einige Segmente der 7-Segment-Anzeige sind schwach | Gemeinsame Anode und Kathode verwechselt oder Widerstand fehlt | Anzeigetyp prüfen, an jedes Segment einen Widerstand setzen |
| Der MAX7219 lässt zufällige LEDs leuchten | Lose Leitung, schwache Versorgung oder 3,3-V-Signal an der Grenze | Leitungen kürzen, 5-V-Versorgung verstärken, bei Bedarf Pegelwandler ergänzen |
Das richtige Display hängt davon ab, was dein Projekt zeigt, wo es abgelesen wird und womit es versorgt wird: LCD für Text, OLED für kleine Grafiken, TFT oder Nextion für farbige Oberflächen, E-Paper für Batteriegeräte, 7-Segment und MAX7219 für große Ziffern. In der BlueGrays-App findest du Projekte mit I2C-LCD, OLED-Spielen und Wetteranzeige, TM1637-Uhr und MAX7219-Punktmatrix, Schritt für Schritt mit Schaltplan und Code.
Häufige Fragen
Welches ist das beste Display für Arduino?
Das eine beste Display gibt es nicht; die Wahl hängt vom Projekt ab. Für einige Zeilen Text passt ein 16x2-I2C-LCD, für kleine Grafiken ein 0,96-Zoll-OLED, für farbige Oberflächen ein ILI9341-TFT und für Batteriegeräte E-Paper.
Ist OLED oder LCD besser?
Ein OLED ist schärfer, kontrastreich, kann Grafiken zeichnen und ist im Dunkeln perfekt lesbar. Ein Text-LCD ist günstiger, in der Sonne besser lesbar und verbraucht auf dem Arduino fast keinen RAM.
Kann ein Arduino Uno ein Farb-TFT betreiben?
Ja, SPI-TFTs wie ILI9341 oder ST7789 laufen am Uno, aber weil der RAM für einen Vollbildpuffer nicht reicht, wird direkt und langsam aufs Display gezeichnet. Für flüssige Farboberflächen sind ESP32 oder Raspberry Pi Pico die bessere Wahl.
Was ist der Unterschied zwischen SSD1306 und SH1106?
Beide sind 128×64-OLED-Treiber; der SSD1306 steckt meist in 0,96-Zoll-, der SH1106 in 1,3-Zoll-Displays. Weil der Speicher des SH1106 132 Spalten hat, verschiebt sich das Bild mit einer SSD1306-Bibliothek; nötig ist eine passende Bibliothek wie U8g2 oder Adafruit SH110X.
Behält ein E-Paper-Display sein Bild ohne Strom?
Ja. E-Paper erzeugt das Bild durch das Bewegen von Pigmentkapseln, und ein gezeichnetes Bild bleibt ganz ohne Energie stehen. Deshalb ist es ideal für batteriebetriebene Geräte, die sich einmal pro Stunde aktualisieren.
Ist der TM1637 ein I2C-Baustein?
Nein. Das Zweidrahtprotokoll des TM1637 ähnelt I2C, nutzt aber keine Adressen und gehört nicht an einen I2C-Bus. Er hängt an zwei beliebigen Digitalpins und wird mit eigener Bibliothek (z. B. TM1637Display) betrieben; mehrere Module brauchen je ein eigenes Pinpaar.
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…

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…

ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.

ESP32 TM1637 4-stellige 7-Segment-Anzeige
Wir steuern das 4-stellige 7-Segment-Anzeigemodul mit TM1637-Treiber über einen ESP32. Mit nur 2 GPIO-Pins (CLK und DIO) betreiben wir einen Zähler im Bereich von 0 bis 9999, stellen die Helligkeit ein und zeigen das Zeichen „:“ (zwei Punkte) in der Mitte im Uhrzeitformat an. Dank der TM1637Display-Bibliothek ist die Steuerung von Zahlen, Hexadezimalwerten, Segmenten und Zeichenfolgen sehr einfach.

Punktmatrixuhr und Kalender (MAX7219, DS1307)
Eine leuchtende Tafel für Tisch oder Wand, die Uhrzeit und Datum als Laufschrift zeigt.

Digitaluhr mit 4-stelliger 7-Segment-Anzeige
Eine leuchtende vierstellige Digitaluhr, ähnlich wie die am Backofen. Das Uhrmodul DS1302 hält die Zeit, der Arduino liest jede Sekunde Stunden und Minuten aus und zeigt sie auf der vierstelligen…
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

