MicroPython auf dem LilyGO T-Dongle S3: Display richtig ansteuern – so geht’s
Der LilyGO T-Dongle S3 ist ein kleiner, leistungsfähiger Mikrocontroller im USB-Stick-Format, der vor allem durch Projekte wie den NerdMiner oder LottoMiner bekannt wurde. Kein Wunder – mit seinem schnellen ESP32-S3-Chip, einem integrierten Farbdisplay, SD-Kartenslot und einem kompakten Gehäuse bringt der T-Dongle S3 alles mit, was man für ein autark laufendes Projekt benötigt. https://youtu.be/7IOr_mxJuSU Doch das Board ist längst nicht nur für Mining-Spielereien geeignet. Dank der Unterstützung für MicroPython, Arduino IDE, ESP-IDF oder CircuitPython lässt es sich vielseitig einsetzen – etwa für kleine Automatisierungen, Statusanzeigen oder IoT-Anwendungen, die ganz ohne zusätzliche Hardware auskommen.
In diesem Beitrag zeige ich dir, wie du das integrierte Display mit MicroPython ansprichst. Denn das ist – trotz guter Hardware – nicht ganz so selbsterklärend, wie man vielleicht denkt. Mit den richtigen Tipps und etwas Beispielcode bringst du das Display aber schnell zum Laufen.
Technische Daten des LilyGO T-Dongle S3
Hier die wichtigsten technischen Daten im Überblick: EigenschaftDetailsMikrocontrollerESP32-S3 (Xtensa LX7, Dual-Core, bis zu 240 MHz)Speicher (Flash)16 MBDrahtlose VerbindungWi-Fi 802.11 b/g/n, Bluetooth 5Display0,96" IPS Farbdisplay (ST7735)Auflösung80 × 160 PixelFarben65.000 Farben (Full Color)Display-Anschluss4-Draht SPISpeicherkartenslotMicroSD (TF-Karte), ohne Funktion laut HerstellerProgrammierumgebungenArduino IDE, PlatformIO, MicroPythonAnschlüsseUSB-C (für Strom und Datenübertragung), QwiicTastenBoot-Taste (programmiert), Reset-Taste (optional je nach Modell)Betriebsspannung3,3 VFormfaktorUSB-Stick mit Kunststoffgehäuse Pinbelegung des ST7735-Displays im LilyGO T-Dongle S3 Damit das Display zuverlässig mit MicroPython angesteuert werden kann, müssen die verwendeten GPIOs korrekt im Code angegeben werden. Der LilyGO T-Dongle S3 verwendet eine feste Verdrahtung für SPI und Steuerleitungen. In der folgenden Grafik siehst du die genaue Pinbelegung des integrierten ST7735-Displays.
Pinout ST7735 LC Display - LilyGO T-Dongle S3
Quellenangaben
Die Informationen zur Pinbelegung sowie zur Displayansteuerung stammen aus folgenden Quellen: - Offizielle Produktseite des Herstellers LilyGO: https://lilygo.cc/products/t-dongle-s3 (Enthält technische Details sowie Hinweise zur Pinbelegung des integrierten Displays.) - MicroPython-Modul zur Ansteuerung des ST7735-Displays: GitHub-Repository von boochow: https://github.com/boochow/MicroPython-ST7735 - Ergänzendes Font-Modul (sysfont) für MicroPython: GitHub-Repository von alastairhm: https://github.com/alastairhm/micropython-st7735 Diese Ressourcen sind eine gute Grundlage, um das Display des LilyGO T-Dongle S3 zuverlässig mit MicroPython zu betreiben. In den nächsten Abschnitten zeige ich dir, wie du die Module installierst und erste Inhalte auf dem Display anzeigen kannst.
Benötigte Ressourcen
Für die Programmierung des Displays am LilyGO T-Dongle S3 mit MicroPython benötigst du nur wenige Komponenten und Dateien. Da das Board bereits über einen integrierten USB-Anschluss verfügt, ist kein separates USB-Datenkabel erforderlich. Hardware - ✅ LilyGO T-Dongle S3* (wird direkt über USB mit dem Computer verbunden) Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Software - ✅ Thonny IDE (kostenlose und einsteigerfreundliche Python-Entwicklungsumgebung für MicroPython) MicroPython-Module - ST7735.py (Display-Treiber für das ST7735-Display über SPI) → GitHub: boochow/MicroPython-ST7735 - sysfont.py (Schriftartmodul für einfache Textdarstellung auf dem Display) → GitHub: alastairhm/micropython-st7735 💡 Tipp: Beide Dateien kannst du direkt in Thonny öffnen und auf das Board hochladen. Achte darauf, sie im Hauptverzeichnis des Mikrocontrollers zu speichern, damit sie im Hauptprogramm eingebunden werden können.
Programmierung – Erste Schritte mit dem Display
1. MicroPython auf den LilyGO T-Dongle S3 flashen Bevor du loslegen kannst, musst du zunächst die MicroPython-Firmware auf den Stick flashen. Am einfachsten gelingt das mit der Thonny IDE – ganz ohne zusätzliche Tools oder Kommandozeile.
Thonny - flash Micropython - Step1
Thonny - flash Micropython - Step2
Thonny - flash Micropython - Step3 🎥 Hinweis: In meinem YouTube-Video zeige ich dir diesen Schritt Schritt für Schritt, inklusive Auswahl der richtigen Firmware und Verbindung des Boards. 2. Module auf den Stick kopieren Nach dem Flashen kannst du die beiden benötigten Dateien ganz einfach über Thonny auf das Board laden: - ST7735.py – für die Ansteuerung des Displays - sysfont.py – für einfache Textdarstellung
ST7735 Module auf den LilyGO kopieren - Step1
ST7735 Module auf den LilyGO kopieren - Step2 Beide Dateien müssen im Hauptverzeichnis des Boards gespeichert werden (also dort, wo auch deine main.py liegt). 3. Erster Test: „Hello World!“ auf dem Display Jetzt kommt der spannende Teil: Wir bringen das Display zum Leben! Mit nur wenigen Zeilen Code kannst du einen einfachen Text ausgeben.
LilyGO T-Dongle S3 - ST7735 Display Sample 1 # Titel: Beispielcode – Textausgabe auf dem ST7735-Display (LilyGO T-Dongle S3) # Beschreibung: Dieser Code zeigt, wie man mit MicroPython einen Text auf dem integrierten ST7735-Display ausgibt. # Autor: Stefan Draeger # Blogbeitrag: https://draeger-it.blog/micropython-auf-dem-lilygo-t-dongle-s3-display-richtig-ansteuern-so-gehts/ from ST7735 import TFT # Importiere die Displayklasse für ST7735-Displays from sysfont import sysfont # Einfache Standardschriftart zur Anzeige von Text from machine import SPI, Pin # Zugriff auf SPI-Schnittstelle und GPIO-Pins import time # Für Zeitverzögerungen # Initialisiere die SPI-Schnittstelle (SPI2) mit benutzerdefinierten Pins spi = SPI(2, baudrate=20000000, # Schnelle Übertragungsrate für das Display polarity=0, # SPI-Standardpolarisierung phase=0, # SPI-Standardphase sck=Pin(5), # Clock-Pin (GPIO5) mosi=Pin(3), # Datenleitung (Master Out Slave In, GPIO3) miso=None) # Nicht benötigt, da Display nur geschrieben wird # Initialisiere das TFT-Display mit den Steuerpins: # dc=2 (Data/Command), reset=1, cs=4 (Chip Select) tft = TFT(spi, 2, 1, 4) tft.initr() # Display initialisieren tft.rgb(True) # Farbmodus RGB aktivieren tft.invertcolor(True) # Farben invertieren (je nach Display nötig) tft.rotation(1) # Display-Rotation setzen (0–3) index = 0 # Zähler für dynamische Anzeige while True: tft.fill(TFT.BLACK) # Bildschirm mit schwarzem Hintergrund löschen # Text "Hallo Welt!" an Position (10, 40), in weiß, Schriftgröße 2 tft.text((10, 40), "Hallo Welt!", TFT.WHITE, sysfont, 2) # Zähler anzeigen an Position (10, 60), Schriftgröße leicht größer tft.text((10, 60), str(++index), TFT.WHITE, sysfont, 2.3) time.sleep(5) # 5 Sekunden warten, dann wiederholen Es lässt sich nicht nur Text anzeigen, sondern auch Bilder (24bit Bitmap) und auch einfache geometrische Figuren.
Beispiel Code zum anzeigen von Bilder, Text und einfachen geometrischen FigurenHerunterladen
Einstellen der Ausrichtung des Displays
Die Ausrichtung des Displays kann je nach Anwendungsfall angepasst werden. Dabei stehen vier verschiedene Rotationen (0 bis 3) zur Verfügung – das deckt alle Anzeigerichtungen ab, egal ob Hoch- oder Querformat. Mit einem kurzen Testskript lässt sich schnell herausfinden, welche Rotation für dein Projekt am besten passt.
Beispiel Code zum Ausrichten des Displays ST7735 am LilyGo T-Dongle S3Herunterladen
Darstellen von Bildern auf dem Display mit ST7735 Modul
Mit dem integrierten ST7735-Farbdisplay des LilyGO T-Dongle S3 lassen sich nicht nur Texte und einfache Grafiken darstellen – auch komplette Bilder können geladen und angezeigt werden. In diesem Abschnitt zeige ich dir, wie du ein Bitmap-Bild im 24-Bit-BMP-Format direkt von der internen Dateistruktur des Mikrocontrollers auslesen und auf dem Display anzeigen kannst. Dabei greifen wir direkt auf die Rohdaten der .bmp-Datei zu und übertragen sie zeilenweise per SPI an das Display. Das funktioniert ganz ohne zusätzliche Grafikbibliothek, ist jedoch auf unkomprimierte BMP-Dateien mit 24 Bit Farbtiefe beschränkt. Der folgende Beispielcode basiert auf dem Open-Source-Projekt von boochow/MicroPython-ST7735 und wurde leicht angepasst, um optimal mit dem LilyGO T-Dongle S3 zu funktionieren. Im Beispiel wird ein Logo angezeigt, das farbecht dargestellt wird – inklusive Umwandlung der Farbdaten von BGR zu RGB. So lassen sich z. B. Logos, Icons oder kleine Grafiken problemlos auf dem Display einblenden.
Logo auf dem LCD Display des LilyGo T-Dongle S3 # -------------------------------------------------------------------- # MicroPython: BMP-Bild auf dem LilyGO T-Dongle S3 anzeigen # -------------------------------------------------------------------- # Dieses Skript zeigt, wie du ein 24-Bit-Bitmap-Bild (*.bmp) ohne # externe Bibliotheken auf das integrierte ST7735-Display laden kannst. # Voraussetzung: Das Bild liegt im Dateisystem des Boards. # # Wichtig: # - Nur **24 Bit unkomprimierte** BMP-Dateien werden unterstützt! # - Die Auflösung des Bildes sollte zum Display passen (80x160) # # Mehr Details im Blogbeitrag: # https://draeger-it.blog/micropython-auf-dem-lilygo-t-dongle-s3-display-richtig-ansteuern-so-gehts/ # # Autor: Stefan Draeger # -------------------------------------------------------------------- from ST7735 import TFT, TFTColor # Displaytreiber & Farbcodierer from sysfont import sysfont # Schriftart (nicht verwendet hier) from machine import SPI, Pin # SPI- & GPIO-Funktionen import time # Für Debug-Pausen oder Effekte # --------- Hardware-SPI Initialisierung für ST7735 Display --------- spi = SPI(2, # SPI Bus 2 baudrate=20000000, # 20 MHz, schneller Bildaufbau polarity=0, # SPI-Modus 0 phase=0, sck=Pin(5), # Clock (GPIO5) mosi=Pin(3), # MOSI (GPIO3) miso=None) # MISO nicht benötigt # --------- TFT-Display initialisieren --------- # Parameter: SPI-Objekt, DC, RESET, CS (alles GPIO-Pins) tft = TFT(spi, 2, 1, 4) tft.initr() # Initialisiere das Display tft.rgb(False) # Farbmodus setzen (False = BGR) tft.invertcolor(True) # Farben invertieren (je nach Panel nötig) tft.rotation(1) # Display-Rotation (0–3) # --------- Funktion zum Anzeigen eines BMP-Bildes --------- def sampleImage(x_offset=0, y_offset=0): f = open('logo.bmp', 'rb') # Öffne BMP-Datei im Binärmodus if f.read(2) == b'BM': # BMP-Dateien starten mit 'BM' f.read(8) # Überspringe Dateigröße & Creator offset = int.from_bytes(f.read(4), 'little') # Pixel-Daten-Offset hdrsize = int.from_bytes(f.read(4), 'little') # Headergröße width = int.from_bytes(f.read(4), 'little') # Bildbreite height = int.from_bytes(f.read(4), 'little') # Bildhöhe (negativ = top-down) if int.from_bytes(f.read(2), 'little') == 1: # Plane muss 1 sein depth = int.from_bytes(f.read(2), 'little') # Farbtiefe (bit pro Pixel) compression = int.from_bytes(f.read(4), 'little') # Komprimierung (0 = none) if depth == 24 and compression == 0: # Nur 24-Bit BMP ohne Komprimierung zulassen print("Image size:", width, "x", height) # Berechne Zeilengröße (jede Zeile muss auf 4-Byte-Grenze enden) rowsize = (width * 3 + 3) & ~3 # Prüfe, ob Bild invertiert gelesen werden muss (BMP speichert oft bottom-up) if height < 0: height = -height flip = False else: flip = True w, h = width, height # Definiere Fenstergröße für Display (nur dort wird gezeichnet) tft._setwindowloc((x_offset, y_offset), (x_offset + w - 1, y_offset + h - 1)) # Zeile für Zeile durchgehen for row in range(h): pos = offset + ((height - 1 - row) if flip else row) * rowsize if f.tell() != pos: f.seek(pos) for col in range(w): bgr = f.read(3) # BMP speichert Farben als BGR (Blau, Grün, Rot) # Umwandeln in TFTColor und ans Display senden tft._pushcolor(TFTColor(bgr, bgr, bgr)) f.close() time.sleep(2) # --------- Hauptaufruf: Zeige das Bild an --------- sampleImage(45, 35) # Position: leicht nach rechts unten verschoben Rotation des Displays Read the full article
