{"id":9025,"date":"2026-01-20T14:13:40","date_gmt":"2026-01-20T13:13:40","guid":{"rendered":"https:\/\/de.elv.com\/elvjournal\/?p=9025"},"modified":"2026-03-05T13:59:30","modified_gmt":"2026-03-05T12:59:30","slug":"oled-display-python-raspberry-pi-ssd1306","status":"publish","type":"post","link":"https:\/\/de.elv.com\/elvjournal\/oled-display-python-raspberry-pi-ssd1306\/","title":{"rendered":"Einstieg in Python (Teil 13): OLED \u2013 Displaytechnik mit Python"},"content":{"rendered":"\n

Einstieg in Python, Teil 13<\/strong><\/p>\n\n\n\n

OLED \u2013 Displaytechnik mit Python<\/h1>\n\n\n\n

Mit dem Raspberry Pi lassen sich kleine Displays problemlos ansteuern. Die Kombination aus pr\u00e4ziser Hardwarekontrolle und einer vielseitigen Programmiersprache wie Python erm\u00f6glicht einen strukturierten, praxisnahen Einstieg. Neben den theoretischen Grundlagen werden auch verschiedene praktische Anwendungen vorgestellt.<\/strong><\/p>\n\n\n\n

<\/div>\n\n\n\n

OLED-Display am Raspberry Pi<\/h2>\n\n\n\n

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\u00f6sungen von 128\u00d764 Pixel. In den meisten Anwendungen wird das Bauteil \u00fcber den I\u00b2C-Bus angesteuert, Varianten mit SPI-Anschluss kommen eher seltener zum Einsatz. Im Folgenden soll daher speziell der I\u00b2C-Bus verwendet werden. Aufgrund seines geringen Stromverbrauchs eignet sich das SSD1306 ideal f\u00fcr kleine, energieeffiziente Projekte. Das Display l\u00e4sst sich problemlos in Systeme wie Raspberry Pi, den Pico oder auch andere Mikrocontroller integrieren und erm\u00f6glicht die Darstellung von Text, Grafiken und einfachen Animationen. Bild 1<\/mark><\/mark> zeigt ein typisches SSD1306-OLED-Display.<\/p>\n\n\n\n

\n
\n

Typische Daten des SSD1306:<\/strong><\/p>\n\n\n\n

    \n
  • Gr\u00f6\u00dfe: 0,96-<\/kbd>1,3″<\/li>\n\n\n\n
  • Aufl\u00f6sung: 128\u00d764 Pixel<\/li>\n\n\n\n
  • Schnittstellen: I\u00b2C (SDA\/SCL)<\/li>\n\n\n\n
  • Betriebsspannung: 3,3 V

    <\/li>\n<\/ul>\n<\/div>\n\n\n\n
    \n
    \"\"
    Bild 1: OLED-Display SSD1306<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n

    Der Einsatz des SSD1306-OLED-Displays in Kombination mit Python bietet zahlreiche Vorteile. Durch freie Bibliotheken l\u00e4sst sich das Display sehr einfach ansteuern, sodass Text, Grafiken oder einfache Animationen ohne Low-Level-Programmierung dargestellt werden k\u00f6nnen. Die Integration mit der Python-Bibliothek Pillow<\/strong> erm\u00f6glicht zudem das Erstellen von Bildern, Formen und Schriftz\u00fcgen, wodurch sich z. B. Diagramme, Symbole oder animierte Texte leicht realisieren lassen. Python macht den Einsatz zudem plattformunabh\u00e4ngig: Programme, die auf einem Raspberry Pi funktionieren, lassen sich h\u00e4ufig auch auf MicroPython-kompatiblen Boards ohne gro\u00dfe Anpassungen nutzen. Dadurch eignet sich die Kombination aus SSD1306 und Python besonders gut f\u00fcr interaktive Anwendungen und schnelles Prototyping, etwa in Verbindung mit Sensoren, Tasten oder Drehgebern, wodurch dynamische und anpassbare Anzeigen auf dem Display m\u00f6glich werden. F\u00fcr den Betrieb muss zun\u00e4chst der I\u00b2C-Bus auf den Raspberry Pi aktiviert werden:<\/p>\n\n\n\n

                sudo raspi-config \u2192 Interface Options<\/strong> \u2192 I\u00b2C<\/strong> \u2192 Enable<\/p>\n\n\n\n

    Dann kann das Display mit lediglich vier Leitungen an den Raspberry Pi angeschlossen werden:<\/p>\n\n\n\n

    OLED-Pin<\/strong><\/td>Raspberry-Pi-Pin<\/strong><\/td>Name<\/strong><\/td><\/tr>
    VCC<\/td>3,3 V (Pin 1)<\/td>Stromversorgung<\/td><\/tr>
    GND<\/td>GND (z. B. Pin 6)<\/td>Masse<\/td><\/tr>
    SDA<\/td>SDA (Pin 3)<\/td>I\u00b2C-Daten<\/td><\/tr>
    SCL<\/td>SCL (Pin 5)<\/td>I\u00b2C-Clock<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

    Der gesamte Aufbau ist in Bild 2<\/mark><\/mark> zu sehen.<\/p>\n\n\n\n

    \"\"
    Bild 2: OLED am Raspberry Pi<\/figcaption><\/figure>\n\n\n\n
    <\/div>\n\n\n\n

    Die Luma Library<\/h2>\n\n\n\n

    \u201eLuma.OLED\u201c ist eine leistungsf\u00e4hige Python-Bibliothek zur Ansteuerung von OLED-Displays wie dem SSD1306. Sie baut auf dem Python-Imaging-Library-(Pillow)-Framework auf und erm\u00f6glicht die einfache Darstellung von Texten, Formen, Grafiken und Animationen. Die Bibliothek abstrahiert die Low-Level-Kommunikation \u00fcber I\u00b2C. Man kann damit also direkt mit Grafikbefehlen arbeiten, ohne sich um einzelne Register oder das Bus-Timing k\u00fcmmern zu m\u00fcssen.
    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\u00fcbergreifend und unterst\u00fctzt neben dem Raspberry Pi auch andere Mikrocontroller und Einplatinencomputer, die Python ausf\u00fchren.<\/p>\n\n\n\n

    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\u00fcr schnelles Prototyping als auch f\u00fcr fertige Anwendungen, die eine stabile und flexible Anzeige ben\u00f6tigen. Die Installation der Lib erfolgt \u00fcber:<\/p>\n\n\n\n

                pip3 install luma.oled<\/p>\n\n\n\n

    Nach erfolgreicher Installation kann die Funktion des Displays mit dem folgenden Programm getestet werden (Luma_tst.py):<\/p>\n\n\n\n

    from luma.core.interface.serial import i2c\nfrom luma.oled.device import ssd1306\nfrom PIL import ImageDraw, ImageFont, Image\n\nserial = i2c(port=1, address=0x3C)\ndevice = ssd1306(serial)\n\ndraw = ImageDraw.Draw(device)\ndraw.text((0, 0), \"Hallo Pi!\", fill=255)\ndevice.show()<\/code><\/pre>\n\n\n\n
    Bild 2<\/mark><\/mark> zeigt die Ausgabe auf dem Display. Nat\u00fcrlich lassen sich auch wichtigere Daten als eine Begr\u00fc\u00dfung 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\u00f6glicht sie einen schnellen Zugriff auf wichtige Systeminformationen, ohne dass zus\u00e4tzliche Monitore oder Terminals erforderlich sind. Besonders bei headless-Systemen ohne Bildschirm am HDMI-Port ist es oft m\u00fchsam, 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\u00f6glichkeit zur \u00dcberwachung des Systems. So lassen sich \u00dcberhitzung oder ungew\u00f6hnliche Lastspitzen fr\u00fchzeitig erkennen, was die Zuverl\u00e4ssigkeit und Sicherheit des Ger\u00e4ts erh\u00f6ht. Durch die kompakte, grafische Darstellung auf dem OLED k\u00f6nnen diese Informationen zudem \u00fcbersichtlich und auf einen Blick erfasst werden, ohne die Konsole oder das Netzwerk-Interface bem\u00fchen zu m\u00fcssen. Ein einfaches Programm erm\u00f6glicht die entsprechende Ausgabe (Luma_data.py):<\/p>\n\n\n\n
    import os\nimport time\nimport subprocess\nfrom luma.core.interface.serial import i2c\nfrom luma.oled.device import ssd1306\nfrom luma.core.render import canvas\n\n# --- OLED Initialisieren ---\nserial = i2c(port=1, address=0x3C)\ndevice = ssd1306(serial)\n\ndef get_ip():\n    try:\n        # Sehr zuverl\u00e4ssig, selbst wenn WLAN\/LAN nicht aktiv ist\n        ip = subprocess.check_output(\n            \"hostname -I\", shell=True\n        ).decode().strip().split()[0]\n    except:\n        ip = \"Keine IP\"\n    return ip\n\ndef get_cpu_temp():\n    # Temperatur aus \/sys lesen\n    with open(\"\/sys\/class\/thermal\/thermal_zone0\/temp\", \"r\") as f:\n        temp_raw = f.read().strip()\n    temp_c = float(temp_raw) \/ 1000.0\n    return f\"{temp_c:.1f}\u00b0C\"\n\n# --- Hauptschleife ---\nwhile True:\n    ip = get_ip()\n    temp = get_cpu_temp()\n\n    with canvas(device) as draw:\n        draw.text((0, 0), \"Raspberry Pi\", fill=255)\n        draw.text((0, 16), f\"IP:  {ip}\", fill=255)\n        draw.text((0, 32), f\"CPU: {temp}\", fill=255)\n\n    time.sleep(1)<\/code><\/pre>\n\n\n\n
    Bild<\/mark> 3<\/mark> zeigt, wie die Daten auf dem OLED dargestellt werden.<\/p>\n\n\n\n
    \"\"
    Bild 3: OLED als Datenmonitor<\/figcaption><\/figure>\n\n\n\n
    Wenn man das Display aus gr\u00f6\u00dferer Entfernung ablesen will, kann man auch andere Fonts verwenden. Die Luma Library zeigt sich hier sehr flexibel (Luma_FONTs.py):<\/p>\n\n\n\n
    from luma.core.interface.serial import i2c\nfrom luma.oled.device import ssd1306\nfrom luma.core.render import canvas\nfrom PIL import ImageFont\n\n# --- OLED initialisieren ---\nserial = i2c(port=1, address=0x3C)\ndevice = ssd1306(serial)\n\n# --- Schriften laden ---\nfont_small  = ImageFont.truetype(\"\/usr\/share\/fonts\/truetype\/dejavu\/DejaVuSans.ttf\", 10)\nfont_medium = ImageFont.truetype(\"\/usr\/share\/fonts\/truetype\/dejavu\/DejaVuSans.ttf\", 14)\nfont_large  = ImageFont.truetype(\"\/usr\/share\/fonts\/truetype\/dejavu\/DejaVuSans.ttf\", 20)\n\n# --- Zeichnen ---\nwith canvas(device) as draw:\n    draw.text((0, 0),  \"Kleine Schrift\", font=font_small, fill=255)\n    draw.text((0, 11), \"Mittlere Schrift\", font=font_medium, fill=255)\n    draw.text((0, 26), \"GROSSE\", font=font_large, fill=255)\n    draw.text((0, 45), \"Schrift!\", font=font_large, fill=255)<\/code><\/pre>\n\n\n\n
    Ein wesentlicher Vorteil der Luma Lib liegt in der einfachen Handhabung von Schriftarten und Grafiken<\/strong>. Dank der Integration mit der Python-Bibliothek Pillow<\/strong> lassen sich sowohl Standard- als auch benutzerdefinierte Fonts problemlos verwenden. Texte k\u00f6nnen in verschiedenen Gr\u00f6\u00dfen, Stilen und Positionen dargestellt werden, wodurch sich das Display flexibel f\u00fcr unterschiedliche Anwendungen anpassen l\u00e4sst. Dar\u00fcber hinaus erm\u00f6glicht Luma.OLED das Zeichnen von Linien, Rechtecken, Kreisen, Icons oder komplexen Bildern<\/strong>, die direkt auf dem SSD1306-Display ausgegeben werden k\u00f6nnen. Diese Kombination aus Text- und Grafikfunktionen macht die Bibliothek ideal f\u00fcr interaktive Visualisierungen, Diagramme oder animierte Elemente, ohne dass tiefgreifendes Low-Level-Wissen erforderlich ist. Bild<\/mark> 4<\/mark> zeigt die Verwendung verschiedener Font-Gr\u00f6\u00dfen.<\/p>\n\n\n\n
    \"\"
    Bild 4: Font-Gr\u00f6\u00dfen in allen Variationen<\/figcaption><\/figure>\n\n\n\n
    <\/div>\n\n\n\n
    OLEDs als Minibildschirme: Grafikausgabe<\/h2>\n\n\n\n
    OLED-Displays haben sich als vielseitige Minibildschirme etabliert, die dank ihrer hohen Helligkeit, kontrastreichen Darstellung und geringen Baugr\u00f6\u00dfe in einer Vielzahl von Projekten eingesetzt werden k\u00f6nnen. Insbesondere die M\u00f6glichkeit, Grafiken, Texte und Symbole<\/strong> direkt auf dem Display auszugeben, macht sie zu einem idealen Werkzeug f\u00fcr interaktive Anwendungen, Prototyping und kleine Benutzeroberfl\u00e4chen.<\/p>\n\n\n\n
    Luma.OLED<\/strong> erm\u00f6glicht die einfache Integration solcher Displays in Python-Projekte. Sie bietet die volle Kontrolle \u00fcber Pixel, Formen, Linien und Schriftarten<\/strong>. Durch die Kombination mit Grafikbibliotheken k\u00f6nnen nicht nur statische Inhalte, sondern auch dynamische Visualisierungen, einfache Animationen oder Diagramme auf kleinen OLEDs realisiert werden (Bild<\/mark> 5)<\/mark>.<\/p>\n\n\n\n
    \"\"
    Bild 5: Freundliche Anzeige<\/figcaption><\/figure>\n\n\n\n
    Das folgende Programm zeigt eine einfach Grafikausgabe (Luma_Graphics.py):<\/p>\n\n\n\n
    from luma.core.interface.serial import i2c \nfrom luma.oled.device import ssd1306\nfrom PIL import Image, ImageDraw\n\n# I2C-Verbindung aufbauen\nserial = i2c(port=1, address=0x3C)\ndevice = ssd1306(serial, width=128, height=64)\n\n# Neues Bild erstellen\nimage = Image.new(\"1\", (device.width, device.height))\ndraw = ImageDraw.Draw(image)\n\n# Smiley\ndraw.ellipse((44, 12, 84, 52), outline=255, fill=0)   # Kopf\ndraw.ellipse((54, 22, 60, 28), fill=255)              # linkes Auge\ndraw.ellipse((68, 22, 74, 28), fill=255)              # rechtes Auge\ndraw.arc((54, 34, 74, 44), start=0, end=180, fill=255, width=2)  # Mund\n\n# Bild auf OLED anzeigen\ndevice.display(image)<\/code><\/pre>\n\n\n\n
    <\/div>\n\n\n\n
    Datenaufzeichnung<\/h2>\n\n\n\n
    Die Luma.OLED-Bibliothek eignet sich auch hervorragend f\u00fcr Datenvisualisierung und -aufzeichnung<\/strong> in Echtzeit. Insbesondere in Projekten mit Mikrocontrollern oder Einplatinencomputern wie dem Raspberry Pi kann die Bibliothek genutzt werden, um Messwerte von Sensoren<\/strong>, Systeminformationen<\/strong> oder andere dynamische Daten direkt auf einem kompakten Display anzuzeigen.<\/p>\n\n\n\n
    Durch die Kombination von Luma.OLED mit Python k\u00f6nnen Daten zun\u00e4chst erfasst, verarbeitet und anschlie\u00dfend grafisch oder numerisch<\/strong> aufbereitet werden. Die Integration mit der Pillow-Bibliothek<\/strong> erm\u00f6glicht es, Diagramme, Balkenanzeigen, Verlaufskurven oder kleine Grafiken<\/strong> zu erstellen, die auf dem OLED-Display \u00fcbersichtlich angezeigt werden. Dies ist besonders n\u00fctzlich f\u00fcr Anwendungen wie Temperatur\u00fcberwachung, Netzwerkstatistiken, Logdaten oder andere Messreihen, da die Informationen direkt sichtbar sind, ohne dass ein externer Monitor ben\u00f6tigt wird.<\/p>\n\n\n\n
    Ein weiterer Vorteil der Luma.OLED-Bibliothek ist die M\u00f6glichkeit, laufend aktualisierte Inhalte<\/strong> anzuzeigen. So lassen sich z. B. Sensorwerte in Echtzeit aufzeichnen und grafisch darstellen, was eine schnelle Interpretation und Analyse von Daten direkt am Ger\u00e4t erm\u00f6glicht. Insgesamt eignet sich Luma.OLED damit ideal f\u00fcr kleine, mobile oder energieeffiziente Projekte<\/strong>, bei denen eine visuelle R\u00fcckmeldung von Daten notwendig ist. Das folgende Programm stellt beispielsweise die CPU-Temperatur des Raspberry Pi als durchlaufende Grafik dar. Das hei\u00dft, die Werte werden grafisch auf dem Bildschirm angezeigt, wobei die entstehende Kurve \u2014 \u00e4hnlich wie bei einem EKG im Krankenhaus \u2014 von rechts nach links \u00fcber den Bildschirm l\u00e4uft (Luma_scroll.py).<\/p>\n\n\n\n
    import time\nfrom collections import deque\nfrom luma.core.interface.serial import i2c\nfrom luma.oled.device import ssd1306\nfrom luma.core.render import canvas\n\n# OLED initialisieren\nserial = i2c(port=1, address=0x3C)\ndevice = ssd1306(serial)\n\n# Speicher f\u00fcr die Graph-Werte\nWIDTH = device.width\nHEIGHT = device.height\ndata = deque([0]*WIDTH, maxlen=WIDTH)\n\ndef get_cpu_temp():\n    with open(\"\/sys\/class\/thermal\/thermal_zone0\/temp\") as f:\n        return float(f.read().strip()) \/ 1000.0\n\nwhile True:\n    # Neue Temperatur holen\n    temp = get_cpu_temp()\n    data.append(temp)\n\n    # Werte f\u00fcr Graph normalisieren (0\u201370\u00b0C \u2192 0\u201363px)\n    t_min = 30.0\n    t_max = 70.0\n    def scale(v):\n        v = max(min(v, t_max), t_min)\n        return HEIGHT - int((v - t_min) \/ (t_max - t_min) * (HEIGHT - 1))\n\n    # OLED zeichnen\n    with canvas(device) as draw:\n        draw.text((0, 0), f\"{temp:.1f}\u00b0C\", fill=255)\n        # Graph\n        for x in range(len(data)-1):\n            y1 = scale(data[x])\n            y2 = scale(data[x+1])\n            draw.line((x, y1, x+1, y2), fill=255)\n\n    time.sleep(.1)<\/code><\/pre>\n\n\n\n
    Bild<\/mark> 6<\/mark> zeigt die Ausgabe des Programms.<\/p>\n\n\n\n
    \"\"
    Bild 6: Temperaturverlauf als Rollgrafik<\/figcaption><\/figure>\n\n\n\n
    Abschlie\u00dfend noch ein wichtiger Hinweis: 
    <\/strong>Neben ihren vielen Vorteilen weisen OLED-Displays auch einen Nachteil auf. Im Dauerbetrieb bleichen die Pixel relativ schnell aus. Der Grund daf\u00fcr liegt in der Funktionsweise der OLED-Technologie: Jedes Pixel besteht aus selbstleuchtenden, organischen Materialien, die sich mit der Zeit abnutzen. Je l\u00e4nger 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 \u2014 dadurch entstehen dauerhafte Schatten oder eingebrannte Muster im Display. Man sollte daher statische Vollbilder \u00fcber l\u00e4ngere Zeit vermeiden, um diesen sogenannten \u201eBurn-in\u201c zu verhindern.<\/p>\n\n\n\n
    <\/div>\n\n\n\n
    \n
    Erg\u00e4nzungen, \u00dcbungen und Anregungen<\/strong><\/h2>\n\n\n\n
      \n
    • Wie kann man die Systeminformationen IP-Adresse und CPU-Temperatur mit Speicher- oder Netzwerkauslastungsdaten erg\u00e4nzen?<\/li>\n\n\n\n
    • Kann man auch Sensoranzeigen wie Temperatur, Luftfeuchtigkeit, Lichtintensit\u00e4t oder Bewegungssensoren visualisieren? Wie sehen die Programme dazu aus?<\/li>\n\n\n\n
    • Animationen: Wie kann man Smileys animieren oder f\u00fcr Statusanzeigen nutzen (freundlich, traurig, \u00e4rgerlich, b\u00f6se …)<\/li>\n\n\n\n
    • Erstellen Sie ein kleines Dashboard, das Text, Daten-Balken und kleine Symbole gleichzeitig zeigt.<\/li>\n\n\n\n
    • Wie k\u00f6nnte einen Mini-Wetterstation mit Temperatur, Luftfeuchtigkeit und Luftdruck auf dem Display aussehen?<\/li>\n\n\n\n
    • Kann man auch kleine Spiele oder Animationen programmieren?<\/li>\n<\/ul>\n<\/div>\n\n\n\n
      <\/div>\n\n\n\n
      Zusammenfassung und Ausblick<\/h2>\n\n\n\n
      In diesem Artikel wurde die Programmierung von OLED-Anzeigen mit Python ausf\u00fchrlich dargestellt. Praktische Anwendungen reichten hierbei von einfachen Textausgaben bis hin zu grafischen Darstellungen. Dabei kam bereits der I\u00b2C-Bus als Bindeglied zwischen dem Raspberry\u00a0Pi 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.<\/p>\n\n\n\n
      In den folgenden Beitr\u00e4gen sollen daher verschiedene Busse wie I\u00b2C oder SPI genauer betrachtet werden. Neben den grundlegenden Programmierkonzepten mit Python werden dabei auch wieder praktische Projekte und Einsatzm\u00f6glichkeiten vorgestellt.<\/p>\n\n\n\n
      <\/div>\n\n\n\n
      Material<\/h2>\n\n\n\n
        \n
      • Raspberry Pi mit Netzteil<\/li>\n\n\n\n
      • Breadboard und Jumper-Kabel<\/li>\n\n\n\n
      • OLED-Display
        <\/li>\n<\/ul>\n\n\n\n
        \u00dcber den Autor
        <\/strong>Dr. G\u00fcnter Spanner ist als Autor zu den Themen Elektronik, Sensortechnik und Mikrocontroller einem weiten Fachpublikum bekannt. Schwerpunkt seiner hauptberuflichen T\u00e4tigkeit f\u00fcr verschiedene Gro\u00dfkonzerne wie Siemens und ABB ist die Projektleitung im Bereich Entwicklung und Technologie-Management. Der Dozent fu\u0308r Physik und Elektrotechnik hat zudem zahlreiche Fachartikel und Bu\u0308cher vero\u0308ffentlicht sowie Kurse und Lernpakete erstellt.<\/p>\n\n\n\n
        <\/p>\n","protected":false},"excerpt":{"rendered":"
        Dieser Beitrag bietet einen kompakten \u00dcberblick \u00fcber die Ansteuerung von OLED-Panels mittels Python auf dem Raspberry Pi. Schritt f\u00fcr Schritt wird gezeigt, wie sich erste Ausgaben realisieren und visuelle Informationen effizient darstellen lassen – eine ideale Grundlage f\u00fcr professionelle Anwendungen und weiterf\u00fchrende Projekte.<\/p>\n","protected":false},"author":6,"featured_media":864,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[34],"tags":[1331,1332,1335,1328,1329,1337,1336,1334,1330,1333],"post-author":[137],"class_list":["post-9025","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python-micropython","tag-luma-oled-python","tag-oled-display-ansteuern-python","tag-oled-display-i2c-raspberry-pi","tag-oled-display-python-beispiel","tag-oled-display-raspberry-pi-python","tag-python-oled-grafik","tag-raspberry-pi-oled-anzeige","tag-raspberry-pi-oled-tutorial","tag-ssd1306-oled-raspberry-pi","tag-ssd1306-python","post-author-dr-guenter-spanner"],"acf":[],"info":{"thumbnail":{"url":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/header_phyton_teil11.jpg","alt":""},"teaserImage":{"ID":9827,"id":9827,"title":"liste-beitrag_python_t13_neu","filename":"Liste-Beitrag_python_t13_neu.jpg","filesize":54265,"url":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu.jpg","link":"https:\/\/de.elv.com\/elvjournal\/oled-display-python-raspberry-pi-ssd1306\/liste-beitrag_python_t13_neu\/","alt":"","author":"5","description":"","caption":"","name":"liste-beitrag_python_t13_neu","status":"inherit","uploaded_to":9025,"date":"2026-01-20 13:18:52","modified":"2026-01-20 13:18:52","menu_order":0,"mime_type":"image\/jpeg","type":"image","subtype":"jpeg","icon":"https:\/\/elvjournal.elv.com\/wp-includes\/images\/media\/default.png","width":433,"height":274,"sizes":{"thumbnail":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu-250x250.jpg","thumbnail-width":250,"thumbnail-height":250,"medium":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu-300x190.jpg","medium-width":300,"medium-height":190,"medium_large":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu.jpg","medium_large-width":433,"medium_large-height":274,"large":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu.jpg","large-width":433,"large-height":274,"1536x1536":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu.jpg","1536x1536-width":433,"1536x1536-height":274,"2048x2048":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu.jpg","2048x2048-width":433,"2048x2048-height":274,"gform-image-choice-sm":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu.jpg","gform-image-choice-sm-width":300,"gform-image-choice-sm-height":190,"gform-image-choice-md":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu.jpg","gform-image-choice-md-width":400,"gform-image-choice-md-height":253,"gform-image-choice-lg":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t13_neu.jpg","gform-image-choice-lg-width":433,"gform-image-choice-lg-height":274}},"categories":[{"id":34,"name":"Python & MicroPython","slug":"python-micropython"}],"authors":[{"id":137,"name":"Dr. G\u00fcnter Spanner","slug":"dr-guenter-spanner"}],"document":false,"epaper":"","date":"20. Januar 2026","excerpt":"Dieser Beitrag bietet einen kompakten \u00dcberblick \u00fcber die Ansteuerung von OLED-Panels mittels Python auf dem Raspberry Pi. Schritt f\u00fcr Schritt wird gezeigt, wie sich erste Ausgaben realisieren und visuelle Informationen effizient darstellen lassen - eine ideale Grundlage f\u00fcr professionelle Anwendungen und weiterf\u00fchrende Projekte."},"_links":{"self":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/9025","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/comments?post=9025"}],"version-history":[{"count":10,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/9025\/revisions"}],"predecessor-version":[{"id":11596,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/9025\/revisions\/11596"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/media\/864"}],"wp:attachment":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/media?parent=9025"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/categories?post=9025"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/tags?post=9025"},{"taxonomy":"post-author","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/post-author?post=9025"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}