Komplettes Arduino 16×2 LCD Tutorial: Anschließen, Programmieren & Daten anzeigen

Einführung

In diesem Arduino-Tutorial lernen Sie, wie Sie ein LCD (Liquid Crystal Display) mit einem Arduino verbinden und verwenden. Solche LCD-Displays sind in Elektronikprojekten sehr beliebt, da sie sich hervorragend zur Anzeige einfacher Informationen – wie Sensordaten – eignen und dabei sehr kostengünstig sind.

Ich habe sie bereits in mehreren meiner Arduino-Projekte eingesetzt, zum Beispiel:

• Arduino Sicherheits- und Alarmsystem
• DIY-Vending-Machine – Arduino-basiertes Mechatronik-Projekt
• Arduino-Entfernungsmesser und digitale Wasserwaage

Sie können das folgende Video ansehen oder das schriftliche Tutorial unten lesen. Es deckt alles ab, was Sie über die Verwendung eines LCD-Zeichendisplays mit Arduino wissen müssen: Pinbelegung, Verdrahtungsplan und mehrere Beispiel-Codes.

Was ist ein LCD-Zeichendisplay?

Ein LCD-Zeichendisplay ist ein spezieller Displaytyp, der nur einzelne ASCII-Zeichen fester Größe ausgeben kann. Aus diesen einzelnen Zeichen lassen sich dann Texte bilden.

Betrachtet man das Display genauer, erkennt man kleine rechteckige Bereiche, die jeweils aus einem 5×8-Pixel-Raster bestehen. Jedes Pixel kann einzeln angesteuert werden, sodass sich innerhalb jedes Gitters Zeichen darstellen lassen.

Die Anzahl dieser rechteckigen Bereiche definiert die Größe des LCD. Das populärste Modell ist das 16×2 LCD mit zwei Zeilen à 16 Zeichen. Es gibt auch andere Größen wie 16×1, 16×4, 20×4 usw., die alle nach demselben Prinzip funktionieren. Zudem können diese LCDs unterschiedliche Hintergrund- und Textfarben haben.

16×2 LCD Pinbelegung

Das Display hat 16 Pins. Von links nach rechts:

• Pin 1: GND – Masse
• Pin 2: VCC – 5 V Versorgungsspannung (an Arduino 5 V)
• Pin 3: Vo – Kontrasteinstellung (über Potentiometer)
• Pin 4: RS – Register Select (Low = Befehl, High = Daten)
• Pin 5: R/W – Read/Write (meist auf GND für Schreibmodus)
• Pin 6: E – Enable (Takt für Datentransfer)
• Pin 7–14: D0–D7 – 8 Datenleitungen (wir nutzen 4-Bit-Modus: D4–D7)
• Pin 15: A (Anode) – Hintergrundbeleuchtung +
• Pin 16: K (Kathode) – Hintergrundbeleuchtung –

Die LiquidCrystal-Bibliothek übernimmt fast die gesamte Low-Level-Steuerung. Wir verwenden den 4-Bit-Modus, sodass nur 4 Datenleitungen (D4–D7) benötigt werden.

Arduino mit LCD verbinden – Verdrahtungsplan

Hier ist der Schaltplan für die Verbindung eines 16×2 LCD mit Arduino:

Verwendete Arduino-Pins (Digital):

• LCD RS → Pin 1
• LCD Enable → Pin 2
• LCD D4 → Pin 4
• LCD D5 → Pin 5
• LCD D6 → Pin 6
• LCD D7 → Pin 7
• LCD R/W → GND
• LCD Vo → mittlerer Pin des Potentiometers
• LCD VCC → 5 V, GND → GND
• Potentiometer außen: 5 V und GND

Benötigte Bauteile

• 16×2 Zeichen-LCD
• Potentiometer (10 kΩ)
• Arduino Board (Uno, Nano, …)
• Steckbrett und Jumper-Kabel

Kontrasteinstellung

Der Kontrast wird über die Spannung am Vo-Pin geregelt. Ein Potentiometer erlaubt eine feine Justierung von 0–5 V.

Geht es auch ohne Potentiometer?

Ja. Zwei Optionen:

1. Spannungsteiler aus zwei Widerständen (z. B. 1 kΩ + 220 Ω → ca. 1 V am Vo-Pin).
2. PWM-Signal vom Arduino an Vo-Pin:

   analogWrite(11, 100); // PWM an Pin D11, Wert 100 von 255 ≈ 2 V

Arduino LCD Code – Grundbeispiel

Ein einfaches Programm zur Demonstration der LiquidCrystal-Bibliothek:

/* Arduino LCD Tutorial
 * Erstellt von Dejan Nedelkovski, www.HowToMechatronics.com
 */
#include <LiquidCrystal.h>

LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // (rs, enable, d4, d5, d6, d7)

void setup() {
  lcd.begin(16, 2); // Initialisierung: 16 Spalten, 2 Zeilen
}

void loop() {
  lcd.print("Arduino");
  delay(3000);
  lcd.setCursor(2, 1); // Spalte 2, Zeile 1 (0-indexed)
  lcd.print("LCD Tutorial");
  delay(3000);
  lcd.clear();
  lcd.blink();
  delay(4000);
  lcd.setCursor(7, 1);
  delay(3000);
  lcd.noBlink();
  lcd.cursor();
  delay(4000);
  lcd.noCursor();
  lcd.clear();
}

Code-Erklärung

• #include <LiquidCrystal.h> – Bibliothek einbinden (Sketch → Bibliothek einbinden → LiquidCrystal)
• LiquidCrystal lcd(rs, en, d4, d5, d6, d7) – LCD-Objekt mit Pin-Nummern erstellen
• lcd.begin(spalten, zeilen) – Display initialisieren
• lcd.print() – Text ausgeben
• lcd.setCursor(spalte, zeile) – Cursor positionieren (0-basiert)
• lcd.blink() / noBlink() – Blinkenden Block-Cursor ein/aus
• lcd.cursor() / noCursor() – Unterstrich-Cursor ein/aus
• lcd.clear() – Display löschen

Scrollender Text auf 16×2 LCD

Bei Texten > 16 Zeichen ermöglichen scrollDisplayLeft() und scrollDisplayRight() das Scrollen.

#include <LiquidCrystal.h>
LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("Scrolling Text Example");
}

void loop() {
  lcd.scrollDisplayLeft();
  delay(500); // Scrollgeschwindigkeit
}

Für mehr Kontrolle kann man das Scrollen manuell per for-Schleife realisieren:

#include <LiquidCrystal.h>
LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
}

void loop() {
  // Nach rechts scrollen
  for (int i = 0; i <= 13; i++) {
    lcd.setCursor(i, 0);
    lcd.print("LCD");
    delay(500);
    lcd.clear();
  }
  // Nach links scrollen
  for (int i = 12; i >= 1; i--) {
    lcd.setCursor(i, 0);
    lcd.print("LCD");
    delay(500);
    lcd.clear();
  }
}

Eigene Zeichen (Custom Characters) erstellen & anzeigen

Neben ASCII-Zeichen können 8 benutzerdefinierte Zeichen (5×8 Pixel) definiert werden.

#include <LiquidCrystal.h>

byte heart[8] = {
  B00000, B01010, B11111, B11111,
  B01110, B00100, B00000, B00000
};
byte smile[8] = {
  B00000, B00000, B01010, B00000,
  B10001, B01110, B00000, B00000
};
byte lock[8] = {
  B01110, B10001, B10001, B11111,
  B11011, B11011, B11111, B00000
};
byte character[8] = {
  B11111, B10101, B11111, B01010,
  B01110, B11111, B01110, B01110
};

LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.createChar(0, heart);
  lcd.createChar(1, smile);
  lcd.createChar(2, lock);
  lcd.createChar(3, character);
  lcd.clear();
  lcd.print("Custom Character");
}

void loop() {
  lcd.setCursor(1, 1);  lcd.write(byte(0)); // Herz
  lcd.setCursor(5, 1);  lcd.write(byte(1)); // Smiley
  lcd.setCursor(9, 1);  lcd.write(byte(2)); // Schloss
  lcd.setCursor(13, 1); lcd.write(byte(3)); // Figur
}

Erklärung:

• Jedes Zeichen ist ein Array von 8 Bytes (je Byte = eine Zeile des 5×8 Gitters).
• lcd.createChar(num, array) – definiert Zeichen num (0–7).
• lcd.write(byte(num)) – zeigt das benutzerdefinierte Zeichen an.

Siehe auch: Arduino Touch Screen Tutorial | TFT LCD

Fazit

Wir haben alle Grundlagen behandelt: Pinbelegung, Verdrahtung, Kontrasteinstellung, Textausgabe, Scrollen und benutzerdefinierte Zeichen. Das gezeigte 16×2 LCD ist repräsentativ – andere Größen (16×4, 20×4, …) funktionieren identisch.

Ich hoffe, dieses Tutorial war hilfreich. Fragen gerne in den Kommentaren. Schauen Sie auch in meine Sammlung von 30+ Arduino-Projekten.