Hotline-Icon
+49 (0) 391 4059 1090
Onlineshop und Projektplattform für: Raspberry Pi Zubehöre, Gehäuse, Bausätze, Baugruppen und Komplettgeräte
Onlineshop und Projektplattform für: Raspberry Pi Zubehöre, Gehäuse, Bausätze, Baugruppen und Komplettgeräte
Mein Benutzerkonto
Klicken zum Schliessen
Ich bin schon Kunde



Passwort vergessen

Neuer Kunde?
Jetzt registrieren

Tutorial: I2C OLED Display am Raspberry Pi einrichten

Oft ist es praktisch, ein kleines Display zur Verfügung zu haben, um Daten jedweder Art anzeigen zu können. Dafür stehen mittlerweile verschiedenste kleine OLED-Displays zur Verfügung, die einfach über Bibliotheken angesprochen und benutzt werden können.

Um mit diesen Displays kommunizieren zu können, ist es zunächst einmal wichtig, zu wissen, über welchen Treiberchip sie angesprochen werden. In diesem Tutorial werde ich auf die verbreitetsten beiden Chips, den SSD1306 und den SH1106, eingehen. Diese Treiber werden häufig für die gängigen ein- oder zweifarbigen 0.96 und 1.3 Zoll OLED-Displays eingesetzt.

In diesem kleinen Tutorial möchte ich Euch zeigen, wie Ihr mit Hilfe der Programmiersprache Python über den I2C-Bus des Raspberry Pi diese kleinen und sehr praktischen Displays verwenden könnt, um Text und/oder Grafik auf diesen Displays anzuzeigen.

Voraussetzung für die Inbetriebnahme des Displays am I2C-Bus ist ein fertig eingerichtetes Raspi-OS (Raspian). Damit die benötigten Pakete schon vorinstalliert sind, wählt Ihr, falls Ihr unsicher seid, am besten die Desktop-Variante des OS mit der empfohlenen vorinstallierten Software als Euer Image aus.

Falls Ihr ein Steckbrett und Steckbrücken zur Verfügung habt, benötigt Ihr kein Werkzeug. Ansonsten werden Lötkolben, Lötzinn, Litze und idealerweise ein 40-poliger Pfostenverbinder für den Aufbau benötigt. Der Rest ist Software. Es wäre also auch wichtig, dass Euer Pi grundsätzlich eingerichtet ist, idealerweise über ssh und/oder xrdp fernbedienbar ist und über eine funktionierende Internetverbindung verfügt. Anleitungen für diese Vorbereitungen findet Ihr in den folgenden Tutorials:

 - Raspberry Pi - Grundeinrichtung
 - Raspberry Pi - Lan und WLAN Konfiguration
 - Raspberry Pi - fernsteuern - ssh und Remote-Desktop

Um sicher zu gehen, dass auch Python installiert ist und Ihr wisst, wie die GPIO funktioniert, schaut Euch am besten auch noch dieses Tutorial an:

 - Raspberry Pi - GPIO Pinbelegung und WiringPi

Mit diesem Rüstzeug solltet Ihr perfekt für diese Anleitung vorbereitet sein.

1. OLED-Display mit dem Raspberry Pi verbinden.

Damit unser Raspberry Pi überhaupt mit unserem I2C-Gerät kommunizieren kann, muss er natürlich zunächst einmal elektrisch mit dem entsprechenden Gerät, in diesem Fall unserem Display, verbunden werden.

Für die I2C-Kommunikation benötigen wir hier genau drei Anschlüsse, plus einen Vierten für die Stromversorgung unseres Displays. Die Pins an der Schnittstelle des Displays sind meistens wie folgt beschriftet:

UCC/VCC/VDD/+ => Versorgungsspannung (normalerweise 3,3V=), Pluspol
G/GND/-              => Ground, Masse, Minuspol
C/CL/SDC/SCK     => Clock oder Taktanschluss des I2C-Busses
D/DA/SDA            => Datenleitung des I2C-Busses

Da die Displays einen äusserst geringen Stromverbrauch haben, können wir uns die Versorgungsspannung direkt über die 3,3V Pins des Raspberry Pi holen. Es mag sein, dass es auch Displays gibt, die mit 5V arbeiten, die Displays, die ich bisher verwendet habe, laufen alle mit 3,3V und sollten deshalb auch nur mit dieser Spannung versorgt werden.

Praktischerweise liegen somit alle GPIO-Anschlüsse des Raspberry Pi, die wir für den Anschluss eines I2C-Gerätes benötigen, ganz dicht beieinander. Die GPIO-Pinbelegung findet Ihr hier: GPIO-Belegung. Ein Anschlussschema für die Displays zeige ich Euch in der folgenden Grafik. Dazu verwende ich die beiden, meiner Meinung nach, am häufigsten auftretenden Bauformen dieser kleinen Anzeigen. Sucht Euch einfach die Variante heraus, die für Euch am besten passt.

Abb. 1: Anschlussschema für OLED-Display 128x64 Pixel

Anschlussschema I2C OLED 128x64
Abb. 2: Anschlussschema für OLED-Display 128x32 Pixel
Anschlussschema I2C OLED Display 128x32
Nachdem wir nun unser OLED-Display erfolgreich mit dem Raspberry Pi verbunden haben, kommen wir zum nächsten Schritt und bringen Strom ins Spiel.

2. Inbetriebnahme des Raspberry Pi mit dem angeschlossenen OLED-Display

Bevor wir jetzt den Raspberry Pi mit Strom versorgen, sollten wir noch einmal kritisch die Verkabelung in Augenschein nehmen und überprüfen, ob auch alle Käbelchen richtig angeschlossen sind. Sowohl der Raspberry Pi alsauch das Display verzeihen uns zwar meistens kleine Fehlerchen, sie können jedoch beide auch sehr leicht dauerhaften Schaden nehmen.

Nach der Überprüfung schalten wir dann einfach mal unseren frisch verkabelten Raspberry Pi ein. Sollte Euch die Elektronik jetzt Rauchsignale senden und merkwürdig riechen, dann wart Ihr im ersten Schritt wohl etwas leichtsinnig. Normalerweise fährt unser Pi jetzt einfach hoch und an unserem Display passiert noch gar nichts.

Um den I2C-Bus am Raspberry Pi benutzen zu können, müssen wir diesen zunächst einmal aktivieren. Zu diesem Zweck öffnen wir ein Terminal und starten das Raspberry Pi Konfigurationstool raspi-config. Das geht so:

pi@rechnername ~ : $ sudo raspi-config (enter)

In dem jetzt angezeigten Menü wählt Ihr den Punkt "Interfacing Options" (Schnittstellen-Optionen) aus und bestätigt die Auswahl mit Enter. Das nächste Menü zeigt Euch die vorhandenen Schnittstellen an. Hier geht Ihr jetzt zum Menüpunkt: I2C und bestätigt wieder mit Enter. Die Frage, ob Ihr die I2C-Schnittstelle aktivieren möchtet, beantwortet Ihr mit einem klaren JA. Bestätigung der Aktivierung des I2C-Busses sollte jetzt mit der Meldung: "The ARM I2C interface is enabled" kommen, die Ihr wieder mit OK (Enter) bestätigt. Raspi-config könnt Ihr dann über den Button "finish" wieder verlassen. Um sicher zu gehen, dass die Änderungen auch übernommen werden, booten wir vorsichtshalber unseren Pi noch einmal:

pi@rechnername ~ : $ sudo reboot (enter)

Nach dem Neustart können wir davon ausgehen, dass der I2C-Bus aktiviert ist. Damit sind alle Voraussetzungen für eine Kommunikation mit unserem OLED-Display geschaffen.


3. Etwas Theorie und erste Schritte mit dem I2C-Bus

Bevor wir uns tiefer in Details verstricken, möchte ich Euch noch ein paar kleine Informationen zum I2C-Bus geben. Der I2C-Bus wurde ursprünglich von Philips zur geräteinternen Kommunikation diverser Komponenten entwickelt.

Er ist also grundsätzlich nicht für lange Übertragungswege konzipiert, sondern eher ein Kurzstreckenspezialist. Mit Kurzstrecke meine ich Leitungswege bis zu einigen Metern. Innerhalb eines Gerätes oder gar zwischen Komponenten auf einer Platine müsst ihr im Allgemeinen nicht mit Problemen rechnen. Für längere Strecken kann es jedoch möglich sein, dass Ihr geschirmte Kabel benötigt, die Übertragungsfrequenz reduzieren müsst oder spezielle Leitungstreiber zum Einsatz kommen sollten.

Bitte beachtet, dass der Raspberry Pi an der GPIO mit einer Spannung von 3,3V arbeitet. Unsere Displays tun das auch. Solltet Ihr jedoch noch zusätzliche I2C Komponenten verwenden wollen so solltet Ihr sicherstellen, dass auch diese mit 3,3V und nicht etwa mit 5V am Bus funktionieren. 5V an den GPIO-Anschlüssen des Pi können diesen beschädigen oder gar zerstören. Für die Anbindung von 5V-Logikkomponenten gibt es spezielle Pegelkonverter, die in beide Richtungen die Spannungen zwischen verschiedenen Systemen anpassen.

Alle Geräte, die über die I2C-Schnittstelle miteinander verbunden werden sollen, müssen parellel, über die Anschlüsse Ground, SCL und SDA an den I2C-Bus angeschlossen werden.

Damit verschiedene Geräte an einem Bus miteinander kommunizieren können, muss man sie zunächst einmal identifizieren können. Dafür verfügt jedes Gerät, dass am I2C-Bus angeschlossen wird über eine eindeutige Adresse. Es darf also jede Adresse nur einmal am Bus vorhanden sein.

Diese Adresse besteht aus einem Byte (8Bit) und kann somit theoretisch 256 Zustände annehmen. Die tatsächlich am Bus verfügbaren Adressen sind jedoch auf den Bereich von 0x03-0x77 begrenzt.. I2C-Bus-Komponenten verfügen in der Regel über in der Hardware festgelegte Adressen. Im Fall unserer Displays ist das die Adresse 0x3C. Andere Komponenten benutzen andere Adressen.

Für I2C Geräte (z. B. Sensoren oder I/O-Treiber), von denen eventuell mehrere an einem Bus benötigt werden, besteht oft die Möglichkeit, diese Adresse über Löt- oder Steckbrücken zu ändern. So wird ermöglicht, dass mehrere gleichartige Komponenten unter verschiedenen Adressen angesprochen werden können.

Hinweis: Wenn Ihr also mehrere Displays an einem Raspberry Pi über den I2C-Bus betreiben möchtet, benötigt Ihr entweder mehrere I2C-Busse oder I2C-Displays an denen Ihr die Adresse einstellen könnt.

Nachdem also nun klar ist, dass jedes Gerät am Bus eine Adresse benötigt, muss jetzt noch sichergestellt werden, dass nicht alle Komponenten sinnlos durcheinander kommunizieren. Beim I2C-Bus ist das so geregelt, dass es einen Master am Bus gibt (das ist in diesem Fall unser Raspberry Pi) und mindestens eine Slave-Komponente (das ist hier unser Display).

Alle Slave-Geräte am Bus sitzen generell dumm herum und warten darauf, vom Master angesprochen zu werden.
Erst wenn der Master eine Anforderung an die Adresse eines Slave-Gerätes sendet, antwortet das Slave-Gerät und führt die Anweisung des Master aus und antwortet dem Master oder sendet ggfs. Daten an den Master zurück.

Für I2C-Slave-Geräte, die eventuell auf Ereignisse reagieren müssen, gibt es Ausnahmen, die wir für hier und jetzt jedoch zuerst einmal ignorieren wollen.

Damit genug Theorie zum I2C-Bus und wir wollen versuchen, den ersten Schritt zu gehen, indem wir unseren Raspberry Pi mal losschicken und nachgucken lassen, ob er denn unser Display auch am angeschlossenen I2C-Bus findet. Das machen wir wie folgt:

pi@rechnername ~ : $ i2cdetect -y 1 (enter)

Wenn Euer Display korrekt angeschlossen und der I2C-Bus des Raspberry Pi aktiviert ist, bekommt Ihr jetzt eine Liste aller möglichen I2C-Adressen angezeigt, bei der am Kreuzungspunkt der Zeile "30" und der Spalte "c" der Wert "3c" zu finden ist.

Sollte das der Fall sein, so ist das der Beleg, dass Euer Raspberry Pi über den I2C-Bus mit Eurem OLED-Display kommunizieren kann.

Bekommt Ihr an dem beschriebenen Kreuzungspunkt "--" angezeigt, müsst Ihr die Verkabelung Eures OLED-Displays noch einmal kontrollieren und ggfs. die Verbindung mit einem Messgerät (vorher den Pi abschalten) überprüfen.

Beschwert sich Euer Pi, dass er das Kommando "i2cdetect" nicht kennt, dann führt folgende Befehle aus und versucht es danach noch einmal:

pi@rechnername ~ : $ sudo apt-get update (enter)
pi@rechnername ~ : $ sudo apt-get install -y i2c-tools (enter)


Nun ist also unser Display angeschlossen und der Raspberry Pi kann damit kommunizieren. Um auf dem Display jetzt auch noch Grafik oder Text darzustellen, benötigen wir eine Programmiersprache. Dazu verwenden wir in diesem Tutorial die Interpretersprache Python. Natürlich sind so ziemlich alle Programmiersprachen, die über eine I2C-Anbindung verfügen, auch für die Ansteuerung unseres Displays möglich.

4. I2C OLED Display am Raspberry Pi mit Python ansteuern

Python, wir benutzen die Version3 für unser tutorial, sollte auf unserem Raspberry Pi ja schon vorinstalliert sein. Wenn nicht, dann macht das mal noch schnell wie folgt:

pi@rechnername ~ $ sudo apt-get update (enter)
pi@rechnername ~ $ sudo apt-get install python3-dev libffi-dev libssl-dev python3-pil libjpeg-dev zlib1g-dev libfreetype6-dev liblcms2-dev libopenjp2-7 libtiff5 -y (enter)

pi@rechnername ~ $ sudo apt-get install python3-rpi.gpio python3-pip -y (enter)


Mit der letzten Zeile haben wir gleich noch die GPIO-Erweiterung für Python3 und den Paketmanager PIP für Python 3 mitinstalliert.

Python ist als Programmiersprache, wie unser Raspi-OS als Betriebssystem auch, über diverse zusätzlich zu installierende Pakete unheimlich anpassungsfähig. Mit Hilfe des Paketmanagers PIP3 (PIP für Python 3) ist es uns ganz einfach möglich, zusätziche Softwarepakete, wie zum Beispiel für die Ansteuerung eines OLED-Displays für Python zu installieren. Das Paket, dass uns diese Arbeit enorm erleichtert, heisst luma.oled und wir installieren es wie folgt:

sudo -H pip3 install luma.oled

Damit steht uns dieses Paket auf unserem Raspberry Pi zur Verfügung und wir können beginnen, damit zu programmieren.

5. I2C OLED Display am Raspberry Pi - unser erstes Python Programm

Bis jetzt haben wir nahezu alle Schritte zur Einrichtung und zum Testen unseres Displays an der Konsole durchgeführt. Das könnten wir theoretisch auch so weitermachen. Praktisch ist das jedoch äusserst mühselig. Es ist also sinnvoll, sich eines besseren Werkzeugs zu bedienen. Dazu nutzen wir die grafische Oberfläche, den Desktop unseres Raspberry Pi.

Hier sind auch schon alle notwendigen Werkzeuge für unsere Entwicklerarbeit vorhanden und wir können sie ganz einfach benutzen. Ob Ihr nun einen Bildschirm, Maus und Tastatur an den Pi anschliesst und ihn direkt bedient, oder ob Ihr VNC oder XRDP zur Fernsteuerung des Pi über Euren PC nutzt ist Euch und Euren Vorlieben überlassen.

Wir finden unser Entwicklungswerkzeug für den Umgang mit Python in folgendem Menü:

Himbeerchen => Entwicklung => Thonny Python IDE

Mit dem Klick auf "Thonny Python IDE" starten wir unser Programmierwerkzeug. Nach dem Öffnen des Thonny-Fensters machen wir es erst einmal bildschirmfüllend gross, damit wir auch ordentlich damit arbeiten können.

Jetzt wird es Zeit, unser erstes Python Programm zu schreiben. Dazu klicken wir oben links in der Symbolleiste auf das grüne Plus-Symbol mit der Beschriftung "New".

Damit wir unser neues Programm speichern können, müssen wir zuerst etwas hineinschreiben. Damit, wenn wir versuchen unser Programm auszuführen, der Pi auch weiss, dass es sich um ein Python-Programm handelt, fügen wir in die erste Zeile mal einen Hinweis darauf ein, mit welcher Software, die Datei bei einem Aufruf ausgeführt werden sollte. Das geht so:

#! /usr/bin/python3
# -*- coding: utf-8 -*-

Die erste Zeile sagt dem Rechner, dass das Programm bitte mit dem Python3 Interpreter ausgeführt werden möchte.

Zeile zwei hingegen informiert über die Zeichenkodierung innerhalb der Datei und ermöglicht uns mit der Auswahl "utf-8" die problemlose Verwendung von Umlauten und Sonderzeichen.

Nachdem wir diese beiden Zeilen eingetippt oder eingefügt haben, können wir unser neues Programm speichern und ihm damit einen Namen geben. Das machen wir, indem wir auf das Diskettensymbol mit der Beschriftung "SAVE" klicken. Dann können wir in dem folgenden Dialog einen Ordner auswählen (ich erzeuge dazu im Ordner /home/pi den Unterordner Python) und speichern unser Programm unter dem klangvollen Namen "oled_display.py" ab.

Von jetzt an genügt ein klick auf das Diskettensymbol, um Änderungen an unserem Programm zu speichern.

Als nächstes rüsten wir unser neues Programm mit den Werkzeugen für das Handling von OLED-LED-Displays aus. Dazu ergänzen wir die folgenden Zeilen:

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


Nun können wir schon unser OLED-Display initialisieren. Das erledigt dieser Code:

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


An dieser Stelle müssen wir ein bisschen pokern. Leider weiss man oft gar nicht, welcher OLED-Treiber in unserem Display verbaut ist. Dazu kommt noch das Problem, dass viele Displays zwar als SSD1306 verkauft werden, in China aber einfach ein SH1106 verbaut worden ist. Das ist insofern eine böse Falle, als dass es Treiberpakete für das SSD1306 gibt, die nicht zum SH1106 kompatibel sind. Dann hat man ein Problem.

Wenn der falsche Treiber angesprochen wird, zeigt unser Display, wenn wir es ansteuern möchten, nämlich nur Schnee (ein chaotisches Muster von Pixeln).

Sollte das bei Ihnen der Fall sein, ändern Sie bitte den Eintrag device auf "device = ssd1306(serial)", um aus dem Schnee eine sinnvolle Darstellung zu machen.

Jetzt definieren wir noch eine Schriftart und Schriftgrösse für darzustellenden Text und dann beginnen wir schon damit, ein Rechteck mit den Ausmassen des Displays zu zeichnen und schreiben dort den Text "OLED-Display" hinein.

oled_font = ImageFont.truetype('FreeSans.ttf', 14)
with canvas(device) as draw:
    draw.rectangle(device.bounding_box, outline = "white", fill = "black")
    draw.text((10, 10), "OLED-Display", font = oled_font, fill = "white")


Wer jetzt Schnee sieht, sollte sich an das oben Gelesene erinnern und den device-Eintrag ändern. Allen Anderen gratuliere ich, zum funktionierenden OLED-Display.

Weitere Hinweise zur Verwendung des OLED-Paketes (luma.oled) findet Ihr auf der folgenden Dokumentations-Seite: readthedocs.io.

Das Python-Script aus dem Tutorial, für die Ansteuerung des OLED-Displays, findet Ihr zip-komprimiert hier zum Download: oled_display.zip.

Damit sind wir auch schon am Ende dieses kleinen Tutorials. Ich hoffe, ich konnte Euch ein bisschen inspirieren und wünsche Euch noch viel Spass, beim Entdecken der Möglichkeiten mit OLED-Displays.




Kobeli Pi by SKET-EDV
Kostengünstige papierlose
Lösung zur Erfassung von Kontakt-
und Besucherlisten im Rahmen der
CORONA (COVID19)
Vorsorge-Regeln. [mehr...]