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.
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.
Inhaltsverzeichnis
- Technische Daten des LilyGO T-Dongle S3
- Quellenangaben
- Benötigte Ressourcen
- Programmierung – Erste Schritte mit dem Display
- Einstellen der Ausrichtung des Displays
- Darstellen von Bildern auf dem Display mit ST7735 Modul
Technische Daten des LilyGO T-Dongle S3
Hier die wichtigsten technischen Daten im Überblick:
| Eigenschaft | Details |
|---|---|
| Mikrocontroller | ESP32-S3 (Xtensa LX7, Dual-Core, bis zu 240 MHz) |
| Speicher (Flash) | 16 MB |
| Drahtlose Verbindung | Wi-Fi 802.11 b/g/n, Bluetooth 5 |
| Display | 0,96″ IPS Farbdisplay (ST7735) |
| Auflösung | 80 × 160 Pixel |
| Farben | 65.000 Farben (Full Color) |
| Display-Anschluss | 4-Draht SPI |
| Speicherkartenslot | MicroSD (TF-Karte), ohne Funktion laut Hersteller |
| Programmierumgebungen | Arduino IDE, PlatformIO, MicroPython |
| Anschlüsse | USB-C (für Strom und Datenübertragung), Qwiic |
| Tasten | Boot-Taste (programmiert), Reset-Taste (optional je nach Modell) |
| Betriebsspannung | 3,3 V |
| Formfaktor | USB-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.
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-ST7735sysfont.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.
🎥 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 Displayssysfont.py– für einfache Textdarstellung
Beide Dateien müssen im Hauptverzeichnis des Boards gespeichert werden
(also dort, wo auch deinemain.pyliegt).
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.
# 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.
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.
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.
# --------------------------------------------------------------------
# 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[2], bgr[1], bgr[0]))
f.close()
time.sleep(2)
# --------- Hauptaufruf: Zeige das Bild an ---------
sampleImage(45, 35) # Position: leicht nach rechts unten verschoben
Rotation des Displays