ESP32 MicroPython - OLED SSD1309
Der ESP32 ist ein leistungsstarker, WLAN-fähiger Mikrocontroller, der in IoT- und Embedded-Projekten weit verbreitet ist. In Kombination mit MicroPython und der DIYables-Bibliothek OLED SSD1309 können Sie Ihrem Projekt ganz einfach ein gestochen scharfes monochromes OLED-Display hinzufügen.
Dieses Tutorial führt Sie durch:
- Den Anschluss des OLED SSD1309 an einen ESP32 — es werden nur 2 Datenpins benötigt (I2C).
- Die Anzeige von Text und Zahlen.
- Das Zeichnen von Formen: Pixel, Linien, Rechtecke und Bitmaps.
- Die Verwendung von Hardware-Scrolling.
- Die Einstellung des Kontrasts und das Dimmen des Displays.
Benötigte Komponenten
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 Starter-Kit (ESP32 enthalten) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Das OLED SSD1309
Der SSD1309 ist ein Single-Chip-CMOS-OLED/PLED-Treiber mit Controller für grafische Punktmatrix-Anzeigesysteme mit organischen bzw. Polymer-Leuchtdioden. Er wird über das I2C-Protokoll (Zweidraht) mit einem Mikrocontroller verbunden, was die Verdrahtung minimal hält — neben der Stromversorgung werden nur die Leitungen SDA und SCL benötigt.
Das Display ist selbstleuchtend (keine Hintergrundbeleuchtung nötig), bietet hohen Kontrast, einen weiten Betrachtungswinkel und ist sowohl in heller als auch in dunkler Umgebung gut lesbar. Es ist üblicherweise in Varianten mit 128×64 und 128×32 Pixeln erhältlich.
Hauptmerkmale:
- I2C-Schnittstelle (Standardadresse 0x3C)
- Auflösung von 128×64 Pixeln (oder 128×32, 96×16, 64×48, 64×32)
- Eingebautes Hardware-Scrolling in horizontaler und diagonaler Richtung
- Einstellbarer Kontrast (0–255)
- Erweitert framebuf.FrameBuffer — alle MicroPython-Zeichenfunktionen funktionieren sofort
Pin-Beschreibung
| Pin | Zweck | ESP32-Anschluss |
|---|---|---|
| SDA | I2C-Datenleitung | Mit GPIO21 verbinden |
| SCL | I2C-Taktleitung | Mit GPIO22 verbinden |
| VCC | Stromeingang 3,3 V bis 5 V | Mit 3.3V verbinden |
| GND | Masse | Mit GND verbinden |
Verdrahtung
Der ESP32 arbeitet mit 3,3-V-Logik, die mit dem SSD1309-Display kompatibel ist.
| OLED SSD1309 | ESP32 | Hinweise |
|---|---|---|
| SDA | GPIO21 | I2C-Daten |
| SCL | GPIO22 | I2C-Takt |
| VCC | 3.3V | Stromversorgung |
| GND | GND | Masse |
- So verbinden Sie den ESP32 mit dem SSD1309 OLED 128x64 Display mithilfe eines Steckbretts
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
- So verbinden Sie den ESP32 mit dem SSD1309 OLED 128x64 Display mithilfe einer Schraubklemmen-Breakout-Platine
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Tipp: Sie können beliebige verfügbare I2C-fähige GPIO-Pins des ESP32 verwenden. Passen Sie einfach die Werte SCL_PIN und SDA_PIN im Code an.
Schnelle Schritte
Hier finden Sie eine Anleitung, wie Sie Ihren MicroPython-Code auf dem ESP32 mit der Thonny IDE einrichten und ausführen:
- Stellen Sie sicher, dass Thonny IDE auf Ihrem Computer installiert ist.
- Vergewissern Sie sich, dass die MicroPython-Firmware auf Ihrem ESP32-Board geladen ist.
- Wenn Sie zum ersten Mal einen ESP32 mit MicroPython verwenden, lesen Sie die Anleitung ESP32 MicroPython Erste Schritte für eine Schritt-für-Schritt-Anleitung.
- Verbinden Sie das ESP32-Board gemäß dem bereitgestellten Schaltplan mit dem OLED SSD1309.
- Verbinden Sie das ESP32-Board mit einem USB-Kabel mit Ihrem Computer.
- Öffnen Sie Thonny IDE auf Ihrem Computer.
- Gehen Sie in Thonny IDE zu Tools Options.
- Wählen Sie im Tab Interpreter aus dem Dropdown-Menü MicroPython (ESP32).
- Stellen Sie sicher, dass der richtige Port ausgewählt ist. Thonny IDE erkennt ihn normalerweise automatisch, aber möglicherweise müssen Sie ihn manuell auswählen (z. B. COM3 unter Windows oder /dev/ttyUSB0 unter Linux).
- Navigieren Sie in Thonny IDE zu Tools Manage packages.
- Suchen Sie nach "DIYables-MicroPython-OLED-SSD1309" und finden Sie dann die von DIYables erstellte OLED-SSD1309-Bibliothek.
- Klicken Sie auf DIYables-MicroPython-OLED-SSD1309 und dann auf den Button Install, um die Bibliothek zu installieren.
- Kopieren Sie den bereitgestellten MicroPython-Code und fügen Sie ihn in den Editor von Thonny ein.
- Speichern Sie den Code auf Ihrem ESP32:
- Klicken Sie auf den Save-Button oder drücken Sie Ctrl+S.
- Wählen Sie im Speicherdialog MicroPython device.
- Nennen Sie die Datei main.py.
- Klicken Sie auf den grünen Run-Button (oder drücken Sie F5), um das Skript auszuführen.
- Beobachten Sie das Ergebnis — Text und Grafiken sollten auf dem OLED-Display erscheinen.
Code-Vorlage für den Einstieg
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
# Pin configuration — change to match your wiring
SCL_PIN = 22 # GPIO22
SDA_PIN = 21 # GPIO21
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# Clear the display, draw something, then push to screen
oled.fill(0)
oled.text("Hello, World!", 0, 0)
oled.show()
ESP32 Code — Hello World
"""
Example: Hello World – basic text on SSD1309 OLED
Works with: ESP32
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
ESP32:
OLED SSD1309 ESP32
──────────── ──────────
SDA -> GPIO21
SCL -> GPIO22
VCC -> 3.3V
GND -> GND
"""
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 22 # GPIO22
SDA_PIN = 21 # GPIO21
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# ── Draw ─────────────────────────────────────────────────────────────────────
oled.fill(0)
# Line 1 – normal 8×8 font
oled.text("Hello, World!", 0, 0)
# Line 3
oled.text("DIYables", 0, 16)
# Line 4
oled.text("SSD1309 OLED", 0, 32)
oled.text("128 x 64", 0, 40)
oled.show()
Ausprobieren
- Verdrahten Sie das OLED SSD1309 gemäß dem obigen Schaltplan mit dem ESP32.
- Laden Sie den Code mit der Thonny IDE hoch.
- Sie sollten "Hello, World!", "DIYables" und "SSD1309 OLED 128 x 64" auf dem Bildschirm sehen.
Referenz zum Zeichnen von Text
| Methodenaufruf | Funktion | Hinweise |
|---|---|---|
| oled.fill(0) | Löscht den gesamten Bildschirm (alle Pixel aus) | Immer vor dem Zeichnen eines neuen Bildes aufrufen |
| oled.text("Hello!", 0, 0) | Zeichnet Text in Spalte 0, Zeile 0 | Eingebaute 8×8-Pixel-Schrift; 16 Zeichen pro Zeile, 8 Zeilen bei 64-px-Display |
| oled.text("Line 2", 0, 16) | Zeichnet Text in der zweiten Zeile | Zeilen sind 8 px hoch; die nächste Zeile ist y+8 oder y+16 für Abstand |
| oled.show() | Überträgt den Framebuffer auf das physische Display | Nichts ist sichtbar, bis show() aufgerufen wird |
ESP32 Code — Formen zeichnen
"""
Example: Draw Shapes – lines, rectangles, and circles on SSD1309 OLED
Works with: ESP32
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
ESP32:
OLED SSD1309 ESP32
──────────── ──────────
SDA -> GPIO21
SCL -> GPIO22
VCC -> 3.3V
GND -> GND
Note:
framebuf.FrameBuffer provides: pixel, fill, fill_rect, rect, line,
hline, vline, text, blit, scroll, and (on newer MicroPython) ellipse & poly.
Circles and triangles require manual drawing or the ellipse/poly helpers.
"""
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
import time
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 22 # GPIO22
SDA_PIN = 21 # GPIO21
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
def demo_pixels():
"""Scatter individual pixels diagonally."""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
for i in range(0, w, 4):
oled.pixel(i, i * h // w, 1)
oled.show()
time.sleep_ms(1500)
def demo_lines():
"""Fan of lines from the top-left corner.
"""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
for i in range(0, w, 8):
oled.line(0, 0, i, h - 1, 1)
for i in range(0, h, 8):
oled.line(0, 0, w - 1, i, 1)
oled.show()
time.sleep_ms(1500)
def demo_h_v_lines():
"""Horizontal and vertical lines."""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
# horizontal lines
for y in range(0, h, 8):
oled.hline(0, y, w, 1)
# vertical lines
for x in range(0, w, 16):
oled.vline(x, 0, h, 1)
oled.show()
time.sleep_ms(1500)
def demo_rectangles():
"""Nested rectangle outlines.
"""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
for i in range(0, h // 2, 4):
oled.rect(i, i, w - 2 * i, h - 2 * i, 1)
oled.show()
time.sleep_ms(1500)
def demo_filled_rects():
"""Alternating filled rectangles."""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
for i in range(0, h // 2, 6):
color = 1 if (i // 6) % 2 == 0 else 0
oled.fill_rect(i, i, w - 2 * i, h - 2 * i, color)
oled.show()
time.sleep_ms(1500)
def demo_ellipse():
"""Ellipses (requires MicroPython 1.20+ for framebuf.ellipse).
"""
oled.fill(0)
cx, cy = SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2
try:
for r in range(4, min(cx, cy), 8):
oled.ellipse(cx, cy, r, r, 1) # circle outline
oled.show()
except AttributeError:
# ellipse not available; fall back to a manual Bresenham circle
_draw_circle(cx, cy, 20, 1)
oled.show()
time.sleep_ms(1500)
def _draw_circle(cx, cy, r, c):
"""Bresenham circle (fallback when framebuf.ellipse is unavailable)."""
x, y, err = r, 0, 1 - r
while x >= y:
for dx, dy in [(x, y), (y, x), (-y, x), (-x, y),
(-x, -y), (-y, -x), (y, -x), (x, -y)]:
oled.pixel(cx + dx, cy + dy, c)
y += 1
if err < 0:
err += 2 * y + 1
else:
x -= 1
err += 2 * (y - x) + 1
# ── Main loop ────────────────────────────────────────────────────────────────
while True:
demo_pixels()
demo_lines()
demo_h_v_lines()
demo_rectangles()
demo_filled_rects()
demo_ellipse()
"""
Ausprobieren
- Laden Sie den Code mit der Thonny IDE hoch.
- Das Display durchläuft mehrere Demos: diagonale Pixel, Linienfächer, Gitterlinien, Rechteckumrisse und gefüllte Rechtecke.
Referenz der Zeichenmethoden
| Methodenaufruf | Was gezeichnet wird | Hinweise |
|---|---|---|
| oled.pixel(x, y, 1) | Einzelnes Pixel bei (x, y) | 0 = aus, 1 = an |
| oled.line(x1, y1, x2, y2, 1) | Linie zwischen zwei Punkten | Bresenham-Algorithmus |
| oled.hline(x, y, w, 1) | Horizontale Linie der Breite w | Schneller als line() für horizontale Linien |
| oled.vline(x, y, h, 1) | Vertikale Linie der Höhe h | Schneller als line() für vertikale Linien |
| oled.rect(x, y, w, h, 1) | Rechteckumriss | Obere linke Ecke bei (x, y) |
| oled.fill_rect(x, y, w, h, 1) | Gefülltes Rechteck | Gleiche Parameter wie rect() |
ESP32 Code — Text scrollen
"""
Example: Scroll Text – hardware scrolling on SSD1309 OLED
Works with: ESP32
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
ESP32:
OLED SSD1309 ESP32
──────────── ──────────
SDA -> GPIO21
SCL -> GPIO22
VCC -> 3.3V
GND -> GND
"""
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
import time
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 22 # GPIO22
SDA_PIN = 21 # GPIO21
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# ── Draw static content ───────────────────────────────────────────────────────
oled.fill(0)
oled.text("DIYables", 20, 28) # centred-ish on 128×64
oled.show()
time.sleep_ms(2000)
# ── Scroll loop ───────────────────────────────────────────────────────────────
while True:
# Scroll right across all pages (0–7)
oled.scroll_right(0x00, 0x07)
time.sleep_ms(3000)
oled.stop_scroll()
time.sleep_ms(500)
# Scroll left
oled.scroll_left(0x00, 0x07)
time.sleep_ms(3000)
oled.stop_scroll()
time.sleep_ms(500)
# Diagonal scroll right
oled.scroll_diag_right(0x00, 0x07)
time.sleep_ms(3000)
oled.stop_scroll()
time.sleep_ms(500)
# Diagonal scroll left
oled.scroll_diag_left(0x00, 0x07)
time.sleep_ms(3000)
oled.stop_scroll()
time.sleep_ms(500)
Ausprobieren
- Laden Sie den Code mit der Thonny IDE hoch.
- Das Display scrollt nach rechts, dann nach links, dann diagonal nach rechts, dann diagonal nach links und wiederholt dies.
Referenz zum Hardware-Scrolling
| Methodenaufruf | Scrollrichtung | Hinweise |
|---|---|---|
| oled.scroll_right(0x00, 0x07) | Rechts | Pages 0–7 = alle Zeilen bei einem 64-px-Display |
| oled.scroll_left(0x00, 0x07) | Links | Pages 0–7 decken die volle Bildschirmhöhe ab |
| oled.scroll_diag_right(0x00, 0x07) | Diagonal rechts (rechts + unten) | Kombiniert horizontales und vertikales Scrollen |
| oled.scroll_diag_left(0x00, 0x07) | Diagonal links (links + unten) | Kombiniert horizontales und vertikales Scrollen |
| oled.stop_scroll() | Scrollen stoppen | Vor dem Zeichnen neuer Inhalte aufrufen |
Hinweis: Ändern Sie den Framebuffer (z. B. durch Aufruf von oled.fill() + oled.show()), bevor Sie ein neues Scrollen starten, um den scrollenden Inhalt zu aktualisieren. Rufen Sie immer stop_scroll() auf, bevor Sie neue Zeichenbefehle senden.
ESP32 Code — Kontrast & Dimmen
"""
Example: Contrast & Dim – contrast control on SSD1309 OLED
Works with: ESP32
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
ESP32:
OLED SSD1309 ESP32
──────────── ──────────
SDA -> GPIO21
SCL -> GPIO22
VCC -> 3.3V
GND -> GND
"""
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
import time
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 22 # GPIO22
SDA_PIN = 21 # GPIO21
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# ── Draw a test pattern ───────────────────────────────────────────────────────
oled.fill(0)
oled.fill_rect(0, 0, 64, 32, 1) # top-left filled block
oled.fill_rect(64, 32, 64, 32, 1) # bottom-right filled block
oled.text("Contrast Demo", 8, 28) # label over the blocks
oled.show()
time.sleep_ms(2000)
# ── Contrast / dim loop ───────────────────────────────────────────────────────
while True:
# Gradually increase contrast 0 → 255
for c in range(0, 256, 5):
oled.set_contrast(c)
time.sleep_ms(30)
time.sleep_ms(1000)
# Gradually decrease contrast 255 → 0
for c in range(255, -1, -5):
oled.set_contrast(c)
time.sleep_ms(30)
time.sleep_ms(1000)
# Dim on / off toggle
oled.dim(True)
time.sleep_ms(2000)
oled.dim(False)
time.sleep_ms(2000)
Ausprobieren
- Laden Sie den Code mit der Thonny IDE hoch.
- Beobachten Sie, wie die Helligkeit des Displays auf- und abschwillt und dann zwischen gedimmter und voller Helligkeit wechselt.
Referenz zu Kontrast & Dimmen
| Methodenaufruf | Wirkung | Hinweise |
|---|---|---|
| oled.set_contrast(0) | Minimale Helligkeit | Wertebereich 0–255 |
| oled.set_contrast(128) | Mittlere Helligkeit | Der Wert wird intern für dim/restore gespeichert |
| oled.set_contrast(255) | Maximale Helligkeit | Standardwert nach der Initialisierung ist 0xCF (207) |
| oled.dim(True) | Senkt den Kontrast auf 0 (gedimmt) | Ändert den gespeicherten Kontrastwert nicht |
| oled.dim(False) | Stellt den gespeicherten Kontrast wieder her | Stellt den mit set_contrast() gesetzten Wert wieder her |
| oled.invert(True) | Invertiert alle Pixel auf Hardwareebene | Keine Änderung am Framebuffer |
| oled.invert(False) | Stellt die normale Pixelpolarität wieder her | — |
ESP32 Code — Bitmap
"""
Example: Bitmap – display a monochrome bitmap image on SSD1309 OLED
Works with: ESP32
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
ESP32:
OLED SSD1309 ESP32
──────────── ──────────
SDA -> GPIO21
SCL -> GPIO22
VCC -> 3.3V
GND -> GND
How bitmap drawing works:
framebuf.FrameBuffer.blit() copies one FrameBuffer onto another.
Bitmap data must be stored row-by-row, MSB first → use framebuf.MONO_HMSB.
The blit() call then handles the conversion into the display's MONO_VLSB
layout automatically.
"""
import framebuf
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
import time
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 22 # GPIO22
SDA_PIN = 21 # GPIO21
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Bitmap data – 16 × 16 heart, stored row-by-row MSB first ─────────────────
# Each row uses 2 bytes (ceil(16 / 8) = 2).
HEART_W = 16
HEART_H = 16
heart_data = bytearray([
0x00, 0x00, # ................
0x0C, 0x30, # ....##....##....
0x1E, 0x78, # ...####..####...
0x3F, 0xFC, # ..############..
0x7F, 0xFE, # .##############.
0x7F, 0xFE, # .##############.
0xFF, 0xFF, # ################
0xFF, 0xFF, # ################
0xFF, 0xFF, # ################
0x7F, 0xFE, # .##############.
0x3F, 0xFC, # ..############..
0x1F, 0xF8, # ...##########...
0x0F, 0xF0, # ....########....
0x07, 0xE0, # .....######.....
0x03, 0xC0, # ......####......
0x01, 0x80, # .......##.......
])
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# Wrap the raw bytes in a FrameBuffer using MONO_HMSB (row-major, MSB first)
heart_fb = framebuf.FrameBuffer(heart_data, HEART_W, HEART_H, framebuf.MONO_HMSB)
# ── Draw and animate ──────────────────────────────────────────────────────────
while True:
# Draw the heart centred on the display
x = (SCREEN_WIDTH - HEART_W) // 2
y = (SCREEN_HEIGHT - HEART_H) // 2
oled.fill(0)
oled.blit(heart_fb, x, y)
oled.text("DIYables", 24, 50)
oled.show()
time.sleep_ms(800)
# Invert colours for a "pulse" effect
oled.fill(1)
oled.blit(heart_fb, x, y, 1) # key=1 → blit only pixels that are OFF in source
oled.show()
time.sleep_ms(400)
Ausprobieren
- Laden Sie den Code mit der Thonny IDE hoch.
- Ein 16×16-Herzsymbol erscheint zentriert auf dem Display. Es pulsiert durch abwechselnd normale und invertierte Bilder.
Referenz zum Zeichnen von Bitmaps
| Methodenaufruf | Beschreibung | Hinweise |
|---|---|---|
| framebuf.FrameBuffer(data, w, h, framebuf.MONO_HMSB) | Verpackt Rohbytes als Bitmap-FrameBuffer | MONO_HMSB für zeilenweise Daten mit MSB zuerst verwenden |
| oled.blit(icon_fb, x, y) | Kopiert die Bitmap bei (x, y) in den Display-Framebuffer | Alle Pixel werden kopiert (keine Transparenz) |
| oled.blit(icon_fb, x, y, 1) | Blit mit key=1 — Pixel mit dem Wert 1 werden übersprungen | Nützlich für XOR-artige Effekte auf gefüllten Hintergründen |
So werden Bitmap-Daten gespeichert: Jede Zeile wird von links nach rechts gespeichert, das höchstwertige Bit zuerst (MONO_HMSB). Die Anzahl der Bytes pro Zeile ist ceil(width / 8). Bei einem 16 Pixel breiten Bild sind das 2 Bytes pro Zeile.
Bibliotheksreferenz
Unter DIYables MicroPython OLED SSD1309 Library Reference finden Sie die vollständige API-Dokumentation mit allen Konstruktoren, Methoden und Konstanten.
Nächste Schritte
- Kombinieren Sie es mit einem DHT11- oder DHT22-Sensor, um Temperatur und Luftfeuchtigkeit in Echtzeit anzuzeigen.
- Fügen Sie einen Taster hinzu, um zwischen mehreren Bildschirmansichten zu wechseln.
- Verwenden Sie framebuf.FrameBuffer.blit(), um eine animierte Sprite-Anzeige zu erstellen.