Ein 16×2 Zeichen LCD-Display am Raspberry Pi – ein Klassiker. Uhrzeit, IP-Adresse, Sensorwerte oder Statusmeldungen direkt auf einem kleinen Display ausgeben, ohne Monitor und ohne SSH-Verbindung. In diesem Tutorial zeige ich euch zwei Methoden: die direkte GPIO-Verkabelung (wie im Original von 2014) und die viel einfachere I2C-Methode mit einem PCF8574-Adapter. Fuer beide verwenden wir die moderne Python-Library RPLCD – kein eigener LCD-Code mehr noetig.
Material
Methode 1 – Direkte GPIO-Verkabelung:
- 16×2 LCD Display (HD44780-kompatibel)
- Drehpotentiometer 10k oder 50k Ohm (fuer Kontrasteinstellung)
- Breadboard und Jumper-Kabel
Methode 2 – I2C-Adapter (empfohlen):
- 16×2 LCD mit I2C-Adapter (PCF8574) – oft guenstig als Set erhaeltlich
- 4 Jumper-Kabel (statt ~11 bei der direkten Methode)
Die I2C-Methode ist deutlich einfacher: Nur 4 Kabel statt 11, kein Potentiometer noetig (der Kontrast wird per Software eingestellt) und der Code ist sauberer. Wenn ihr noch kein Display habt, kauft direkt ein Set mit PCF8574-Adapter.
Methode 1: Verkabelung direkt ueber GPIO
Das HD44780-LCD hat 16 Pins. Wir verwenden den 4-Bit-Modus, daher werden nur die Datenpins D4-D7 verdrahtet. Die Pinbelegung hier entspricht dem bewaeehrten Original-Setup:
| LCD Pin | LCD Funktion | Verbindung | Raspberry Pi PIN |
|---|---|---|---|
| 01 | GND (VSS) | GND | PIN 6 |
| 02 | +5V (VDD) | 5V | PIN 2 |
| 03 | Kontrast (V0) | Poti (mittlerer Pin) | – (Poti-Enden an 5V/GND) |
| 04 | RS | GPIO7 | PIN 26 |
| 05 | RW | GND (nur schreiben) | PIN 6 |
| 06 | E (Enable) | GPIO8 | PIN 24 |
| 07–10 | D0–D3 | nicht benoetigt (4-Bit-Modus) | – |
| 11 | D4 | GPIO25 | PIN 22 |
| 12 | D5 | GPIO24 | PIN 18 |
| 13 | D6 | GPIO23 | PIN 16 |
| 14 | D7 | GPIO18 | PIN 12 |
| 15 | LED+ (Hintergrundbeleuchtung) | 5V | PIN 2 |
| 16 | LED– (Hintergrundbeleuchtung) | GND | PIN 6 |
Methode 2: Verkabelung mit I2C-Adapter (empfohlen)
Der PCF8574 I2C-Adapter sitzt direkt auf der Rueckseite des LCD-Displays und reduziert die Verkabelung auf nur 4 Kabel:
| I2C-Adapter Pin | Raspberry Pi | PIN-Nummer |
|---|---|---|
| GND | GND | PIN 6 |
| VCC | 5V | PIN 2 |
| SDA | SDA (GPIO2) | PIN 3 |
| SCL | SCL (GPIO3) | PIN 5 |
I2C aktivieren (nur fuer Methode 2)
I2C muss auf dem Raspberry Pi aktiviert werden:
|
1 |
sudo raspi-config |
Navigiert zu Interface Options → I2C → Yes. Dann rebooten:
|
1 |
sudo reboot |
Nach dem Neustart koennt ihr pruefen, ob der I2C-Adapter erkannt wird:
|
1 |
sudo i2cdetect -y 1 |
Ihr solltet bei Adresse 0x27 (oder 0x3f bei manchen Modulen) einen Eintrag sehen. Notiert euch die Adresse – die braucht ihr im Python-Script.
RPLCD installieren
Statt eigenem LCD-Code verwenden wir heute die ausgereifte Python-Library RPLCD, die beide Methoden unterstuetzt:
|
1 2 3 |
sudo apt update sudo apt install -y python3-pip python3-smbus i2c-tools sudo pip install RPLCD smbus2 |
Auf neueren Raspberry Pi OS Versionen (Bookworm) kann pip ohne --break-system-packages Probleme machen. Falls noetig:
|
1 |
sudo pip install RPLCD smbus2 --break-system-packages |
Oder sauberer mit einer virtuellen Umgebung:
|
1 2 |
python3 -m venv /home/pi/lcd-env /home/pi/lcd-env/bin/pip install RPLCD smbus2 |
Python-Script: Direkte GPIO-Methode
Fuer die direkte Verkabelung nutzen wir RPLCD.gpio:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from RPLCD.gpio import CharLCD import RPi.GPIO as GPIO lcd = CharLCD( cols=16, rows=2, pin_rs=7, pin_e=8, pins_data=[25, 24, 23, 18], numbering_mode=GPIO.BCM ) lcd.write_string('Hallo Raspberry!') lcd.cursor_pos = (1, 0) lcd.write_string('raspberry.tips') |
Speichert das Script als /home/pi/lcd.py und testet es:
|
1 |
python3 /home/pi/lcd.py |
Falls ihr eine dunkle Flaeche seht aber keinen Text – am Potentiometer drehen bis der Kontrast stimmt.
Python-Script: I2C-Methode
Fuer den I2C-Adapter ist der Code noch einfacher:
|
1 2 3 4 5 6 7 8 9 |
from RPLCD.i2c import CharLCD # I2C-Adresse pruefen mit: sudo i2cdetect -y 1 # Haeufig 0x27 oder 0x3f lcd = CharLCD('PCF8574', 0x27) lcd.write_string('Hallo Raspberry!') lcd.cursor_pos = (1, 0) lcd.write_string('raspberry.tips') |
Falls eure I2C-Adresse 0x3f ist, ersetzt einfach 0x27 entsprechend.
Uhrzeit und IP-Adresse anzeigen
Das ist das klassische „Proof of concept“ – Uhrzeit in Zeile 1, IP-Adresse in Zeile 2, aktualisiert jede Sekunde. Hier die I2C-Version (fuer GPIO-Methode einfach den LCD-Import und die Initialisierung tauschen):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
#!/usr/bin/env python3 import time import socket import subprocess from RPLCD.i2c import CharLCD lcd = CharLCD('PCF8574', 0x27) def get_ip(): try: result = subprocess.run( ['hostname', '-I'], capture_output=True, text=True ) ip = result.stdout.strip().split()[0] return ip except Exception: return 'keine IP' lcd.clear() while True: uhrzeit = time.strftime('%d.%m.%Y %H:%M') ip = get_ip() lcd.cursor_pos = (0, 0) lcd.write_string(uhrzeit.ljust(16)) lcd.cursor_pos = (1, 0) lcd.write_string(('IP:' + ip).ljust(16)) time.sleep(1) |
Speichert als /home/pi/lcd.py und testet:
|
1 |
python3 /home/pi/lcd.py |
Autostart via systemd
Statt dem alten update-rc.d verwenden wir heute systemd-Services. Erstellt eine neue Service-Datei:
|
1 |
sudo nano /etc/systemd/system/lcd.service |
Fuegt folgenden Inhalt ein:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
[Unit] Description=LCD Display Anzeige After=network.target [Service] Type=simple User=pi ExecStart=/usr/bin/python3 /home/pi/lcd.py Restart=always RestartSec=5 [Install] WantedBy=multi-user.target |
Speichert mit STRG+X, Y, ENTER. Dann den Service aktivieren und starten:
|
1 2 3 |
sudo systemctl daemon-reload sudo systemctl enable lcd.service sudo systemctl start lcd.service |
Den Status pruefen:
|
1 |
sudo systemctl status lcd.service |
Bei der virtuellen Umgebung ersetzt ihr ExecStart durch:
|
1 |
ExecStart=/home/pi/lcd-env/bin/python3 /home/pi/lcd.py |
Fazit
Mit RPLCD und einem I2C-Adapter ist die LCD-Ansteuerung am Raspberry Pi heute deutlich einfacher als noch 2014. Vier Kabel, ein paar Zeilen Python, und ihr habt eine funktionsfaehige Anzeige. Wer das Display dauerhaft betreiben moechte, sollte auf die I2C-Variante setzen – weniger Kabelsalat, stabiler und einfacher zu erweitern.
