Wie man ein LCD-Display mit Arduino steuert (8 Beispiele)

Dieses Tutorial enthält alles, was du über die Steuerung eines Zeichen-LCDs mit Arduino wissen musst. Ich habe ein Schaltbild und viele Beispielcodes beigefügt. Diese Displays sind ideal, um Sensordaten oder Text anzuzeigen, und sie sind zudem recht günstig.

Der erste Teil dieses Artikels behandelt die Grundlagen der Anzeige von Text und Zahlen. Im zweiten Teil gehe ich näher darauf ein, wie man benutzerdefinierte Zeichen anzeigt und wie du die anderen Funktionen der LiquidCrystal Arduino-Bibliothek nutzen kannst.

Wie du sehen wirst, benötigt man ziemlich viele Verbindungen, um diese Displays zu steuern. Deshalb verwende ich sie gerne mit einem I2C interface Modul, das auf der Rückseite montiert ist. Mit diesem I2C-Modul brauchst du nur zwei Verbindungen, um das LCD zu steuern. Schau dir das folgende Tutorial an, wenn du auch ein I2C-Modul verwenden möchtest:

Materialien

Hardware-Komponenten

16×2 character LCD	× 1	Amazon
20×4 character LCD	× 1	Amazon
Arduino Uno Rev3	× 1	Amazon
Breadboard	× 1	Amazon
Jumper wires	~ 10	Amazon
10 kΩ potentiometer	× 1	Amazon
USB cable type A/B	× 1	Amazon

Software

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Hardware-Übersicht

Diese LCDs sind in vielen verschiedenen Größen erhältlich (16×2 1602, 20×4 2004, 16×1 usw.), aber sie verwenden alle denselben HD44780 parallelen Schnittstellen-LCD-Controllerchip von Hitachi. Das bedeutet, du kannst sie problemlos austauschen. Du musst nur die Größenangaben in deinem Arduino-Code anpassen.

16×2 LCD Spezifikationen

Betriebsspannung	5 V
Controller	Hitachi HD44780 LCD-Controller
Bildschirmauflösung	2 Zeilen x 16 Zeichen
Zeichenauflösung	5 x 8 Pixel
Modulabmessungen	80 x 36 x 12 mm
Sichtbereich Abmessungen	64,5 x 16,4 mm
Kosten	Check price

Für weitere Informationen kannst du die untenstehenden Datenblätter ansehen. Die Datenblätter für 16×2 und 20×4 enthalten die Abmessungen des LCDs, und im HD44780-Datenblatt findest du mehr Infos zum Hitachi LCD-Treiber.

16×2 Character LCD Datasheet

20×4 Character LCD Datasheet

HD44780 Datasheet

16×2 LCD Pinbelegung

Das LCD hat 16 Anschluss-Pins, nummeriert von 1 bis 16 von links nach rechts.

Die Pins oben am Display sind von links nach rechts mit 1 bis 16 nummeriert.

Die Pinbelegung eines Standard-HD44780 LCDs ist in der folgenden Tabelle dargestellt:

Pin Nr.	Symbol	Anschluss	Funktion
1	VSS	GND Arduino	Signalmasse
2	VDD	5 V Arduino	Logikversorgung für LCD
3	V0	10 kΩ Potentiometer	Kontrasteinstellung
4	RS	Pin 2 Arduino	Register-Auswahl-Signal
5	R/W	GND Arduino	Lese-/Schreib-Auswahl-Signal
6	E	Pin 3 Arduino	Aktivierungssignal
7 – 14	D0 – D7	–	Datenbusleitungen für 8-Bit-Modus
11 – 14	D4 – D7	Pin 4 – 7 Arduino	Datenbusleitungen für 4-Bit-Modus
15	A (LED+)	5 V Arduino	Anode für LCD-Hintergrundbeleuchtung
16	K (LED-)	GND Arduino	Kathode für LCD-Hintergrundbeleuchtung

LCD testen und Kontrast einstellen

Um das Display zu testen, musst du die Verbindungen wie in der Abbildung unten herstellen.

Die meisten LCDs haben einen eingebauten Vorwiderstand für die LED-Hintergrundbeleuchtung. Du findest ihn auf der Rückseite des LCDs, verbunden mit Pin 15 (Anode). Wenn dein Display keinen Widerstand enthält, musst du einen zwischen 5 V und Pin 15 hinzufügen. Ein 220Ω Widerstand ist in der Regel sicher, aber dieser Wert könnte dein Display etwas dunkler machen. Du kannst im Datenblatt den maximalen Strom der Hintergrundbeleuchtung nachsehen und damit einen passenden Widerstand auswählen.

16x2-character-lcd-with-arduino-uno-adjusting-contrast-wiring — Verdrahtung für Kontrasteinstellung

Nachdem du das LCD verdrahtet hast, musst du den Kontrast einstellen. Das erfolgt durch Drehen des 10 kΩ Potentiometers im oder gegen den Uhrzeigersinn.

Stecke den USB-Stecker des Arduino ein, um das LCD mit Strom zu versorgen. Die Hintergrundbeleuchtung sollte aufleuchten. Drehe nun das Potentiometer, bis eine (16×2 LCD) oder zwei Reihen (20×4 LCD) von Rechtecken erscheinen.

16x2 lcd arduino contrast adjustment — Drehe das Potentiometer, bis eine Reihe von Rechtecken erscheint.

Du kannst den Kontrast später bei Bedarf noch anpassen.

Wie man das LCD mit Arduino UNO verbindet

Um das LCD zu steuern und Zeichen anzuzeigen, musst du einige zusätzliche Verbindungen herstellen. Sieh dir das Schaltbild unten und die Pinbelegungstabelle aus der Einleitung dieses Artikels an.

16x2-character-lcd-with-arduino-uno-wiring-diagram-schematic — 16×2 LCD mit Arduino Schaltbild

Wir verwenden das LCD im 4-Bit-Modus, das heißt, du musst nichts an D0-D3 anschließen. Der R/W-Pin ist mit Masse verbunden, dadurch wird der Pin auf LOW gezogen und das LCD auf SCHREIB-Modus gesetzt.

Sobald alles verdrahtet ist, können wir mit der Programmierung des LCDs beginnen.

Arduino Beispielcode für Zeichen-LCD

Zur Steuerung des LCDs verwenden wir die LiquidCrystal Bibliothek. Diese Bibliothek ist normalerweise bereits in der Arduino IDE vorinstalliert. Du findest sie unter Sketch > Include Library > LiquidCrystal.

Die LiquidCrystal-Bibliothek bietet viele eingebaute Funktionen und macht die Steuerung von Zeichen-LCDs super einfach.

Der Beispielcode unten zeigt dir, wie du eine Nachricht auf dem LCD anzeigst. Danach erkläre ich, wie der Code funktioniert und wie du die anderen Funktionen der LiquidCrystal-Bibliothek nutzen kannst.

/* Basic Arduino example code for displaying text 
  on 16x2, 20x4 etc. character LCDs. 
  www.www.makerguides.com */

// Include the library:
#include "LiquidCrystal.h"

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

void loop() {
  // Set the cursor on the third column and the first row, counting starts at 0:
  lcd.setCursor(2, 0);
  // Print the string 'Hello World!':
  lcd.print("Hello World!");
  // Set the cursor on the third column and the second row:
  lcd.setCursor(2, 1);
  // Print the string 'LCD tutorial':
  lcd.print("LCD tutorial");
}

Du solltest folgende Ausgabe auf dem LCD sehen:

Wie der Code funktioniert

Nach dem Einbinden der Bibliothek ist der nächste Schritt, eine neue Instanz der LiquidCrystal-Klasse zu erstellen. Das geschieht mit der Funktion LiquidCrystal(rs, enable, d4, d5, d6, d7). Als Parameter verwenden wir die Arduino-Pins, an die wir das Display angeschlossen haben. Beachte, dass wir das Display ‘lcd’ genannt haben. Du kannst ihm einen anderen Namen geben, z.B. ‘menu_display’. Dann musst du ‘lcd’ im restlichen Sketch durch den neuen Namen ersetzen.

// Include the library:
#include "LiquidCrystal.h"

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

Im setup() wird das LCD mit der Funktion begin(cols,rows)initialisiert. Bei Verwendung eines 20×4 LCD ändere diese Zeile zu lcd.begin(20,4);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

Im loop() wird der Cursor mit lcd.setCursor(2,0)auf die dritte Spalte und erste Zeile des LCD gesetzt. Beachte, dass die Zählung bei 0 beginnt und das erste Argument die Spalte angibt. Wenn du die Cursorposition nicht angibst, wird der Text an der Standard-Startposition (0,0) ausgegeben, wenn das Display leer ist, oder hinter dem zuletzt gedruckten Zeichen.

Anschließend wird der String ‘Hello World!’ mit lcd.print("Hello World!")ausgegeben. Beachte, dass du Anführungszeichen (” “) um den Text setzen musst. Wenn du Zahlen oder Variablen ausgeben willst, sind keine Anführungszeichen nötig.

void loop() {
  // Set the cursor on the third column and the first row, counting starts at 0:
  lcd.setCursor(2, 0);
  // Print the string 'Hello World!':
  lcd.print("Hello World!");
  // Set the cursor on the third column and the second row:
  lcd.setCursor(2, 1);
  // Print the string 'LCD tutorial':
  lcd.print("LCD tutorial");
}

Wenn du ein Beispiel sehen möchtest, wie man Variablen auf dem LCD anzeigt (und ändert), schau dir mein Tutorial zu How to use a HC-SR04 Ultrasonic Distance Sensor with Arduino an.

Im Beispiel habe ich ein I2C LCD Display verwendet, aber der Code nach dem Setup ist für beide gleich.

Andere Funktionen der LiquidCrystal-Bibliothek

Die LiquidCrystal Arduino-Bibliothek hat viele weitere eingebaute Funktionen, die nützlich sein können. Eine Übersicht mit Erklärungen und Codebeispielen findest du unten.

clear()

Löscht den LCD-Bildschirm und setzt den Cursor in die obere linke Ecke (erste Zeile, erste Spalte) des Displays. Du kannst diese Funktion verwenden, um verschiedene Wörter in einer Schleife anzuzeigen.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

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

void loop() {
  lcd.clear();
  lcd.print("Monday");
  delay(2000);
  lcd.clear();
  lcd.print("13:45");
  delay(2000);
}

home()

Setzt den Cursor in die obere linke Ecke des LCDs. Verwende clear(), wenn du auch das Display löschen möchtest.

cursor()

Zeigt den LCD-Cursor an: einen Unterstrich an der Position des nächsten zu druckenden Zeichens.

noCursor()

Versteckt den LCD-Cursor. Das folgende Beispiel erzeugt einen blinkenden Cursor am Ende von “cursor()”.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

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

void loop() {
  lcd.cursor();
  delay(500);
  lcd.noCursor();
  delay(500);
}

blink()

Erzeugt einen blinkenden Block-Cursor: ein blinkendes Rechteck an der Position des nächsten zu druckenden Zeichens.

noBlink()

Deaktiviert den Block-Cursor. Das folgende Beispiel zeigt den blinkenden Cursor für 5 Sekunden und deaktiviert ihn dann für 2 Sekunden.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("blink() example");
}

void loop() {
  lcd.blink();
  delay(5000);
  lcd.noBlink();
  delay(2000);
}

display()

Schaltet das LCD ein und zeigt alle Texte oder Cursor an, die auf das Display geschrieben wurden.

noDisplay()

Schaltet alle Texte oder Cursor auf dem LCD aus. Die Daten werden nicht aus dem LCD-Speicher gelöscht. Das bedeutet, sie werden wieder angezeigt, wenn display() aufgerufen wird.

Das folgende Beispiel erzeugt einen blinkenden Texteffekt.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("Blinking text");
}

void loop() {
  lcd.display();
  delay(2000);
  lcd.noDisplay();
  delay(2000);
}

write()

Diese Funktion kann verwendet werden, um ein Zeichen auf das LCD zu schreiben. Mehr Infos findest du im Abschnitt über das Erstellen und Anzeigen benutzerdefinierter Zeichen weiter unten.

scrollDisplayLeft()

Scrollt den Inhalt des Displays (Text und Cursor) um eine Position nach links. Du kannst diese Funktion in der loop-Sektion des Codes zusammen mit delay(500) verwenden, um eine Lauftext-Animation zu erzeugen.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("scrollDisplayLeft() example");
}

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

scrollDisplayRight()

Scrollt den Inhalt des Displays (Text und Cursor) um eine Position nach rechts.

autoscroll()

Diese Funktion aktiviert das automatische Scrollen des LCDs. Dadurch wird bei jeder Ausgabe eines Zeichens das vorherige um eine Position verschoben. Wenn die aktuelle Schreibrichtung von links nach rechts ist (Standard), scrollt das Display nach links; bei rechts-nach-links scrollt es nach rechts. So wird jedes neue Zeichen an derselben Position auf dem LCD ausgegeben.

Das folgende Beispiel-Sketch aktiviert automatisches Scrollen und gibt die Zeichen 0 bis 9 an der Position (16,0) des LCDs aus. Ändere dies auf (20,0) für ein 20×4 LCD.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

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

void loop() {
  lcd.autoscroll();
  lcd.setCursor(16, 0);
  for (int x = 0; x < 10; x++) {
    lcd.print(x);
    delay(500);
  }
  lcd.clear();
}

noAutoscroll()

Deaktiviert das automatische Scrollen des LCDs.

leftToRight()

Diese Funktion bewirkt, dass der Text vom Cursor aus nach rechts fließt, als wäre das Display linksbündig (Standard).

rightToLeft()

Diese Funktion bewirkt, dass der Text vom Cursor aus nach links fließt, als wäre das Display rechtsbündig.

Wie erstellt und zeigt man benutzerdefinierte Zeichen an?

Mit der Funktion createChar() kann man benutzerdefinierte Zeichen auf dem LCD erstellen und anzeigen. Das ist besonders nützlich, wenn du ein Zeichen darstellen möchtest, das nicht im Standard-ASCII-Zeichensatz enthalten ist.

Technische Info: LCDs, die auf dem Hitachi HD44780 LCD-Controller basieren, haben zwei Arten von Speicher: CGROM und CGRAM (Character Generator ROM und RAM). CGROM erzeugt alle 5 x 8 Punkt-Zeichenmuster aus den Standard-8-Bit-Zeichencodes. CGRAM kann benutzerdefinierte Zeichenmuster erzeugen.

Für 5 x 8 Punkt-Displays kann CGRAM bis zu 8 benutzerdefinierte Zeichen und für 5 x 10 Punkt-Displays 4erstellen. Weitere Infos findest du im Datenblatt.

Beispielcode für benutzerdefinierte Zeichen mit Arduino

Das folgende Beispiel-Sketch erstellt und zeigt acht benutzerdefinierte Zeichen (nummeriert 0 – 7).

/* Example sketch to create and display custom characters on 
   character LCD with Arduino and LiquidCrystal library. 
   For more info see www.www.makerguides.com */

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};
byte Bell[] = {
  B00100,
  B01110,
  B01110,
  B01110,
  B11111,
  B00000,
  B00100,
  B00000
};
byte Alien[] = {
  B11111,
  B10101,
  B11111,
  B11111,
  B01110,
  B01010,
  B11011,
  B00000
};
byte Check[] = {
  B00000,
  B00001,
  B00011,
  B10110,
  B11100,
  B01000,
  B00000,
  B00000
};
byte Speaker[] = {
  B00001,
  B00011,
  B01111,
  B01111,
  B01111,
  B00011,
  B00001,
  B00000
};
byte Sound[] = {
  B00001,
  B00011,
  B00101,
  B01001,
  B01001,
  B01011,
  B11011,
  B11000
};
byte Skull[] = {
  B00000,
  B01110,
  B10101,
  B11011,
  B01110,
  B01110,
  B00000,
  B00000
};
byte Lock[] = {
  B01110,
  B10001,
  B10001,
  B11111,
  B11011,
  B11011,
  B11111,
  B00000
};

void setup() {
  // Specify the LCD's number of columns and rows:
  lcd.begin(16, 2);

  // Create a new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

  // Clears the LCD screen:
  lcd.clear();

  // Print a message to the lcd:
  lcd.print("Custom Character");
}

void loop() {
  // Print all the custom characters:
  lcd.setCursor(0, 1);
  lcd.write(byte(0));
  lcd.setCursor(2, 1);
  lcd.write(byte(1));
  lcd.setCursor(4, 1);
  lcd.write(byte(2));
  lcd.setCursor(6, 1);
  lcd.write(byte(3));
  lcd.setCursor(8, 1);
  lcd.write(byte(4));
  lcd.setCursor(10, 1);
  lcd.write(byte(5));
  lcd.setCursor(12, 1);
  lcd.write(byte(6));
  lcd.setCursor(14, 1);
  lcd.write(byte(7));
}

Du solltest folgende Ausgabe auf dem LCD sehen:

16x2-character-lcd-arduino-tutorial-custom-characters — LCD Ausgabe

Wie der Code funktioniert

Nach dem Einbinden der Bibliothek und Erstellen des LCD-Objekts werden die Arrays für die benutzerdefinierten Zeichen definiert. Jedes Array besteht aus 8 Bytes, je 1 Byte für jede Zeile. In diesem Beispiel werden 8 benutzerdefinierte Zeichen erstellt.

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

Wenn man sich das Array genau anschaut, sieht man Folgendes: Jede Zeile besteht aus 5 Zahlen, die den 5 Pixeln eines 5 x 8 Punkt-Zeichens entsprechen. Eine 0 bedeutet Pixel aus, eine 1 bedeutet Pixel an.

Es ist möglich, jede Zeile von Hand zu bearbeiten, aber ich empfehle die Verwendung dieser visual tool auf GitHub. Diese Anwendung erstellt automatisch das Zeichen-Array, und du kannst die Pixel anklicken, um sie ein- oder auszuschalten.

Im setup()werden die benutzerdefinierten Zeichen mit lcd.createChar(num, data)erstellt.

Das erste Argument dieser Funktion ist die Nummer des benutzerdefinierten Zeichens (0-7), das zweite Argument ist das Zeichen-Array, das wir erstellt haben.

  // Create a new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

Im loop()werden alle Zeichen mit lcd.write()angezeigt. Als Parameter verwenden wir die Nummer des reservierten Zeichens.

  lcd.setCursor(0, 1);
  lcd.write(byte(0));

Fazit

In diesem Artikel habe ich dir gezeigt, wie man ein alphanumerisches LCD mit Arduino verwendet. Ich hoffe, du fandest es nützlich und informativ. Wenn du Fragen, Vorschläge hast oder denkst, dass in diesem Tutorial etwas fehlt, hinterlasse bitte einen Kommentar unten.

Viel Spaß beim Tüfteln 😉

Benne de Bakker