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
