Adafruit-GFX-Anleitung für ESP32 und Arduino

Dieses Adafruit-GFX-Tutorial bringt ein Display-Projekt für ESP32 oder Arduino von einer leeren Lopaka-Zeichenfläche bis zur funktionierenden Hardware. Lopaka erzeugt den Zeichencode und die Bitmap-Assets; du wählst die hardwarespezifische Displaybibliothek aus, verdrahtest das Display und initialisierst es.

Was ist die Adafruit-GFX-Bibliothek?

Adafruit GFX ist die gemeinsame Grafikschicht, die viele Displaybibliotheken für Arduino-kompatible Boards nutzen, auch für ESP32. Sie bietet Zeichenmethoden für Pixel, Linien, Formen, Text und Bitmaps.

Adafruit GFX steuert allein kein Display an. Die Bibliothek arbeitet mit einer hardwarespezifischen Bibliothek zusammen, etwa Adafruit_SSD1306, Adafruit_ST7789 oder einem anderen Treiber für genau den Controller in deinem Modul. Der Treiber kümmert sich um Bus, Initialisierung und Übertragung zum Display; GFX liefert die gemeinsame Zeichen-API. Beispiele für diese Aufteilung findest du in der Bibliotheksübersicht von Adafruit.

Bevor du anfängst

Du brauchst:

• Einen Mikrocontroller und ein Display mit einem Adafruit-GFX-kompatiblen Treiber.
• Controller-Name, Auflösung, Schnittstelle und Pinbelegung deines Moduls.
• Ein Arduino- oder ESP32-Projekt mit dem Arduino-Framework, das den Beispiel-Sketch des Treibers kompilieren und hochladen kann.
• Genug Flash für Schriftarten und Bitmap-Assets sowie genug RAM für einen eventuellen Framebuffer des Treibers.

Achtung

Lopaka erkennt deinen Controller nicht und erzeugt weder Verdrahtung noch Treiberkonfiguration. Displays mit derselben Auflösung können unterschiedliche Bibliotheken, Konstruktoren, Adressen, Pins, Initialisierungsaufrufe oder Display-Offsets brauchen.

Schritt 0: Display-Treiber installieren und testen

Öffne in der Arduino IDE Tools → Manage Libraries und suche nach dem Treiber deines Displays, etwa Adafruit SSD1306 oder Adafruit ST7735 and ST7789 Library. Aktuelle Versionen der Arduino IDE installieren deklarierte Abhängigkeiten wie Adafruit GFX und Adafruit BusIO zusammen mit dem Treiber. Wenn du Bibliotheken manuell installierst, folge den Anweisungen im Adafruit-GFX-Repository und im Repository deines Display-Treibers.

Für Ellipsen-Ebenen installierst du Adafruit GFX 1.12.2 oder neuer. Die API von 1.12.2 enthält drawEllipse() und fillEllipse(), 1.12.1 nicht.

Installiere für ESP32 den Arduino-Core für ESP32 und wähle dein Board aus. ESP32-Sketches nutzen dieselbe setup()- und loop()-Struktur wie in dieser Anleitung.

Bevor du Lopaka-Code hinzufügst, kompiliere ein offizielles Beispiel für genau dein Display und lade es hoch. Zum Beispiel:

• Beispiel für SSD1306-OLED 128×64 mit I2C
• Grafikbeispiel für ST7789-TFT

Läuft das Beispiel des Herstellers, stimmen Bibliothek, Konstruktor, Verdrahtung, Adresse, Bus und Initialisierung. Behalte dieses Beispiel als Basis-Sketch und ersetze nur seine Demo-Zeichenaufrufe durch die Ausgabe von Lopaka.

Schritt 1: Lopaka-Plattform wählen

Lopaka hat zwei Ziele für Adafruit GFX:

Lopaka-Plattform	Geeignet für	Erzeugtes Objekt	Farb- und Bildausgabe
AdafruitGFX Color	Treiber für Farb-TFT, OLED oder Matrizen	tft	RGB565-Farben; 1-Bit-Bilder mit drawBitmap() oder RGB565-Bilder mit drawRGBBitmap()
AdafruitGFX Mono	Treiber für 1-Bit-OLED oder -LCD	display	Farben 0 und 1; 1-Bit-Bilder mit drawBitmap()

Wähle das Ziel passend zum Treiber, nicht nur nach dem Aussehen des Designs. Ein monochromes Ziel erzeugt keine RGB- oder Graustufenpixel. Das Farbziel packt Farben in die 16-Bit-RGB565-Werte, die Adafruit GFX verwendet; siehe das Koordinaten- und Farbmodell von Adafruit.

Der Name des erzeugten Objekts ist Teil der Integrationsvereinbarung. Am einfachsten nennst du deine Treiberinstanz tft für die Farbausgabe oder display für die monochrome Ausgabe. Andernfalls benennst du diesen Bezeichner im generierten Block um.

Schritt 2: Lopaka-Projekt anlegen

1. Öffne lopaka.app und lege ein Projekt an.
2. Wähle AdafruitGFX Color oder AdafruitGFX Mono.
3. Stelle Screen-Größe auf die logische Breite und Höhe ein, die dein Sketch nutzt.
4. Wähle bei einem Farbprojekt die Hintergrundfarbe des Screens. Bei einem monochromen Projekt gestaltest du mit der festen Schwarz-Weiß-Palette.

Koordinaten in Adafruit GFX beginnen bei (0, 0) oben links, X wächst nach rechts und Y nach unten. Lopaka nutzt dieselbe Ausrichtung.

Ruft der Sketch setRotation() auf, richte die Lopaka-Zeichenfläche nach den gedrehten logischen Abmessungen aus, die width() und height() liefern. Lopaka erzeugt kein setRotation() und dreht die Hardware nicht für dich. Adafruit beschreibt die vier Ausrichtungen unter Rotating the Display.

Schritt 3: Screen gestalten

Platziere Ebenen über die Werkzeugleiste, ordne sie im Bereich Ebenen und bearbeite ihre Werte im Inspektor. Benenne wichtige Ebenen vor dem Export um: Aus den Namen werden Kommentare, Bitmap-Bezeichner, Namen von Polygon-Hilfsfunktionen, Animations-Header und optionale Variablennamen.

Die aktuellen Adafruit-GFX-Generatoren erzeugen Folgendes:

Lopaka-Ebene	Adafruit-GFX-Ausgabe
Linie	drawLine()
Rechteck	drawRect() / fillRect()
Abgerundetes Rechteck	drawRoundRect() / fillRoundRect()
Kreis	drawCircle() / fillCircle()
Ellipse	drawEllipse() / fillEllipse()
Dreieck	drawTriangle() / fillTriangle()
Polygon	Eine Hilfsfunktion aus geschlossenen drawLine()-Aufrufen; nur Umriss
Text	setTextColor(), setTextSize(), setFont(), setCursor(), print()
Malebene, Icon, Bild	drawBitmap() oder, beim Farbziel, drawRGBBitmap()
Animation	1-Bit-Frame-Daten plus Hilfsfunktionen zur Frame-Auswahl und zum Zeichnen

Nutze für ovale Formen auf beiden Adafruit-Zielen das Werkzeug Ellipse. Setze den horizontalen und vertikalen Radius gleich, um einen Kreis zu zeichnen; importierte Kreisebenen erzeugen weiterhin drawCircle() oder fillCircle().

Textverhalten

Die Standardschrift von Adafruit ist die integrierte 5×7-Schrift mit fester Zeichenbreite. Andere GFX-Schriftarten nutzen eine Grundlinie: Die Y-Koordinate des Cursors ist die Linie, auf der die Glyphen stehen, nicht die Oberkante der sichtbaren Buchstaben. Lopaka passt die generierte Y-Koordinate an die gewählte Schriftart an, prüfe die Ausrichtung aber trotzdem auf dem echten Display.

Das Farbziel bietet eine Hintergrundfarbe für Text und erzeugt die Form setTextColor(foreground, background) mit zwei Argumenten. Adafruit GFX ignoriert dieses Hintergrundargument bei eigenen GFX-Schriftarten; es funktioniert nur mit der klassischen integrierten Schrift. Um Text in einer eigenen Schriftart zu überschreiben, lösche seinen alten Bereich mit einem gefüllten Rechteck, bevor du ihn neu zeichnest. Das monochrome Lopaka-Ziel bietet keine Texthintergründe. Siehe die Hinweise von Adafruit zu Schriftverhalten und Grundlinie.

Schritt 4: Generierten Code konfigurieren

Öffne die Code-Einstellungen. Die Adafruit-GFX-Ziele haben zwei C++-Vorlagen und diese Optionen:

Syntax wählt das Ziel-Framework. Arduino (C++) ist voreingestellt. ESP-IDF (C++) erzeugt dieselben Zeichenaufrufe für eine ESP-IDF-Komponente: Bild-, Masken- und Animations-Arrays sind einfache static const uint8_t / uint16_t-Arrays ohne PROGMEM, das Animations-Timing nutzt esp_timer_get_time() aus esp_timer.h, und es werden kein setup() / loop() erzeugt – rufe draw{ScreenName}() und drawAnimations() aus deiner eigenen Task-Schleife auf. Heruntergeladene Bild- und Animations-Header folgen der gewählten Vorlage.

Einstellung	Was sie ändert
Wrapper-Funktion	Packt den aktiven Screen in void draw{ScreenName}(void)
Schriftarten einbinden	Fügt Includes lokaler Header für GFX-Schriftarten außer der Standardschrift hinzu
Bilder deklarieren	Erzeugt 1-Bit- oder RGB565-Bitmap-Arrays für Bildebenen
Bilddateien einbinden	Erzeugt #include "<symbol>.h" statt der Inline-Bitmap-Arrays
Animations-Hilfsfunktionen	Fügt Includes für Animations-Header, Timing-Hilfsfunktionen und ein Start-Setup/-Loop hinzu
Variablen deklarieren	Erzeugt Deklarationen für unterstützte Ebeneneigenschaften, die als Variablen markiert sind
Kommentare, Ebenentitel	Fügt der statischen Zeichenausgabe Kommentare mit den Ebenennamen hinzu
Display leeren/füllen	Leert die monochrome Ausgabe bzw. füllt die Farbausgabe am Anfang des Zeichenblocks

Lass Wrapper-Funktion, Schriftarten einbinden, Bilder deklarieren und Display leeren/füllen für das erste Rendering aktiviert.

Die Wrapper-Funktion für Farbe beginnt mit tft.fillScreen(...). Die monochrome Wrapper-Funktion beginnt mit display.clearDisplay() und endet mit display.display(), damit ein gepuffertes Display wie das SSD1306 aktualisiert wird. Manche andere monochrome Treiber nutzen eine andere Aktualisierungsmethode; passe den letzten Aufruf an das offizielle Beispiel deines Treibers an.

Schritt 5: Schriftarten, Bilder und Animationen hinzufügen

Schriftarten

Die integrierte Adafruit-5×7-Schrift braucht keinen Header. Lopaka bietet außerdem GFX-Schriftarten an und akzeptiert importierte Schriftart-Header im GFX-Format. Unterstützte BDF- und Vektorschriftarten kann Lopaka beim Import ins GFX-Format umwandeln; die verfügbaren Importwege beschreibt der Schriftarten-Leitfaden von Lopaka.

Für jede Schriftart außer der Standardschrift, die der Screen nutzt:

1. Öffne Code-Einstellungen → Schriftarten und lade die .h-Datei herunter.
2. Lege die Datei neben deinen Sketch oder den generierten Quellcode.
3. Lass Schriftarten einbinden aktiviert, damit das generierte #include "FontName.h" erhalten bleibt.

Schriftdaten belegen Programmspeicher, und größere Schriftarten belegen mehr. Der Schriftarten-Leitfaden von Adafruit erklärt die mitgelieferte Free-Familie und das GFX-Schriftformat.

Bilder

Importiere ein Bild mit dem Werkzeug Bild und schneide es auf seine endgültige Pixelgröße zu. Die Ausgabe hängt vom gewählten Lopaka-Ziel und vom Farbmodus des Bildes ab:

• Monochrom: ein 1-Bit-PROGMEM-Array, das mit einer gewählten Vordergrundfarbe gezeichnet wird. Nicht gesetzte Pixel sind im generierten drawBitmap()-Aufruf transparent.
• RGB bei AdafruitGFX Color: ein RGB565-Array uint16_t PROGMEM, gezeichnet mit drawRGBBitmap(). Ein importiertes Bild füllt seine transparenten Pixel mit dem Screen-Hintergrund, auf der Zeichenfläche wie auf dem Gerät. Damit sie durchsichtig bleiben, aktiviere im Inspektor Transparenz neben Overlay (die Option erscheint, wenn das Bild transparente Pixel hat): Lopaka erzeugt dann zusätzlich ein 1-Bit-Array image_<Name>_mask und nutzt die maskierte Überladung von drawRGBBitmap(), sodass diese Pixel das behalten, was der Screen bereits zeigt. Die Maske kostet ein Bit Flash pro Pixel, und der maskierte Aufruf zeichnet Pixel für Pixel, was langsamer ist.

Lass Bilder deklarieren aktiviert, damit die Arrays im kopierten Code enthalten sind. RGB565 braucht zwei Byte pro Pixel, noch vor dem Overhead von Compiler und Speicherung, große bildschirmfüllende Bilder können also viel Flash belegen. Der Leitfaden zum Bildimport von Lopaka behandelt Skalieren, Zuschneiden, Resampling, Dithering und Größenschätzungen. Adafruit dokumentiert die zugrunde liegenden Bitmap-Aufrufe unter Graphics Primitives.

Code-Einstellungen → Bilder listet außerdem jedes Bild mit seiner Asset-Datei auf – image_<Name>_bits.h für 1-Bit-Daten, image_<Name>_pixels.h für RGB565 –, mit genau denselben Bytes wie das Inline-Array. Aktiviere Bilddateien einbinden, um statt des Arrays #include "image_<Name>_bits.h" zu erzeugen und die Pixel im heruntergeladenen Header zu behalten.

Animationen

Beide Adafruit-Ziele in Lopaka unterstützen Frame-Animationen. Die exportierten Frames sind 1-Bit-Bitmaps, auch beim Farbziel; die gewählte Ebenenfarbe wird beim Zeichnen jedes Frames angewendet. Das ist keine Vollfarb-Videowiedergabe.

Lade jede unter Code-Einstellungen → Animationen aufgeführte .h-Datei herunter und lege sie zum Sketch. Die Hilfsfunktion wählt ein Frame mit millis() bei der Syntax Arduino (C++) und mit esp_timer_get_time() bei der Syntax ESP-IDF (C++).

Achtung

Mit der Syntax Arduino (C++) fügt der Animationsexport die Standard-Einstiegspunkte setup() und loop() von Arduino hinzu, die mit dem Arduino-Core auch auf dem ESP32 funktionieren. Der Display-Code im generierten setup() ist nur ein Startpunkt: Adafruit-Treiber nutzen unterschiedliche Initialisierungsaufrufe. Übernimm die Animations-Includes, die Update-Hilfsfunktion und die Zeichen-Hilfsfunktionen in das funktionierende Herstellerbeispiel, behalte Konstruktor und Initialisierung dieses Treibers und behalte nur ein setup() und ein loop().

Den Ablauf im Editor und die Exportoptionen beschreibt Animationen.

Schritt 6: Code kopieren und einbinden

Lege einen Screen namens Main an, füge eine Textebene und ein ungefülltes Rechteck hinzu und klicke im Code-Bereich auf Kopieren. Deine Ausgabe enthält deine eigenen Ebenen, Farben, Schriftarten und Koordinaten.

Farbbeispiel mit ST7789-TFT

Für AdafruitGFX Color sieht eine typische Lopaka-Funktion so aus:

void drawMain(void) {
    tft.fillScreen(0x0);
    // Greeting
    tft.setTextColor(0xFFFF);
    tft.setCursor(8, 12);
    tft.print("Hello!");
    // Border
    tft.drawRect(0, 0, 240, 240, 0xFFFF);
}

Der folgende minimale Sketch folgt dem offiziellen Adafruit-Beispiel für das ST7789 mit 240×240 Pixeln. Ersetze die Pin-Definitionen und die Argumente von init() durch die aus dem funktionierenden Beispiel für dein Modul.

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>

#define TFT_CS 10
#define TFT_DC 8
#define TFT_RST 9

Adafruit_ST7789 tft(TFT_CS, TFT_DC, TFT_RST);

// Paste the complete Lopaka-generated block here.
void drawMain(void) {
    tft.fillScreen(0x0);
    // Greeting
    tft.setTextColor(0xFFFF);
    tft.setCursor(8, 12);
    tft.print("Hello!");
    // Border
    tft.drawRect(0, 0, 240, 240, 0xFFFF);
}

void setup(void) {
    tft.init(240, 240);
    tft.setRotation(0);
    drawMain();
}

void loop(void) {}

Treiber für Farb-TFTs zeichnen meist direkt auf das Display, deshalb braucht dieses Beispiel keinen separaten Aufruf zum Anzeigen oder Übertragen. Falls dein Treiber die Ausgabe puffert, halte dich an das hardwarespezifische Beispiel.

Monochrom-Beispiel mit SSD1306-OLED

Bei AdafruitGFX Mono enthält die Wrapper-Funktion die Aufrufe zum Leeren und Aktualisieren:

void drawMain(void) {
    display.clearDisplay();
    // Greeting
    display.setTextColor(1);
    display.setCursor(8, 12);
    display.print("Hello!");
    // Border
    display.drawRect(0, 0, 128, 64, 1);
    display.display();
}

Dieser minimale Sketch folgt dem offiziellen Adafruit-Beispiel für das SSD1306 mit 128×64 Pixeln und I2C. Ersetze Reset-Pin und I2C-Adresse durch die Werte deines Moduls.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3D

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Paste the complete Lopaka-generated block here.
void drawMain(void) {
    display.clearDisplay();
    // Greeting
    display.setTextColor(1);
    display.setCursor(8, 12);
    display.print("Hello!");
    // Border
    display.drawRect(0, 0, 128, 64, 1);
    display.display();
}

void setup(void) {
    if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
        for (;;) {}
    }
    drawMain();
}

void loop(void) {}

Schritt 7: Laufzeitdaten und weitere Screens hinzufügen

Um eine unterstützte Eigenschaft dynamisch zu machen, aktiviere ihren Variablenschalter im Inspektor und lass Variablen deklarieren aktiviert. Lopaka ersetzt das Literal durch eine Deklaration auf Basis des Ebenennamens. Aktualisiere diesen Wert in deiner Anwendung, bevor du die Zeichenfunktion erneut aufrufst.

Jeder Lopaka-Screen wird separat exportiert, und sein Titel wird zum Namen der Wrapper-Funktion. Kopiere die Funktion jedes Screens in den Sketch, führe doppelte Includes und Assets zusammen und lass dann deine Anwendung entscheiden, welche Funktion aufgerufen wird:

enum Screen { MAIN, DETAILS };
Screen currentScreen = MAIN;

void drawCurrentScreen(void) {
    if (currentScreen == MAIN) {
        drawMain();
    } else {
        drawDetails();
    }
}

Was Lopaka übernimmt und was du übernimmst

Lopaka übernimmt	Du übernimmst
Pixel-Layout, Ebenenreihenfolge und unterstützte GFX-Aufrufe	Genauer Display-Treiber, Konstruktor, Pins, Bus und Spannung
RGB565-Farben für das Farbziel	Treiberspezifische Farbreihenfolge, Offsets und Initialisierung
1-Bit- und RGB565-Bitmap-Deklarationen	Flash-/RAM-Budget und jegliches Laden aus einem Dateisystem oder von einer SD-Karte
Auswahl der GFX-Schriftarten und lokale Header zum Download	Bibliotheken installieren und Header beim Quellcode behalten
Optionale Variablen und 1-Bit-Animations-Hilfsfunktionen	Aktualisierungs-Timing, Eingaben, Navigation und Anwendungszustand
Eine benannte Zeichenfunktion pro exportiertem Screen	Diese Funktion aufrufen und gepufferte Ausgabe korrekt anzeigen

Kompilieren, hochladen und iterieren

1. Kompiliere vor dem Hochladen. Behebe zuerst fehlende Header, nicht definierte Objekte und Fehler bei treiberspezifischen Methoden.
2. Lade hoch und vergleiche das physische Display mit der Lopaka-Zeichenfläche.
3. Passe Treibervariante, Adresse, Drehung, Größe der Zeichenfläche oder Ebenenpositionen nach Bedarf an.
4. Wenn sich das Design ändert, ersetze den kompletten generierten Block, statt einzelne Zeichenaufrufe von Hand zu pflegen.

Halte Hardware- und Anwendungscode außerhalb des generierten Abschnitts:

// BEGIN LOPAKA GENERATED CODE
// Replace this entire block after exporting again.
// END LOPAKA GENERATED CODE

Fehlerbehebung

Das Display bleibt leer

• Stelle das offizielle Beispiel des Treibers wieder her und lade es hoch. Bleibt auch das leer, prüfe Stromversorgung, Spannung, Masse, Verdrahtung, Controller, Adresse, Reset und Bus-Pins.
• Stelle sicher, dass die Initialisierungsmethode des Treibers erfolgreich ist, bevor du die Lopaka-Funktion aufrufst.
• Stelle sicher, dass der Name des erzeugten Objekts zu deiner Instanz passt: tft für Farbe oder display für Mono.
• Rufe bei einem gepufferten Treiber wie dem SSD1306 nach dem Zeichnen seine Aktualisierungsmethode auf. Die Mono-Vorlage von Lopaka erzeugt display.display(); ein anderer Treiber braucht womöglich eine andere Methode.

Das Bild ist verschoben, abgeschnitten, gespiegelt oder gedreht

Richte die Lopaka-Zeichenfläche nach den logischen Abmessungen nach setRotation() aus. Nutze genau die Treibervariante für das Panel: Der Controller-RAM kann größer sein als die sichtbare Fläche, und manche Module brauchen treiberspezifische Offsets.

Die Farben sind falsch

Das Farbziel erzeugt RGB565-Werte. Stelle sicher, dass die hardwarespezifische Bibliothek die üblichen 16-Bit-Farbwerte von Adafruit GFX erwartet und dass ihre Initialisierung die richtige Panel-Variante wählt. Sind Rot und Blau vertauscht, untersuche die Farbreihenfolge oder die Panel-Konfiguration des Treibers, statt jede Farbe in Lopaka zu ändern.

Eine eigene Schriftart lässt sich nicht kompilieren oder richtig ausrichten

• Lade ihre .h-Datei unter Code-Einstellungen → Schriftarten herunter und lege sie neben den Sketch.
• Lass Schriftarten einbinden aktiviert und prüfe, ob Dateiname, eingebundener Name und GFX-Symbol übereinstimmen.
• Denk daran, dass eigene GFX-Schriftarten eine Grundlinie nutzen und das Hintergrundargument von setTextColor() ignorieren.
• Nutze weniger oder kleinere Schriftarten, wenn das Programm den Flash-Speicher übersteigt.

Ein Bild lässt sich nicht kompilieren oder belegt zu viel Flash

Lass Bilder deklarieren aktiviert, wenn der generierte Zeichenaufruf auf eine Inline-Bitmap verweist. Schneide das Quellbild zu und skaliere es auf seine endgültigen Abmessungen. Stelle ein einfaches Icon von RGB auf Monochrom um, wenn eine Vordergrundfarbe genügt.

Animationscode kollidiert mit meinem Sketch

Behalte ein setup() und ein loop(). Behalte die Treiberinitialisierung aus dem offiziellen Hardwarebeispiel und führe dann den generierten Animations-Header, die Update-Funktion und die Zeichenfunktionen ein. Lopaka-Animationen nutzen 1-Bit-Frames; RGB-Video-Frames bleiben nicht erhalten.

FAQ

Unterstützt Lopaka jedes Adafruit-Display?

Lopaka zielt auf die gemeinsame Zeichen-API von Adafruit GFX, nicht auf eine Liste von Displaymodulen. Ein Display passt in der Praxis, wenn es einen Adafruit-GFX-kompatiblen Treiber für deine Arduino- oder ESP32-Umgebung gibt und dieser Treiber die Methoden unterstützt, die für dein Design erzeugt werden. Prüfe das genaue Modul mit dem offiziellen Beispiel seines Treibers.

Installiert oder konfiguriert Lopaka Adafruit GFX?

Nein. Installiere den hardwarespezifischen Treiber und seine Abhängigkeiten, lege das Display-Objekt an und initialisiere es in deinem Sketch. Lopaka liefert Zeichenaufrufe und Assets.

Kann das Farbziel Vollfarbbilder exportieren?

Ja. RGB-Bildebenen erzeugen RGB565-Arrays und drawRGBBitmap()-Aufrufe, beim Farbziel mit einer optionalen 1-Bit-Maske für transparente Pixel (das Kontrollkästchen Transparenz). Monochrome Bildebenen und alle Animations-Frames bleiben bei einem Bit pro Pixel. Den Export von Graustufen-Bitmaps unterstützen die Adafruit-Vorlagen von Lopaka nicht.

Wo erfahre ich mehr?

• Adafruit-GFX-Leitfaden
• Adafruit-GFX-Repository
• Grafikprimitive
• Schriftarten verwenden
• Display drehen
• Schriftarten-Leitfaden von Lopaka
• Leitfaden zum Bildimport in Lopaka
• Animations-Leitfaden von Lopaka
• Leitfaden zur Code-Generierung in Lopaka