LCD 16x2 am Arduino anschließen: ohne I2C im 4-Bit-Modus
LCD 16x2 ohne I2C-Modul an den Arduino anschließen: die 16 Pins, 4-Bit-Modus, Kontrast, LiquidCrystal, Hilfe bei schwarzen Kästchen und das 20x4-LCD.
Wenn du ein LCD 16x2 ohne I2C-Modul an den Arduino anschließt, nutzt du 12 der 16 Pins des Displays: Sechs gehen an Digitalpins des Arduino, der Rest dient Versorgung, Kontrast und Hintergrundbeleuchtung. Das klingt nach vielen Kabeln, aber so verstehst du wirklich, wie das Display arbeitet, musst keine I2C-Adresse suchen, bist schneller als mit I2C und kommst auch ohne I2C-Modul weiter. Die meisten LCDs in Arduino-Starterkits werden ohnehin ohne I2C-Modul geliefert.
In dieser Anleitung lernst du die Aufgabe jedes der 16 Pins kennen, warum wir nur 4 Datenleitungen (4-Bit-Modus) nutzen, wie das Kontrastpoti angeschlossen wird und welche Befehle die Bibliothek LiquidCrystal bietet. Danach entwirfst du eigene Zeichen für einen Balken, der sich mit einem Poti füllt, steigst auf ein 20x4-LCD um und nutzt dasselbe Display mit ESP32 und Raspberry Pi Pico. Am Ende findest du Lösungen für die häufigsten Probleme wie "schwarze Kästchen" und "leeres Display" und erfährst, wann sich der Umstieg auf ein I2C-Modul lohnt.

Wie funktioniert ein 16x2-LCD?
Der schwarze, tropfenförmige Chip auf der Rückseite ist der Treiber HD44780 (oder ein exakter Nachbau), die gemeinsame Sprache fast aller Zeichen-LCDs. Der Arduino schickt ihm zwei Arten von Bytes: Befehle (Display löschen, Cursor an diese Stelle setzen, Display einschalten) und Zeichen (der Code des anzuzeigenden Buchstabens). Der RS-Pin sagt, was gesendet wird: Bei RS LOW ist das Byte ein Befehl, bei RS HIGH ein Zeichen. Der E-Pin (Enable) ist das Signal "Daten bereit, jetzt lesen": Nachdem ein Byte auf den Datenleitungen liegt, wird E kurz auf HIGH gesetzt, und der Chip übernimmt das Byte bei der fallenden Flanke. Im Chip stecken ein Bildschirmspeicher für 80 Zeichen (DDRAM), ein Zeichensatz-ROM mit 208 eingebauten Zeichen und ein kleiner Speicher (CGRAM) für 8 eigene Zeichen.
| Merkmal | Wert |
|---|---|
| Treiberchip | HD44780 oder kompatibel (KS0066, SPLC780) |
| Anzeige | 16 Spalten × 2 Zeilen, je Zeichen 5 × 8 Pixel |
| Versorgung | 4,5–5,5 V (es gibt auch spezielle 3,3-V-Versionen) |
| Logikstrom | Etwa 1–2 mA |
| Strom der Beleuchtung | Etwa 15–30 mA (LED, je nach Modell) |
| Datenbus | 8 Bit oder 4 Bit parallel |
| Eigene Zeichen | 8 (CGRAM) |
| Befehlsdauer | Meist 37 µs, clear() und home() etwa 1,5 ms |
Die Aufgabe der 16 Pins
| Pin | Name | Funktion | Anschluss |
|---|---|---|---|
| 1 | VSS | Masse | GND |
| 2 | VDD | Logikversorgung | 5V |
| 3 | V0 (VO, VEE) | Kontrasteinstellung | Schleifer eines 10-kΩ-Potis |
| 4 | RS | Auswahl Befehl (LOW) oder Zeichen (HIGH) | Arduino D12 |
| 5 | RW | Lesen (HIGH) oder Schreiben (LOW) | GND (wir schreiben nur) |
| 6 | E | Impuls für gültige Daten | Arduino D11 |
| 7–10 | D0–D3 | Untere Datenbits | Im 4-Bit-Modus frei |
| 11 | D4 | Datenbit 4 | Arduino D5 |
| 12 | D5 | Datenbit 5 | Arduino D4 |
| 13 | D6 | Datenbit 6 | Arduino D3 |
| 14 | D7 | Datenbit 7 | Arduino D2 |
| 15 | A (LED+) | Anode der Beleuchtung | Über 220 Ω an 5V |
| 16 | K (LED−) | Kathode der Beleuchtung | GND |
4-Bit-Modus: warum 4 statt 8 Datenleitungen?
Der HD44780 kann ein Byte entweder auf einmal über 8 Datenleitungen (8-Bit-Modus) oder in zwei Hälften über D4–D7 (4-Bit-Modus) übernehmen. Im 4-Bit-Modus kommt zuerst die obere, dann die untere Hälfte, und für jede Hälfte wird E einmal gepulst. Das dauert doppelt so lange, fällt in der Praxis aber nicht auf: Ein Zeichen braucht weiterhin etwa 50 µs, und das ganze Display ist in weniger als 2 ms neu beschrieben. Dafür werden am Arduino vier Pins frei. Die Bibliothek LiquidCrystal wählt den 4-Bit-Modus automatisch, wenn du dem Konstruktor sechs Pins übergibst; D0–D3 offen zu lassen ist unbedenklich, da der Chip dort interne Pull-ups hat.
Das Kontrastpoti

Ob überhaupt Text zu sehen ist, entscheidet die Spannung an V0. Den Flüssigkristall dreht die Differenz zwischen VDD und V0; bei üblichen 5-V-Modulen ergibt sich das beste Bild meist bei V0 um 0,3–1 V. Geht V0 gegen 0 V, wird auch der Hintergrund der Zeichen dunkel, und leere Felder erscheinen als schwarze Kästchen; geht V0 gegen 5 V, verschwindet der Text ganz. Für den ersten Aufbau ist ein Potentiometer deshalb am praktischsten: einen äußeren Anschluss an 5V, den anderen an GND, den mittleren an V0, und langsam drehen, bis die Schrift scharf ist. Kennst du die Einstellung, kannst du das Poti durch einen Festwiderstand ersetzen: 1–2,2 kΩ zwischen V0 und GND passen bei den meisten Modulen.
Schritt für Schritt: der erste Text mit dem Arduino
- Löte eine 16-polige Stiftleiste an das LCD und stecke das Display ins Steckbrett; auf einem langen Steckbrett bleibt links und rechts Platz für Kabel.
- Führe 5V und GND des Arduino auf die Versorgungsschienen. Verbinde die LCD-Pins 1 (VSS) und 16 (K) mit GND, Pin 2 (VDD) mit 5V und Pin 15 (A) über 220 Ω mit 5V. Steckst du den Arduino an USB, muss die Beleuchtung angehen.
- Schließe das Poti an und drehe daran. Schon ohne Code sollten in der oberen Zeile 16 schwarze Kästchen erscheinen; das zeigt, dass Display und Kontrast funktionieren.
- Verbinde Pin 5 (RW) mit GND. Danach RS mit D12, E mit D11 und D4–D7 der Reihe nach mit D5, D4, D3 und D2.
- Prüfe im Bibliotheksverwalter, ob LiquidCrystal installiert ist (sie kommt mit der Arduino IDE), und lade den Code unten hoch.
- Verschwinden die Kästchen und erscheint der Text, stellst du den Kontrast am Poti ein letztes Mal nach.
1// 16x2 LCD, I2C modülü olmadan (4-bit mod) / 16x2 LCD without an I2C module (4-bit mode)
2// RS -> D12, E -> D11, D4 -> D5, D5 -> D4, D6 -> D3, D7 -> D2, RW -> GND, V0 -> pot
3#include <LiquidCrystal.h>
4
5const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
6LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
7
8void setup() {
9 lcd.begin(16, 2); // 16 sütun, 2 satır / 16 columns, 2 rows
10 lcd.print(F("Merhaba Arduino!"));
11 lcd.setCursor(0, 1); // sütun 0, satır 1 / column 0, row 1
12 lcd.print(F("Sure:"));
13}
14
15void loop() {
16 unsigned long s = millis() / 1000;
17 lcd.setCursor(6, 1);
18 lcd.print(s);
19 lcd.print(F(" sn ")); // eski haneleri boşlukla sil / overwrite old digits with spaces
20 delay(200);
21}Im Code stecken zwei kleine, aber wichtige Gewohnheiten. Erstens springt er vor dem Schreiben des veränderlichen Werts mit setCursor() an die Stelle, statt clear() aufzurufen, und hängt ein paar Leerzeichen an die Zahl. clear() ist ein schwerer Befehl mit etwa 1,5 ms und lässt das Display in der Schleife flackern; außerdem muss nicht der ganze Bildschirm gelöscht und neu geschrieben werden. Die Leerzeichen verhindern, dass eine alte Ziffer stehen bleibt, wenn die Zahl kürzer wird (etwa von 100 auf 99). Zweitens stehen feste Texte im F()-Makro und liegen so im Programmspeicher statt im RAM. Auf ein 16x2-Display passen höchstens 16 Zeichen pro Zeile; längerer Text läuft rechts aus dem Bild.
| Befehl | Was er tut |
|---|---|
| lcd.begin(16, 2) | Startet das Display und legt Spalten und Zeilen fest |
| lcd.print(wert) | Schreibt Text, ganze Zahl oder Kommazahl; lcd.print(3.14159, 2) zeigt zwei Nachkommastellen |
| lcd.setCursor(spalte, zeile) | Wählt die Schreibposition; gezählt wird ab 0 |
| lcd.clear() | Löscht das Display und setzt den Cursor zurück (dauert 1,5 ms) |
| lcd.cursor() / lcd.noCursor() | Zeigt oder verbirgt den Unterstrich-Cursor |
| lcd.blink() / lcd.noBlink() | Schaltet den blinkenden Block-Cursor ein oder aus |
| lcd.display() / lcd.noDisplay() | Schaltet die Anzeige ein oder aus, ohne den Speicher zu löschen |
| lcd.scrollDisplayLeft() | Schiebt das ganze Display um eine Spalte nach links |
| lcd.createChar(nr, feld) | Lädt ein eigenes Zeichen in Platz 0–7 |
| lcd.write(byte(nr)) | Schreibt ein eigenes Zeichen oder einen ROM-Code |
Eigene Zeichen: ein Balken, der sich mit dem Poti füllt
Jede Zeichenzelle ist ein Pixelraster aus 5 Spalten und 8 Zeilen. Für ein eigenes Zeichen schreibst du jede Zeile als 5-Bit-Zahl: 1 bedeutet ein leuchtendes, 0 ein dunkles Pixel. Der HD44780 erlaubt 8 eigene Zeichen gleichzeitig. Das folgende Beispiel nutzt fünf dieser Plätze für Blöcke, in denen von links 1, 2, 3, 4 und 5 Spalten gefüllt sind. Mit 16 Zellen × 5 Spalten entsteht ein Balken mit 80 Stufen, der sich mit dem Poti flüssig füllt und leert; ideal für Lautstärke, Akkustand oder einen Sensorwert in Prozent. Wie man eigene Zeichen für türkische Buchstaben (ş, ğ, ı, ç) entwirft, zeigen wir im Artikel zum I2C-LCD; derselbe Befehl createChar funktioniert am parallelen Anschluss genauso.
1// Özel karakterlerle 80 adımlık çubuk grafik / 80-step bar graph with custom characters
2// Potansiyometre orta ucu -> A0 / potentiometer wiper -> A0
3#include <LiquidCrystal.h>
4
5LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
6
7byte bars[5][8]; // 1..5 sütun dolu bloklar / blocks with 1..5 columns filled
8
9void buildBars() {
10 for (int n = 0; n < 5; n++) {
11 byte row = 0;
12 for (int c = 0; c <= n; c++) row |= (0b10000 >> c); // soldan doldur / fill from the left
13 for (int r = 0; r < 8; r++) bars[n][r] = row;
14 lcd.createChar(n, bars[n]); // karakter 0 = 1 sütun ... 4 = 5 sütun / char 0 = 1 column ... 4 = 5 columns
15 }
16}
17
18void setup() {
19 lcd.begin(16, 2);
20 buildBars();
21 lcd.setCursor(0, 0); // createChar sonrası konum ayarla / set position after createChar
22 lcd.print(F("Seviye / Level"));
23}
24
25void loop() {
26 int raw = analogRead(A0);
27 int steps = map(raw, 0, 1023, 0, 80); // 16 hücre x 5 sütun / 16 cells x 5 columns
28 int percent = map(raw, 0, 1023, 0, 100);
29
30 lcd.setCursor(12, 0);
31 if (percent < 100) lcd.print(' ');
32 if (percent < 10) lcd.print(' ');
33 lcd.print(percent);
34 lcd.print('%');
35
36 lcd.setCursor(0, 1);
37 for (int cell = 0; cell < 16; cell++) {
38 int fill = steps - cell * 5; // bu hücreye düşen sütun / columns in this cell
39 if (fill >= 5) lcd.write(byte(4));
40 else if (fill > 0) lcd.write(byte(fill - 1));
41 else lcd.print(' ');
42 }
43 delay(50);
44}Der Befehl createChar verschiebt den Cursor vom Bildschirmspeicher in den Zeichenspeicher. Nach dem Laden eigener Zeichen musst du deshalb vor dem Schreiben setCursor() aufrufen, sonst erscheint der erste Text eventuell nicht. Die Zeichen liegen nur im CGRAM und gehen beim Abschalten verloren, darum werden sie bei jedem Start in setup() neu geladen. Änderst du die Definition eines eigenen Zeichens, während es angezeigt wird, ändern sich alle Zellen mit diesem Zeichen gleichzeitig; genau mit diesem Trick entstehen kleine Animationen.
20x4-LCD: gleiche Verdrahtung, größere Anzeige
LCDs mit 20 Spalten und 4 Zeilen nutzen denselben HD44780 und dieselben 16 Pins; die Verdrahtung ist identisch, im Code genügt lcd.begin(20, 4). Ihre Beleuchtung zieht etwas mehr Strom (40–60 mA), verkleinere den Vorwiderstand also nicht, damit die 5-V-Schiene des Arduino im Dauerbetrieb entspannt bleibt. Die einzige Eigenheit ist die Zeilenreihenfolge: Im Bildschirmspeicher geht das Ende von Zeile 1 in Zeile 3 weiter und das Ende von Zeile 2 in Zeile 4. Schreibst du langen Text ohne setCursor(), läuft er also von Zeile 1 in Zeile 3 statt in Zeile 2. Ein setCursor(0, zeile) am Anfang jeder Zeile beseitigt das Problem vollständig.
1// 20x4 LCD: aynı bağlantı, begin(20, 4) / 20x4 LCD: same wiring, begin(20, 4)
2#include <LiquidCrystal.h>
3
4LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
5
6void setup() {
7 lcd.begin(20, 4);
8 for (int row = 0; row < 4; row++) {
9 lcd.setCursor(0, row); // her satırı açıkça seç / select every row explicitly
10 lcd.print(F("Satir / Row "));
11 lcd.print(row + 1);
12 }
13}
14
15void loop() {
16 lcd.setCursor(15, 3);
17 lcd.print(millis() / 1000 % 100000); // 5 haneye sığsın / fit in 5 digits
18 delay(500);
19}Paralleles LCD am ESP32
Ein normales 16x2-LCD liefert ohne 5-V-Versorgung zu wenig Kontrast, die Pins des ESP32 arbeiten aber mit 3,3 V. Die gute Nachricht: Solange RW an GND liegt, legt das LCD nie Spannung auf die Leitungen, es hört nur zu. Da der HD44780 bei 5 V schon ab etwa 2,2 V HIGH erkennt, genügen die 3,3-V-Signale des ESP32, und ein Pegelwandler ist nicht nötig. Verbinde VDD des LCD mit dem VIN-Pin des ESP32-Boards (5 V vom USB). Die Bibliothek LiquidCrystal läuft auf dem ESP32 genauso; meide nur Pins mit Sonderaufgaben beim Booten wie GPIO 0, 2, 12 und 15.
1// ESP32 + 16x2 LCD (paralel, 4-bit) / ESP32 + 16x2 LCD (parallel, 4-bit)
2// RS -> GPIO 22, E -> GPIO 21, D4 -> 19, D5 -> 18, D6 -> 26, D7 -> 25
3// VDD -> VIN (5 V), RW -> GND, V0 -> pot, A -> 220 ohm -> VIN
4#include <LiquidCrystal.h>
5
6LiquidCrystal lcd(22, 21, 19, 18, 26, 25);
7
8void setup() {
9 lcd.begin(16, 2);
10 lcd.print("ESP32 + LCD");
11}
12
13void loop() {
14 lcd.setCursor(0, 1);
15 lcd.print("Heap: ");
16 lcd.print(ESP.getFreeHeap() / 1024); // boş bellek (KB) / free memory (KB)
17 lcd.print(" KB ");
18 delay(1000);
19}Paralleles LCD am Raspberry Pi Pico (MicroPython)
Für den Raspberry Pi Pico gilt dieselbe Logik: LCD mit 5 V von VBUS (Pin 40) versorgen, RW an GND, Signale direkt an GP-Pins. MicroPython bringt keine fertige LiquidCrystal-Bibliothek mit, deshalb folgt ein kurzer Treiber, der den 4-Bit-Modus selbst steuert. Er hält sich an die Initialisierung aus dem HD44780-Datenblatt: 50 ms nach dem Einschalten warten, den Chip dreimal in den 8-Bit-Modus zwingen, dann in den 4-Bit-Modus schalten und die Anzeige einschalten. Jedes Zeichen geht in zwei Hälften (Nibbles) hinaus, nach jeder gibt E einen kurzen Impuls.
1# Raspberry Pi Pico: I2C'siz 16x2 LCD sürücüsü (4-bit) / 16x2 LCD driver without I2C (4-bit)
2# RS -> GP16, E -> GP17, D4 -> GP18, D5 -> GP19, D6 -> GP20, D7 -> GP21
3# VDD -> VBUS (pin 40, 5 V), RW -> GND, V0 -> pot
4from machine import Pin
5import time
6
7
8class LCD4:
9 def __init__(self, rs, e, d4, d5, d6, d7):
10 self.rs = Pin(rs, Pin.OUT, value=0)
11 self.e = Pin(e, Pin.OUT, value=0)
12 self.data = [Pin(p, Pin.OUT, value=0) for p in (d4, d5, d6, d7)]
13 time.sleep_ms(50) # güç geldikten sonra bekle / wait after power-up
14 for _ in range(3):
15 self._nibble(0x03) # 8-bit moda zorla / force 8-bit mode
16 time.sleep_ms(5)
17 self._nibble(0x02) # 4-bit moda geç / switch to 4-bit mode
18 self.command(0x28) # 4 bit, 2 satır, 5x8 / 4-bit, 2 lines, 5x8
19 self.command(0x0C) # ekran açık, imleç kapalı / display on, cursor off
20 self.clear()
21 self.command(0x06) # soldan sağa yaz / write left to right
22
23 def _nibble(self, value):
24 for i, pin in enumerate(self.data):
25 pin.value((value >> i) & 1)
26 self.e.value(1) # E darbesi / E pulse
27 time.sleep_us(1)
28 self.e.value(0)
29 time.sleep_us(50) # komut süresi (37 µs) / command time (37 µs)
30
31 def _write(self, value, rs):
32 self.rs.value(rs)
33 self._nibble(value >> 4) # önce üst yarı / upper half first
34 self._nibble(value & 0x0F)
35
36 def command(self, cmd):
37 self._write(cmd, 0)
38
39 def clear(self):
40 self.command(0x01)
41 time.sleep_ms(2) # clear yaklaşık 1,5 ms / clear takes about 1.5 ms
42
43 def move_to(self, col, row):
44 offsets = (0x00, 0x40, 0x14, 0x54) # 16x2 ve 20x4 satır adresleri / row addresses
45 self.command(0x80 | (offsets[row] + col))
46
47 def putstr(self, text):
48 for ch in text:
49 self._write(ord(ch), 1)
50
51
52lcd = LCD4(rs=16, e=17, d4=18, d5=19, d6=20, d7=21)
53lcd.move_to(0, 0)
54lcd.putstr("Merhaba Pico!")
55count = 0
56while True:
57 lcd.move_to(0, 1)
58 lcd.putstr("Sayac: {:<9d}".format(count))
59 count += 1
60 time.sleep(1)Schwarze Kästchen, leeres Display und andere Probleme
Fast jedes Problem mit einem parallelen LCD sieht aus wie eines von wenigen Symptomen, und das Display verrät dir selbst, wo du suchen musst. Der wichtigste Hinweis: Siehst du nur in der oberen Zeile 16 schwarze Kästchen, stimmen Versorgung und Kontrast, aber der Chip wurde nie initialisiert. Beim Einschalten startet der HD44780 im Einzeilenmodus und steuert nur die erste Zeile an; solange der Code das Display nicht initialisieren kann, ändert sich das Bild nicht. Dann liegt der Fehler fast immer bei RS, E oder D4–D7 oder bei der Pinreihenfolge im Konstruktor. Siehst du in beiden Zeilen blasse Kästchen, funktioniert das Display, nur der Kontrast ist zu hoch.
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Nur in der oberen Zeile 16 schwarze Kästchen | Display nicht initialisiert: RS, E, D4–D7 falsch verdrahtet, Pinreihenfolge im Konstruktor falsch oder kein Code geladen | Kabel mit der Tabelle vergleichen, Reihenfolge LiquidCrystal lcd(RS, E, D4, D5, D6, D7) prüfen |
| Blasse Kästchen in beiden Zeilen | Kontrast zu hoch (V0 zu nah an GND) | Am Poti drehen |
| Beleuchtung an, aber nichts zu sehen | Kontrast zu niedrig oder V0 nicht angeschlossen | Prüfen, ob der Schleifer an V0 geht, und am Poti drehen |
| Beleuchtung bleibt dunkel | 15 und 16 nicht angeschlossen, vertauscht oder Widerstand fehlt | A über 220 Ω an 5V, K an GND |
| Wirre oder springende Zeichen | Lockeres Datenkabel, D4–D7 vertauscht, Störungen durch Motor oder Relais | Kabel sichern, 100 µF an die Versorgung, bei Bedarf mit lcd.begin() neu initialisieren |
| Text flackert | lcd.clear() in der Schleife | Mit setCursor() überschreiben, alte Ziffern mit Leerzeichen löschen |
| Alte Ziffer bleibt stehen, wenn die Zahl kürzer wird | Neuer Wert kürzer als der alte | Leerzeichen an den Wert anhängen |
| Nach einem eigenen Zeichen erscheint kein Text | createChar hat den Cursor in den Zeichenspeicher gesetzt | Nach createChar setCursor() aufrufen |
Lohnt sich der Umstieg auf ein I2C-Modul?

Dank des PCF8574 auf der Rückseite überträgt das I2C-Modul alle Signale des LCD über zwei Leitungen (SDA und SCL); Kontrastpoti und Beleuchtungstransistor sitzen ebenfalls auf der Platine. Mit wachsendem Projekt wird das wichtig: Ein Uno hat nur 20 digitale und analoge Pins, und ein paralleles LCD belegt allein sechs davon. Andererseits ist die parallele Verbindung schneller, kennt keine I2C-Adresskonflikte und braucht kein Zusatzmodul. Die Tabelle zeigt, wann was besser passt; den Aufbau mit I2C-Modul findest du im Artikel zum I2C-LCD-Display.
| Merkmal | Parallel (4 Bit) | Mit I2C-Modul |
|---|---|---|
| Belegte Arduino-Pins | 6 | 2 (A4, A5) |
| Anzahl Leitungen | 12 (inklusive Versorgung und Poti) | 4 |
| Ganzes Display neu schreiben | Unter 2 ms | Etwa 20–30 ms bei 100 kHz |
| Kontrasteinstellung | Externes Poti | Trimmer auf dem Modul |
| Beleuchtung per Software aus | Zusätzlicher Transistor nötig | lcd.noBacklight() |
| Bibliothek | LiquidCrystal (in der IDE enthalten) | LiquidCrystal I2C (separat installieren) |
| Typische Probleme | Kabelsalat, Wackelkontakte | Adresse (0x27 / 0x3F) und Pull-ups |
Projektideen mit einem 16x2-LCD
- Digitales Thermometer: Zeige Temperatur und Feuchte von einem NTC oder DHT11 groß an, das Gradzeichen schreibst du mit lcd.write(223).
- Codeschloss: Zeige den über ein Keypad eingegebenen Code als Sternchen und schalte bei richtigem Code ein Relais.
- Entfernungsanzeige: Zeige die mit dem HC-SR04 gemessene Entfernung gleichzeitig in Zentimetern und als Balken.
- Stoppuhr und Countdown: Mit zwei Tastern starten, stoppen und zurücksetzen; die Zeit als Minuten:Sekunden:Hundertstel anzeigen.
- Minispiel: Zeichne mit eigenen Zeichen einen Läufer und Hindernisse und lass ihn per Taster springen.
- Menüsystem: Bau ein Menü, in dem du mit einem Drehgeber blätterst und Einstellungen änderst, und speichere die Auswahl im EEPROM.
Ein 16x2-LCD ohne I2C-Modul anzuschließen wirkt anfangs wie Kabelsalat, doch wenn du verstanden hast, wie das Display Befehle annimmt, nutzt du jedes Zeichen-LCD, das 20x4 und sogar andere Mikrocontroller nach derselben Logik. In der BlueGrays-App baust du diese Verbindung in den Projekten "Text auf einem 16x2-LCD ausgeben", "Hin- und herspringender Text auf dem LCD" und "Entfernung messen mit LCD" Schritt für Schritt mit Schaltplan und fertigem Code auf.
Häufige Fragen
Warum zeigt mein 16x2-LCD schwarze Kästchen?
Sind die Kästchen nur in der oberen Zeile, stimmen Versorgung und Kontrast, aber der Arduino konnte das Display nicht initialisieren; prüfe RS, E und D4–D7 sowie die Pinreihenfolge im LiquidCrystal-Konstruktor. Sind in beiden Zeilen blasse Kästchen zu sehen, ist der Kontrast zu hoch, und ein Dreh am Poti genügt.
Warum leuchtet mein LCD, zeigt aber keinen Text?
Meist ist der Kontrast zu niedrig: Liegt V0 nahe 5 V, sind die Zeichen unsichtbar. Prüfe, ob der Schleifer des Potis an V0 hängt, und drehe langsam. Stimmt der Kontrast und erscheinen oben Kästchen, liegt der Fehler bei den Datenleitungen oder im Code.
Kann man ein 16x2-LCD ohne Poti betreiben?
Ja. Ein fester Widerstand von 1–2,2 kΩ zwischen V0 und GND ergibt bei den meisten 5-V-Modulen einen guten Kontrast. Am zuverlässigsten ermittelst du den Wert einmal mit einem Poti und ersetzt es dann durch einen Festwiderstand. Möglich ist auch, V0 über einen RC-Filter an einen PWM-Pin zu legen und den Kontrast per Software einzustellen.
Wo wird der RW-Pin des LCD angeschlossen?
Wenn du nur schreibst, kommt RW (Pin 5) an GND; so bleibt das LCD dauerhaft im Schreibmodus, und genau so arbeitet die Bibliothek LiquidCrystal. Bleibt RW offen, kann das Display zufällig in den Lesemodus wechseln, die Datenleitungen treiben und gar nichts anzeigen. Ein RW an GND schützt außerdem die Pins von 3,3-V-Boards.
Was ist der Unterschied zwischen LiquidCrystal und LiquidCrystal_I2C?
LiquidCrystal steuert das LCD direkt über Arduino-Pins und gehört zur Arduino IDE; sie wird für die parallele Verbindung genutzt. LiquidCrystal_I2C sendet dieselben Befehle über ein I2C-Modul mit PCF8574 und muss separat installiert werden. Die meisten Befehle (print, setCursor, createChar) sind in beiden gleich; die I2C-Variante ergänzt lcd.init() zum Start und backlight() für die Beleuchtung.
Läuft mein 16x2-Code auch auf einem 20x4-LCD?
Ja, denn Verdrahtung und Befehle sind gleich; du musst nur lcd.begin(16, 2) in lcd.begin(20, 4) ändern. Beim 20x4-Display folgen die Zeilen im Speicher der Reihenfolge 1, 3, 2, 4, deshalb springst du am saubersten mit setCursor(0, zeile) in jede Zeile. Die Beleuchtung braucht etwas mehr Strom.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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.

Abstandsmessung mit LCD-Display
Ein Gerät, das ohne Lineal Abstände misst: Beweg deine Hand vor dem Sensor vor und zurück und sieh zu, wie sich die Zahl ändert.

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

DS1302 RTC-Uhr mit LCD-Anzeige
Eine kleine Tischuhr, die die Zeit auch bei Stromausfall nicht vergisst. Das Uhrmodul DS1302 hält die Zeit mit seiner eigenen kleinen Batterie; jede Sekunde liest der Arduino sie aus und schreibt…

Digitales Voltmeter mit LCD-Anzeige
Finde mit einem selbstgebauten Messgerät heraus, wie viel Spannung eine Batterie oder ein Netzteil liefert.

Passwortschloss mit 4x4-Tastenfeld und LCD
Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.

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

