Dieser Artikel enthält alles, was du über die Verwendung eines Character I2C LCD mit Arduino wissen musst. Ich habe ein Schaltbild und viele Beispielcodes beigefügt, um dir den Einstieg zu erleichtern.
Der erste Teil dieses Artikels behandelt die Grundlagen der Anzeige von Text und Zahlen. Im zweiten Teil gehe ich genauer darauf ein, wie man benutzerdefinierte Zeichen anzeigt und wie du die anderen Funktionen der LiquidCrystal_I2C-Bibliothek nutzen kannst.
Sobald du weißt, wie man Text und Zahlen auf dem LCD anzeigt, empfehle ich dir, einen Blick auf die untenstehenden Artikel zu werfen. In diesen Tutorials lernst du, wie man Sensordaten misst und auf dem LCD anzeigt.
Materialien
Hardware-Komponenten
 | 16×2 character I2C LCD | × 1 | Amazon |
| 20×4 character I2C LCD (Alternative) | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Jumper wires (männlich zu weiblich) | × 4 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Werkzeuge
Software
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.
I2C LCD Grundlagen
Dieser Leitfaden ist Teil unseres Artikel-Hubs zu Displays. Diese Art von LCD ist ideal zum Anzeigen von Text und Zahlen, daher der Name „Character LCD“.
Das I2C LCD, das wir in diesem Tutorial verwenden, hat eine kleine Zusatzschaltung auf der Rückseite des Moduls. Dieses Modul verfügt über einen PCF8574-Chip (für I2C-Kommunikation) und ein Potentiometer zur Einstellung der LED-Hintergrundbeleuchtung.
Der Vorteil eines I2C LCDs ist die sehr einfache Verkabelung. Du benötigst nur zwei Datenpins, um das LCD zu steuern. Standard-LCDs benötigen typischerweise etwa 12 Verbindungen, was problematisch sein kann, wenn du nicht viele GPIO-Pins zur Verfügung hast.
Glücklicherweise kannst du die I2C-Zusatzschaltung auch separat auf Amazon kaufen, sodass du ein Standard-LCD problemlos aufrüsten kannst.
Für ein Tutorial und Schaltplan zu Standard-Character-LCDs siehe bitte den folgenden Artikel:
Wenn du genau hinsiehst, erkennst du auf dem LCD die kleinen Rechtecke, die die einzelnen Zeichen des LCD bilden. Jedes Rechteck besteht aus einem Raster von 5×8 Pixeln. Später in diesem Tutorial zeige ich dir, wie du die einzelnen Pixel steuern kannst, um benutzerdefinierte Zeichen auf dem LCD anzuzeigen.
Technische Daten
Die technischen Daten der 16×2, 20×4 und anderer LCD-Größen sind größtenteils gleich. Sie verwenden alle denselben HD44780 Hitachi LCD controller, sodass du sie problemlos austauschen kannst. Du musst nur die Größenangaben in deinem Arduino-Code anpassen.
Die technischen Daten eines typischen 16×2 I2C Displays findest du in der folgenden Tabelle.
16×2 I2C LCD Spezifikationen
| Betriebsspannung | 5 V |
| Controller | Hitachi HD44780 LCD-Controller |
| Standardadresse | 0x27 |
| Bildschirmauflösung | 2 Zeilen × 16 Zeichen |
| Zeichenauflösung | 5 × 8 Pixel |
| Modulabmessungen | 80 × 36 × 12 mm |
| Sichtbereichsabmessungen | 64,5 × 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 LCD, und im HD44780-Datenblatt findest du mehr Informationen zum Hitachi LCD-Treiber.
Der PCF8574-Chip wird im I2C-Modul auf der Rückseite des LCD verwendet.
Wie man das I2C LCD mit Arduino UNO verbindet
Das folgende Schaltbild zeigt dir, wie du das I2C LCD mit dem Arduino verbindest. Die Verkabelung eines I2C LCDs ist viel einfacher als die eines Standard-LCDs. Du musst nur 4 Pins anschließen statt 12.
Die Verbindungen sind auch in der folgenden Tabelle angegeben.
I2C LCD Verbindungen
| I2C Character LCD | Arduino |
|---|---|
| GND | GND |
| VCC | 5 V |
| SDA | A4 |
| SCL | A5 |
Wenn du keinen Arduino Uno verwendest, können die SDA- und SCL-Pins an einer anderen Stelle liegen.
Beachte, dass ein Arduino Uno mit R3-Layout (1.0 Pinout) auch die SDA- (Datenleitung) und SCL- (Taktleitung) Pin-Header in der Nähe des AREF-Pins hat. Siehe die folgende Tabelle für Details.
| Board | SDA | SCL |
|---|---|---|
| Arduino Uno | A4 | A5 |
| Arduino Nano | A4 | A5 |
| Arduino Micro | 2 | 3 |
| Arduino Mega 2560 | 20 | 21 |
| Arduino Leonardo | 2 | 3 |
| Arduino Due | 20 | 21 |
Kontrast des LCD einstellen
Nachdem du das LCD verkabelt hast, musst du den Kontrast des Displays einstellen. Am I2C-Modul findest du ein Potentiometer, das du mit einem kleinen Schraubendreher drehen kannst.
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. Du kannst den Kontrast später bei Bedarf noch anpassen.
Sobald das erledigt ist, können wir mit der Programmierung des LCD beginnen.
Installation der LiquidCrystal_I2C Arduino-Bibliothek
In diesem Tutorial verwende ich die LiquidCrystal_I2C Bibliothek. Diese Bibliothek bietet viele eingebaute Funktionen, die das Programmieren des LCDs sehr einfach machen.
Die neueste Version dieser Bibliothek findest du hier:
Stelle sicher, dass du genau diese Bibliothek installiert hast und lösche alle anderen Bibliotheken mit demselben Namen (LiquidCrystal_I2C). Andere Bibliotheken funktionieren wahrscheinlich auch, verwenden aber möglicherweise leicht unterschiedliche Funktionsnamen.
Die LiquidCrystal_I2C-Bibliothek arbeitet in Kombination mit der Wire.h Bibliothek, die die Kommunikation mit I2C-Geräten ermöglicht. Diese Bibliothek ist im Arduino IDE vorinstalliert.
Um diese Bibliothek zu installieren, gehe zu Tools > Manage Libraries (Strg + Shift + I unter Windows) im Arduino IDE. Der Library Manager öffnet sich und aktualisiert die Liste der installierten Bibliotheken.
Suche nun nach „liquidcrystal_i2c“ und suche die Bibliothek von Frank de Brabander. Wähle die neueste Version aus und klicke dann auf Installieren.
Die Bibliothek enthält einige Beispiele, die du verwenden kannst, aber du musst sie an deine Hardware anpassen. Ich habe viele Beispielcodes unten beigefügt, die du mit der zuvor gezeigten Verkabelung verwenden kannst.
Zuerst zeige ich dir einen einfachen Beispielcode und erkläre dann die Funktionen genauer.
Wie finde ich die I2C-Adresse meines LCD?
Die meisten I2C LCDs werden mit der Standardadresse „0x27“ geliefert, aber sie kann je nach Charge/Hersteller unterschiedlich sein. In diesem Fall musst du die tatsächliche Adresse des LCDs herausfinden, bevor du es verwenden kannst. Auf der Arduino-Website findest du einen einfachen Beispielsketch, der den I2C-Bus nach Geräten durchsucht. Wenn ein Gerät gefunden wird, zeigt er die Adresse im Serial Monitor an.
/*I2C_scanner
This sketch tests standard 7-bit addresses.
Devices with higher bit address might not be seen properly.
*/
#include "Wire.h"
void setup() {
Wire.begin();
Serial.begin(9600);
while (!Serial);
Serial.println("\nI2C Scanner");
}
void loop() {
byte error, address;
int nDevices;
Serial.println("Scanning...");
nDevices = 0;
for (address = 1; address < 127; address++ ) {
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0) {
Serial.print("I2C device found at address 0x");
if (address < 16)
Serial.print("0");
Serial.print(address, HEX);
Serial.println(" !");
nDevices++;
}
else if (error == 4) {
Serial.print("Unknown error at address 0x");
if (address < 16)
Serial.print("0");
Serial.println(address, HEX);
}
}
if (nDevices == 0)
Serial.println("No I2C devices found\n");
else
Serial.println("done\n");
delay(5000);
}
Wenn du diesen Sketch auf den Arduino hochlädst und ausführst, solltest du die folgende Ausgabe im Serial Monitor (Strg + Shift + M) sehen.
Schreibe die gefundene Adresse auf, du wirst sie später beim Programmieren des LCD benötigen.
Einfacher Arduino Beispielcode für I2C LCD
Dieser Beispielsketch zeigt die klassische Ausgabe „Hello World!“ in der ersten Zeile des LCD und „LCD tutorial“ in der zweiten Zeile.
/* I2C LCD with Arduino example code. More info: https://www.makerguides.com */
#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD
// Wiring: SDA pin is connected to A4 and SCL pin to A5.
// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered)
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.
void setup() {
// Initiate the LCD:
lcd.init();
lcd.backlight();
}
void loop() {
// Print 'Hello World!' on the first line of the LCD:
lcd.setCursor(2, 0); // Set the cursor on the third column and first row.
lcd.print("Hello World!"); // Print the string "Hello World!"
lcd.setCursor(2, 1); //Set the cursor on the third column and the second row (counting starts at 0!).
lcd.print("LCD tutorial");
}
Du solltest die folgende Ausgabe auf dem LCD sehen:
Als Nächstes erkläre ich, wie der Code funktioniert.
Wie der Code funktioniert
Zuerst werden die benötigten Bibliotheken eingebunden. Wie bereits erwähnt, brauchen wir sowohl die Wire.h als auch die LiquidCrystal_I2C-Bibliothek. Im weiteren Verlauf dieses Tutorials werde ich mehr eingebaute Funktionen dieser Bibliothek behandeln.
#include "Wire.h" // Library for I2C communication #include "LiquidCrystal_I2C.h" // Library for LCD
Als nächstes wird ein LCD-Objekt mit der LiquidCrystal_I2C-Klasse erstellt und die Adresse sowie die Abmessungen angegeben. Dafür verwenden wir die Funktion LiquidCrystal_I2C(address, columns, rows).
Hier musst du die Standardadresse auf die zuvor gefundene Adresse ändern, falls sie abweicht. Bei Verwendung eines 20×4 LCD ändere diese Zeile zu LiquidCrystal_I2C(0x27,20,4);
Beachte, dass wir das Display „lcd“ genannt haben. Du kannst ihm auch einen anderen Namen geben, z. B. „menu_display“. Du musst dann im restlichen Sketch alle „lcd“ durch den neuen Namen ersetzen.
// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered) LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.
Setup
Im Setup wird das LCD mit lcd.init()initialisiert und die Hintergrundbeleuchtung mit lcd.backlight()eingeschaltet.
void setup() {
// Initiate the LCD:
lcd.init();
lcd.backlight();
}
Loop
Im Loop-Teil des Codes 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. Also lcd.setCursor(2,1)setzt den Cursor auf die dritte Spalte und zweite Zeile.
Anschließend wird der String „Hello World!“ mit lcd.print("Hello World!")ausgegeben. Beachte, dass du Anführungszeichen („ “) um den Text setzen musst, da wir einen text stringausgeben.
Wenn du Zahlen ausgeben möchtest, sind keine Anführungszeichen nötig. Zum Beispiel lcd.print(12345).
void loop() {
lcd.setCursor(2, 0); // Set the cursor on the third column and first row.
lcd.print("Hello World!"); // Print the string "Hello World!".
lcd.setCursor(2, 1); //Set the cursor on the third column and the second row.
lcd.print("LCD tutorial"); // Print the string "LCD tutorial".
}
Wenn du ein Beispiel sehen möchtest, wie man Variablen auf dem LCD anzeigt (und ändert), schau dir mein Tutorial zum HC-SR04 Ultraschallsensor an:
Weitere nützliche Funktionen der LiquidCrystal_I2C-Bibliothek
Das obige Beispiel zeigt die Grundlagen der Textanzeige auf dem LCD. Jetzt schauen wir uns die anderen Funktionen der LiquidCrystal_I2C-Bibliothek an.
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 in einer Schleife verschiedene Wörter anzuzeigen.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
}
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 LCD. Verwende clear() , wenn du auch das Display löschen möchtest.
cursor()
Zeigt den LCD-Cursor an: einen Unterstrich (Linie) an der Position des nächsten zu druckenden Zeichens.
noCursor()
Versteckt den LCD-Cursor. Das folgende Beispiel erzeugt einen blinkenden Cursor am Ende von „Hello World!“.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
lcd.print("Hello World!");
}
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_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
lcd.print("blink() example");
}
void loop() {
lcd.blink();
delay(5000);
lcd.noBlink();
delay(2000);
}
display()
Schaltet das LCD-Display ein und zeigt alle Texte oder Cursor an, die auf dem Display ausgegeben wurden.
noDisplay()
Schaltet alle Texte oder Cursor auf dem LCD aus. Die Texte/Daten werden nicht aus dem LCD-Speicher gelöscht.
Das bedeutet, sie werden wieder angezeigt, wenn die Funktion display() aufgerufen wird.
Das folgende Beispiel erzeugt einen blinkenden Texteffekt.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
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. Siehe den Abschnitt zum Erstellen und Anzeigen benutzerdefinierter Zeichen weiter unten für mehr Infos.
scrollDisplayLeft()
Scrollt den Inhalt des Displays (Text und Cursor) um eine Position nach links.
Du kannst diese Funktion im Loop-Teil des Codes zusammen mit delay(500)verwenden, um eine Lauftext-Animation zu erzeugen.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
lcd.print("Hello World!");
}
void loop() {
lcd.scrollDisplayLeft();
delay(500);
}
scrollDisplayRight()
Scrollt den Inhalt des Displays (Text und Cursor) um eine Position nach rechts.
autoscroll()
Aktiviert das automatische Scrollen des LCD. Dadurch wird jedes ausgegebene Zeichen das vorherige um eine Position verschieben.
Wenn die aktuelle Schreibrichtung von links nach rechts ist (Standard), scrollt das Display nach links, bei rechts-nach-links scrollt es nach rechts.
Dadurch wird jedes neue Zeichen an derselben Position auf dem LCD ausgegeben.
Das folgende Beispiel aktiviert automatisches Scrollen und gibt die Zeichen 0 bis 9 an der Position (16,0) des LCD aus. Ändere dies auf (20,0) für ein 20×4 LCD.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
}
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 LCD.
leftToRight()
Diese Funktion sorgt dafür, dass der Text vom Cursor aus nach rechts fließt, als wäre das Display linksbündig (Standard).
rightToLeft()
Diese Funktion sorgt dafür, 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() ist es möglich, benutzerdefinierte Zeichen auf dem LCD zu erstellen und anzuzeigen. Das ist besonders nützlich, wenn du ein Zeichen anzeigen möchtest, das nicht Teil der ASCII character set ist.
CGROM und CGRAM
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 standardmäßigen 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 4 speichern. Mehr Infos findest du im Datenblatt.
Beispielcode für benutzerdefinierte Zeichen
Der folgende Beispielsketch erstellt und zeigt acht benutzerdefinierte Zeichen (nummeriert 0 – 7). Du kannst den Code kopieren, indem du auf den Button oben rechts im Codefeld klickst.
/* Arduino example code to display custom characters on I2C character LCD. More info: www.www.makerguides.com */
// Include the library:
#include "LiquidCrystal_I2C.h"
// Create lcd object of class LiquidCrystal_I2C:
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.
// 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() {
// Initialize LCD and turn on the backlight:
lcd.init();
lcd.backlight();
// Create 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);
// Clear the LCD screen:
lcd.clear();
// Print a message to the lcd:
lcd.print("Custom Character");
}
// Print all the custom characters:
void loop() {
lcd.setCursor(0, 1);
lcd.write(0);
lcd.setCursor(2, 1);
lcd.write(1);
lcd.setCursor(4, 1);
lcd.write(2);
lcd.setCursor(6, 1);
lcd.write(3);
lcd.setCursor(8, 1);
lcd.write(4);
lcd.setCursor(10, 1);
lcd.write(5);
lcd.setCursor(12, 1);
lcd.write(6);
lcd.setCursor(14, 1);
lcd.write(7);
}
Du solltest die folgende Ausgabe auf dem LCD sehen:
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 (nur 5 Bits werden berücksichtigt). Es gibt 1 Byte für jede Zeile der 5 x 8 LED-Matrix. 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 ansieht, erkennt 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. Das Präfix ‚B‘ ist der Arduino-spezifische Binärformatierer.
Es ist möglich, jede Zeile manuell zu bearbeiten, aber ich empfehle die Verwendung dieser Online-LCD Custom Character Generator. Diese Anwendung erstellt automatisch das Zeichenarray, 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 erstellte Zeichenarray.
// Create 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 Argument verwenden wir die Nummer des benutzerdefinierten Zeichens, das angezeigt werden soll.
lcd.setCursor(0, 1); lcd.write(0);
Fazit
In diesem Artikel habe ich dir gezeigt, wie du ein Character I2C LCD mit Arduino verwendest. Wir haben auch einen Artikel zu How To Control A Character I2C LCD with ESP32, falls du stattdessen mit einem ESP32-Mikrocontroller arbeiten möchtest.
Wenn du Fragen, Vorschläge hast oder denkst, dass in diesem Tutorial etwas fehlt, hinterlasse bitte unten einen Kommentar.
