Raspberry Pi LCD Display HD44780 ansteuern (2×16 Zeichen)

Der Raspberry Pi und andere Einplatinencomputer bieten jede Menge Möglichkeiten der Datenverarbeiten. Im Headless-Betrieb bietet es sich an einige Daten einer Anwendung, oder wichtige System-Informationen des Pi auf einem LCD Display auszugeben. Der LCD Display HD44780 eignet sich dafür und ist mit wenig Aufwand am Pi installiert. Im Folgenden wird gezeigt, wie man am Raspberry Pi einen LCD Display HD44780 ansteuern kann.

LCD Display HD44780

In Verbindung mit dem Raspberry Pi ist der LCD Display mit dem Controller HD44780 gängig. Auf dem Display können auf 2 Zeilen jeweils 16 Zeichen ausgegeben werden. Preislich liegt der LCD Display, je nach Anbieter, zwischen 3 und 6 Euro. Für den Anschluss an Pi bzw. erste Tests eignet sich die Verwendung von Jumperkabeln und eines Breadboards. Je nach Aufbau und Verkabelung ist darauf zu achten, welche Jumperkabel man benötigt: Male – Male, Male – Female oder Female – Female. Desweiteren muss an dem Display eine Stiftleiste(Rastermaß 2,54) installiert werden, um Jumperkabel für das Verbinden zu nutzen. Alternativ zu dem Testaufbau können auch Drähte direkt an den HD44780 gelötet werden.

• LCD Display HD44780
• Stiftleisten Rastermaß 2,54 (für LCD Display)
• Jumperkabel
• Breadboard

Schaltungsaufbau

Der LCD Display HD44780 verfügt insgesamt über 16 Pins. Für die reine Ansteuerung werden jedoch nur 6 GPIO Ports am Einplatinencomputer benötigt. Die Wahl der GPIO Pins, welche man nutzen will bzw. nutzen kann, ist dem Anwender überlassen. Bei Wahl von anderen GPIO-Pins als hier im Artikel verwendet, muss dementsprechend der Folgende Quellcode zu Ansteuerung angepasst werden. Im Folgenden sind die einzelnen Pins des LCD Displays HD44780 und deren Bedeutung für die Beschaltung näher definiert.

Die Beschaltung des Displays und der Anschluss an den Raspberry Pi kann mit Hilfe der abgebildeten Tabelle vorgenommen werden. Besonders zu berücksichtigen ist dabei Pin 5 am LCD Display HD44780 zur Konfiguration von Lesen und Schreiben (Read/Write). Für unser Vorhaben, sprich zum Schreiben von Daten auf dem Display, muss der Pin auf GND (Masse) geschalten werden. Prinzipiell könnte man auch Daten vom Display auf dem Pi einlesen. Dies ist aber nicht praktikabel: Grund dafür ist das der Display mit einem Spannungspegel von 5 Volt arbeitet. Die GPIO Pins des Raspberry Pi vertragen nur 3,3 Volt, sodass eine direkte Beschaltung im Lesemodus den Pi beschädigen bzw. zerstören wurde.

LCD Display HD44780: LED Hintergrundbeleuchtung und Kontrasteinstellung

Die Beschaltung des Displays am Raspberry Pi nach der vorgestellten Tabelle genügt prinzipiell zur Anteuerung. In meinem Fall war der Text dennoch relativ schlecht lesbar auf Grund der schlechten Kontrasteinstellung. Durch Anpassung der Schaltung kann die Lesbarkeit deutlich optimiert werden.

Zur Anpassung des Kontrastes kann können wir an Pin 3 (Kontrastspannung) des LCD Displays die Spannung zwischen 0 und 5 Volt variieren. Hierfür wird ein Poti (10 kOhm) zwischen Raspberry Pi und Pin 3 des LCDs geschalten.

Die Helligkeit der LED Hintergrundbeleuchtung des Displays kann mit Hilfe eines Widerstandes oder Potentiometers (Trimmer-Poti) angepasst werden. Dazu wird zwischen Pin 15 des LCDs (Anode) und den +5 Volt des Raspberry Pi ein 470 Ohm Widerstand (oder Poti, z.B. 1 kOhm) geschalten. In meinem Fall habe ich verwende ich einen festen 470 Ohm Widerstand. Nach der Anpassung bzw. Erweiterung der Beschaltung resultiert die im Folgenden dargestellte Schaltung.

LCD Display HD44780

LCD Display HD44780 ansteuern mit Python

Zum Ausgeben von Informationen auf dem Display nutzen wir einen Python-Skript. Dazu legen wir eine neue Datei mit dem Editor nano an.

nano hd44780.py

In die Datei fügen wir den folgenden Code ein.

#!/usr/bin/python
import time
import RPi.GPIO as GPIO

# GPIO Pins festlegen (anpassen)
LCD_RS = 37
LCD_E  = 33
LCD_DATA4 = 31
LCD_DATA5 = 29
LCD_DATA6 = 27
LCD_DATA7 = 26

LCD_WIDTH = 16 		# Zeichen je Zeile
LCD_LINE_1 = 0x80 	# Adresse LCD Zeile 1
LCD_LINE_2 = 0xC0 	# Adresse LCD Zeile 2
LCD_CHR = GPIO.HIGH
LCD_CMD = GPIO.LOW
E_PULSE = 0.0005
E_DELAY = 0.0005
		
def display_init():
	lcd_write_byte(0x33, LCD_CMD)
	lcd_write_byte(0x32, LCD_CMD)
	lcd_write_byte(0x28, LCD_CMD)
	lcd_write_byte(0x0C, LCD_CMD)  
	lcd_write_byte(0x06, LCD_CMD)
	lcd_write_byte(0x01, LCD_CMD)

def lcd_write_byte(bits, mode):
	# Pins auf LOW setzen
	GPIO.output(LCD_RS, mode)
	GPIO.output(LCD_DATA4, GPIO.LOW)
	GPIO.output(LCD_DATA5, GPIO.LOW)
	GPIO.output(LCD_DATA6, GPIO.LOW)
	GPIO.output(LCD_DATA7, GPIO.LOW)
	if bits & 0x10 == 0x10:
	  GPIO.output(LCD_DATA4, GPIO.HIGH)
	if bits & 0x20 == 0x20:
	  GPIO.output(LCD_DATA5, GPIO.HIGH)
	if bits & 0x40 == 0x40:
	  GPIO.output(LCD_DATA6, GPIO.HIGH)
	if bits & 0x80 == 0x80:
	  GPIO.output(LCD_DATA7, GPIO.HIGH)
	time.sleep(E_DELAY)    
	GPIO.output(LCD_E, GPIO.HIGH)  
	time.sleep(E_PULSE)
	GPIO.output(LCD_E, GPIO.LOW)  
	time.sleep(E_DELAY)      
	GPIO.output(LCD_DATA4, GPIO.LOW)
	GPIO.output(LCD_DATA5, GPIO.LOW)
	GPIO.output(LCD_DATA6, GPIO.LOW)
	GPIO.output(LCD_DATA7, GPIO.LOW)
	if bits&0x01==0x01:
	  GPIO.output(LCD_DATA4, GPIO.HIGH)
	if bits&0x02==0x02:
	  GPIO.output(LCD_DATA5, GPIO.HIGH)
	if bits&0x04==0x04:
	  GPIO.output(LCD_DATA6, GPIO.HIGH)
	if bits&0x08==0x08:
	  GPIO.output(LCD_DATA7, GPIO.HIGH)
	time.sleep(E_DELAY)    
	GPIO.output(LCD_E, GPIO.HIGH)  
	time.sleep(E_PULSE)
	GPIO.output(LCD_E, GPIO.LOW)  
	time.sleep(E_DELAY)    

def lcd_message(message):
	message = message.ljust(LCD_WIDTH," ")  
	for i in range(LCD_WIDTH):
	  lcd_write_byte(ord(message[i]),LCD_CHR)
	
if __name__ == '__main__':
	# Init
	GPIO.setmode(GPIO.BCM)
	GPIO.setwarnings(False)
	GPIO.setup(LCD_E, GPIO.OUT)
	GPIO.setup(LCD_RS, GPIO.OUT)
	GPIO.setup(LCD_DATA4, GPIO.OUT)
	GPIO.setup(LCD_DATA5, GPIO.OUT)
	GPIO.setup(LCD_DATA6, GPIO.OUT)
	GPIO.setup(LCD_DATA7, GPIO.OUT)

	display_init()
	
	lcd_write_byte(LCD_LINE_1, LCD_CMD)
	lcd_message("einplatinen")
	lcd_write_byte(LCD_LINE_2, LCD_CMD)
	lcd_message("computer.com")

Nach dem Einfügen des Codes können wir die Datei speichern und schließen. Weiterhin passen wir optional noch die Rechte an.

chmod +x hd44780.py

Zum Ausführen des Codes wird folgender Befehl genutzt. Wenn das Display richtig angeschlossen ist, sollte der Text einplatinencomputer.com auf dem Display sichtbar werden.

python hd44780.py

Der Python Skript baut sich grundlegend aus mehreren Funktionen auf. Dabei dient die die Funktion lcd_write_byte() dem schreiben von Bytes auf dem Display über die Datenleitungen. Weiterhin wird mit der Funktion display_init() der LCD HD44780 initialisiert und auf einen Anfangszustand gesetzt. Zuletzt nutzen wir die Funktion lcd_message() um Texte auf dem Display zu schreiben. In der eigentlichen Main-Funktion des Skripts werden die GPIO-Pins initialisiert (auf Output gesetzt), der Display initialisiert und anschließend der Text einplatinencomputer.com geschrieben. Wichtig ist, dass zu Beginn des Skripts die verwendetes GPIO-Pins angepasst werden, im Falle das bei Eurem Aufbau andere Pins genutzt werden als hier im Tutorial.

# GPIO Pins festlegen (anpassen)
LCD_RS = 37
LCD_E  = 33
LCD_DATA4 = 31
LCD_DATA5 = 29
LCD_DATA6 = 27
LCD_DATA7 = 26

Der hier vorgestellte Python-Code bildet prinzipiell eine grundlegende Möglichkeit, um Ausgaben auf dem Display zu erzeugen. Durch Erweitern des Skripts können diverse Informationen mit der Funktion lcd_message() auf das LCD Display HD44780 geschrieben werden.

LCD Display HD44780: CPU Temperatur und Frequenz ausgeben

Um diesem Tutorial einen weiteren praktischen Bezug zu geben, kann der bereits vorgestellte Code erweitert werden. Dabei können wir beispielsweise den Skript um die folgendne Funktionen erweitern. Mit der Funktion get_cpu_temp() wird die Temperatur und mit get_cpu_speed() die aktuelle Frequenz des Prozessors des Raspberry Pi ermittelt.

def get_cpu_temp():
        tempFile = open("/sys/class/thermal/thermal_zone0/temp")
        cpu_temp = tempFile.read()
        tempFile.close()
        return float(cpu_temp)/1000

def get_cpu_speed():
        tempFile = open("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq")
        cpu_speed = tempFile.read()
        tempFile.close()
        return float(cpu_speed)/1000

Um nun die beiden Werte auszugeben nutzen wir die bereits bestehende Funktion lcd_message().

	lcd_write_byte(LCD_LINE_1, LCD_CMD)
	lcd_message("CPU Temp: " + str(round(get_cpu_temp(), 2)))
	lcd_write_byte(LCD_LINE_2, LCD_CMD)
	lcd_message("CPU Speed: " + str(round(get_cpu_speed(), 2))