Einstieg in Python, Teil 13

OLED – Displaytechnik mit Python

Mit dem Raspberry Pi lassen sich kleine Displays problemlos ansteuern. Die Kombination aus präziser Hardwarekontrolle und einer vielseitigen Programmiersprache wie Python ermöglicht einen strukturierten, praxisnahen Einstieg. Neben den theoretischen Grundlagen werden auch verschiedene praktische Anwendungen vorgestellt.

OLED-Display am Raspberry Pi

Eines der bekanntesten und am weitesten verbreiteten OLED-Displays (Organic Light Emitting Diode) ist das SSD1306. Es handelt sich dabei um ein kompaktes, monochromes Display mit typischen Auflösungen von 128×64 Pixel. In den meisten Anwendungen wird das Bauteil über den I²C-Bus angesteuert, Varianten mit SPI-Anschluss kommen eher seltener zum Einsatz. Im Folgenden soll daher speziell der I²C-Bus verwendet werden. Aufgrund seines geringen Stromverbrauchs eignet sich das SSD1306 ideal für kleine, energieeffiziente Projekte. Das Display lässt sich problemlos in Systeme wie Raspberry Pi, den Pico oder auch andere Mikrocontroller integrieren und ermöglicht die Darstellung von Text, Grafiken und einfachen Animationen. Bild 1 zeigt ein typisches SSD1306-OLED-Display.

Der Einsatz des SSD1306-OLED-Displays in Kombination mit Python bietet zahlreiche Vorteile. Durch freie Bibliotheken lässt sich das Display sehr einfach ansteuern, sodass Text, Grafiken oder einfache Animationen ohne Low-Level-Programmierung dargestellt werden können. Die Integration mit der Python-Bibliothek Pillow ermöglicht zudem das Erstellen von Bildern, Formen und Schriftzügen, wodurch sich z. B. Diagramme, Symbole oder animierte Texte leicht realisieren lassen. Python macht den Einsatz zudem plattformunabhängig: Programme, die auf einem Raspberry Pi funktionieren, lassen sich häufig auch auf MicroPython-kompatiblen Boards ohne große Anpassungen nutzen. Dadurch eignet sich die Kombination aus SSD1306 und Python besonders gut für interaktive Anwendungen und schnelles Prototyping, etwa in Verbindung mit Sensoren, Tasten oder Drehgebern, wodurch dynamische und anpassbare Anzeigen auf dem Display möglich werden. Für den Betrieb muss zunächst der I²C-Bus auf den Raspberry Pi aktiviert werden:

            sudo raspi-config → Interface Options → I²C → Enable

Dann kann das Display mit lediglich vier Leitungen an den Raspberry Pi angeschlossen werden:

OLED-Pin	Raspberry-Pi-Pin	Name
VCC	3,3 V (Pin 1)	Stromversorgung
GND	GND (z. B. Pin 6)	Masse
SDA	SDA (Pin 3)	I²C-Daten
SCL	SCL (Pin 5)	I²C-Clock

Der gesamte Aufbau ist in Bild 2 zu sehen.

Die Luma Library

„Luma.OLED“ ist eine leistungsfähige Python-Bibliothek zur Ansteuerung von OLED-Displays wie dem SSD1306. Sie baut auf dem Python-Imaging-Library-(Pillow)-Framework auf und ermöglicht die einfache Darstellung von Texten, Formen, Grafiken und Animationen. Die Bibliothek abstrahiert die Low-Level-Kommunikation über I²C. Man kann damit also direkt mit Grafikbefehlen arbeiten, ohne sich um einzelne Register oder das Bus-Timing kümmern zu müssen.
Mit Luma.OLED lassen sich auf dem SSD1306-Display nicht nur statische Inhalte darstellen, sondern auch dynamische Informationen wie Sensorwerte, Uhren oder einfache Animationen. Die Bibliothek ist plattformübergreifend und unterstützt neben dem Raspberry Pi auch andere Mikrocontroller und Einplatinencomputer, die Python ausführen.

Ein weiterer Vorteil ist die nahtlose Integration mit Pillow, wodurch das Erstellen komplexerer Grafiken, Logos oder Diagramme sehr einfach wird. Luma.OLED eignet sich daher sowohl für schnelles Prototyping als auch für fertige Anwendungen, die eine stabile und flexible Anzeige benötigen. Die Installation der Lib erfolgt über:

            pip3 install luma.oled

Nach erfolgreicher Installation kann die Funktion des Displays mit dem folgenden Programm getestet werden (Luma_tst.py):

from luma.core.interface.serial import i2c
from luma.oled.device import ssd1306
from PIL import ImageDraw, ImageFont, Image

serial = i2c(port=1, address=0x3C)
device = ssd1306(serial)

draw = ImageDraw.Draw(device)
draw.text((0, 0), "Hallo Pi!", fill=255)
device.show()

Bild 2 zeigt die Ausgabe auf dem Display. Natürlich lassen sich auch wichtigere Daten als eine Begrüßung auf dem Display darstellen. Die Anzeige von IP-Adresse und CPU-Temperatur auf einem kleinen OLED-Display wie dem SSD1306 bietet mehrere praktische Vorteile. Zum einen ermöglicht sie einen schnellen Zugriff auf wichtige Systeminformationen, ohne dass zusätzliche Monitore oder Terminals erforderlich sind. Besonders bei headless-Systemen ohne Bildschirm am HDMI-Port ist es oft mühsam, per SSH oder Netzwerktools die aktuelle IP-Adresse zu ermitteln; ein kleines Display zeigt diese Information sofort an.
Zum anderen liefert die Anzeige der CPU-Temperatur eine einfache Möglichkeit zur Überwachung des Systems. So lassen sich Überhitzung oder ungewöhnliche Lastspitzen frühzeitig erkennen, was die Zuverlässigkeit und Sicherheit des Geräts erhöht. Durch die kompakte, grafische Darstellung auf dem OLED können diese Informationen zudem übersichtlich und auf einen Blick erfasst werden, ohne die Konsole oder das Netzwerk-Interface bemühen zu müssen. Ein einfaches Programm ermöglicht die entsprechende Ausgabe (Luma_data.py):

import os
import time
import subprocess
from luma.core.interface.serial import i2c
from luma.oled.device import ssd1306
from luma.core.render import canvas

# --- OLED Initialisieren ---
serial = i2c(port=1, address=0x3C)
device = ssd1306(serial)

def get_ip():
    try:
        # Sehr zuverlässig, selbst wenn WLAN/LAN nicht aktiv ist
        ip = subprocess.check_output(
            "hostname -I", shell=True
        ).decode().strip().split()[0]
    except:
        ip = "Keine IP"
    return ip

def get_cpu_temp():
    # Temperatur aus /sys lesen
    with open("/sys/class/thermal/thermal_zone0/temp", "r") as f:
        temp_raw = f.read().strip()
    temp_c = float(temp_raw) / 1000.0
    return f"{temp_c:.1f}°C"

# --- Hauptschleife ---
while True:
    ip = get_ip()
    temp = get_cpu_temp()

    with canvas(device) as draw:
        draw.text((0, 0), "Raspberry Pi", fill=255)
        draw.text((0, 16), f"IP:  {ip}", fill=255)
        draw.text((0, 32), f"CPU: {temp}", fill=255)

    time.sleep(1)

Bild 3 zeigt, wie die Daten auf dem OLED dargestellt werden.

Wenn man das Display aus größerer Entfernung ablesen will, kann man auch andere Fonts verwenden. Die Luma Library zeigt sich hier sehr flexibel (Luma_FONTs.py):

from luma.core.interface.serial import i2c
from luma.oled.device import ssd1306
from luma.core.render import canvas
from PIL import ImageFont

# --- OLED initialisieren ---
serial = i2c(port=1, address=0x3C)
device = ssd1306(serial)

# --- Schriften laden ---
font_small  = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 10)
font_medium = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 14)
font_large  = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 20)

# --- Zeichnen ---
with canvas(device) as draw:
    draw.text((0, 0),  "Kleine Schrift", font=font_small, fill=255)
    draw.text((0, 11), "Mittlere Schrift", font=font_medium, fill=255)
    draw.text((0, 26), "GROSSE", font=font_large, fill=255)
    draw.text((0, 45), "Schrift!", font=font_large, fill=255)

Ein wesentlicher Vorteil der Luma Lib liegt in der einfachen Handhabung von Schriftarten und Grafiken. Dank der Integration mit der Python-Bibliothek Pillow lassen sich sowohl Standard- als auch benutzerdefinierte Fonts problemlos verwenden. Texte können in verschiedenen Größen, Stilen und Positionen dargestellt werden, wodurch sich das Display flexibel für unterschiedliche Anwendungen anpassen lässt. Darüber hinaus ermöglicht Luma.OLED das Zeichnen von Linien, Rechtecken, Kreisen, Icons oder komplexen Bildern, die direkt auf dem SSD1306-Display ausgegeben werden können. Diese Kombination aus Text- und Grafikfunktionen macht die Bibliothek ideal für interaktive Visualisierungen, Diagramme oder animierte Elemente, ohne dass tiefgreifendes Low-Level-Wissen erforderlich ist. Bild 4 zeigt die Verwendung verschiedener Font-Größen.

OLEDs als Minibildschirme: Grafikausgabe

OLED-Displays haben sich als vielseitige Minibildschirme etabliert, die dank ihrer hohen Helligkeit, kontrastreichen Darstellung und geringen Baugröße in einer Vielzahl von Projekten eingesetzt werden können. Insbesondere die Möglichkeit, Grafiken, Texte und Symbole direkt auf dem Display auszugeben, macht sie zu einem idealen Werkzeug für interaktive Anwendungen, Prototyping und kleine Benutzeroberflächen.

Luma.OLED ermöglicht die einfache Integration solcher Displays in Python-Projekte. Sie bietet die volle Kontrolle über Pixel, Formen, Linien und Schriftarten. Durch die Kombination mit Grafikbibliotheken können nicht nur statische Inhalte, sondern auch dynamische Visualisierungen, einfache Animationen oder Diagramme auf kleinen OLEDs realisiert werden (Bild 5).

Das folgende Programm zeigt eine einfach Grafikausgabe (Luma_Graphics.py):

from luma.core.interface.serial import i2c 
from luma.oled.device import ssd1306
from PIL import Image, ImageDraw

# I2C-Verbindung aufbauen
serial = i2c(port=1, address=0x3C)
device = ssd1306(serial, width=128, height=64)

# Neues Bild erstellen
image = Image.new("1", (device.width, device.height))
draw = ImageDraw.Draw(image)

# Smiley
draw.ellipse((44, 12, 84, 52), outline=255, fill=0)   # Kopf
draw.ellipse((54, 22, 60, 28), fill=255)              # linkes Auge
draw.ellipse((68, 22, 74, 28), fill=255)              # rechtes Auge
draw.arc((54, 34, 74, 44), start=0, end=180, fill=255, width=2)  # Mund

# Bild auf OLED anzeigen
device.display(image)

Datenaufzeichnung

Die Luma.OLED-Bibliothek eignet sich auch hervorragend für Datenvisualisierung und -aufzeichnung in Echtzeit. Insbesondere in Projekten mit Mikrocontrollern oder Einplatinencomputern wie dem Raspberry Pi kann die Bibliothek genutzt werden, um Messwerte von Sensoren, Systeminformationen oder andere dynamische Daten direkt auf einem kompakten Display anzuzeigen.

Durch die Kombination von Luma.OLED mit Python können Daten zunächst erfasst, verarbeitet und anschließend grafisch oder numerisch aufbereitet werden. Die Integration mit der Pillow-Bibliothek ermöglicht es, Diagramme, Balkenanzeigen, Verlaufskurven oder kleine Grafiken zu erstellen, die auf dem OLED-Display übersichtlich angezeigt werden. Dies ist besonders nützlich für Anwendungen wie Temperaturüberwachung, Netzwerkstatistiken, Logdaten oder andere Messreihen, da die Informationen direkt sichtbar sind, ohne dass ein externer Monitor benötigt wird.

Ein weiterer Vorteil der Luma.OLED-Bibliothek ist die Möglichkeit, laufend aktualisierte Inhalte anzuzeigen. So lassen sich z. B. Sensorwerte in Echtzeit aufzeichnen und grafisch darstellen, was eine schnelle Interpretation und Analyse von Daten direkt am Gerät ermöglicht. Insgesamt eignet sich Luma.OLED damit ideal für kleine, mobile oder energieeffiziente Projekte, bei denen eine visuelle Rückmeldung von Daten notwendig ist. Das folgende Programm stellt beispielsweise die CPU-Temperatur des Raspberry Pi als durchlaufende Grafik dar. Das heißt, die Werte werden grafisch auf dem Bildschirm angezeigt, wobei die entstehende Kurve — ähnlich wie bei einem EKG im Krankenhaus — von rechts nach links über den Bildschirm läuft (Luma_scroll.py).

import time
from collections import deque
from luma.core.interface.serial import i2c
from luma.oled.device import ssd1306
from luma.core.render import canvas

# OLED initialisieren
serial = i2c(port=1, address=0x3C)
device = ssd1306(serial)

# Speicher für die Graph-Werte
WIDTH = device.width
HEIGHT = device.height
data = deque([0]*WIDTH, maxlen=WIDTH)

def get_cpu_temp():
    with open("/sys/class/thermal/thermal_zone0/temp") as f:
        return float(f.read().strip()) / 1000.0

while True:
    # Neue Temperatur holen
    temp = get_cpu_temp()
    data.append(temp)

    # Werte für Graph normalisieren (0–70°C → 0–63px)
    t_min = 30.0
    t_max = 70.0
    def scale(v):
        v = max(min(v, t_max), t_min)
        return HEIGHT - int((v - t_min) / (t_max - t_min) * (HEIGHT - 1))

    # OLED zeichnen
    with canvas(device) as draw:
        draw.text((0, 0), f"{temp:.1f}°C", fill=255)
        # Graph
        for x in range(len(data)-1):
            y1 = scale(data[x])
            y2 = scale(data[x+1])
            draw.line((x, y1, x+1, y2), fill=255)

    time.sleep(.1)

Bild 6 zeigt die Ausgabe des Programms.

Abschließend noch ein wichtiger Hinweis:
Neben ihren vielen Vorteilen weisen OLED-Displays auch einen Nachteil auf. Im Dauerbetrieb bleichen die Pixel relativ schnell aus. Der Grund dafür liegt in der Funktionsweise der OLED-Technologie: Jedes Pixel besteht aus selbstleuchtenden, organischen Materialien, die sich mit der Zeit abnutzen. Je länger ein Pixel mit hoher Helligkeit leuchtet, desto schneller sinkt seine Leuchtkraft. Bereiche, die permanet das gleiche Bild anzeigen, verlieren daher schneller an Helligkeit als andere — dadurch entstehen dauerhafte Schatten oder eingebrannte Muster im Display. Man sollte daher statische Vollbilder über längere Zeit vermeiden, um diesen sogenannten „Burn-in“ zu verhindern.

Zusammenfassung und Ausblick

In diesem Artikel wurde die Programmierung von OLED-Anzeigen mit Python ausführlich dargestellt. Praktische Anwendungen reichten hierbei von einfachen Textausgaben bis hin zu grafischen Darstellungen. Dabei kam bereits der I²C-Bus als Bindeglied zwischen dem Raspberry Pi und dem OLED-Display zum Einsatz. Dies verdeutlicht die wichtige Rolle, die Bussysteme in der Programmierung spielen. Mit Python stellt der Einsatz solcher Bussysteme kein Problem dar.

In den folgenden Beiträgen sollen daher verschiedene Busse wie I²C oder SPI genauer betrachtet werden. Neben den grundlegenden Programmierkonzepten mit Python werden dabei auch wieder praktische Projekte und Einsatzmöglichkeiten vorgestellt.

Material

• Raspberry Pi mit Netzteil
• Breadboard und Jumper-Kabel
• OLED-Display
  

Über den Autor
Dr. Günter Spanner ist als Autor zu den Themen Elektronik, Sensortechnik und Mikrocontroller einem weiten Fachpublikum bekannt. Schwerpunkt seiner hauptberuflichen Tätigkeit für verschiedene Großkonzerne wie Siemens und ABB ist die Projektleitung im Bereich Entwicklung und Technologie-Management. Der Dozent für Physik und Elektrotechnik hat zudem zahlreiche Fachartikel und Bücher veröffentlicht sowie Kurse und Lernpakete erstellt.