Arduino UNO Q - OLED 128x32
Dieses Tutorial zeigt Ihnen, wie Sie ein SSD1306 OLED 128x32 Display mit Arduino UNO Q verwenden — von grundlegendem Text bis hin zu Formen, Bildern und Telegram-Fernsteuerung.
- Verbindung eines SSD1306 OLED 128x32 zu Arduino UNO Q
- Anzeige von "Hello World" Text in mehreren Größen auf dem OLED
- Anzeige von Text, Ganzzahlen, Dezimalzahlen und Hexadezimalzahlen
- Zeichnung von Formen: Pixel, Linien, Rechtecke, Kreise und Dreiecke
- Verwendung von Hardware-Scrolling (rechts, links, diagonal)
- Anzeige von Bitmap-Bildern auf dem OLED
- Steuerung der Display-Helligkeit und des Kontrasts
- Verwendung von benutzerdefinierten externen Schriftarten
- Fernsteuerung des OLED von Linux aus über Bridge-Programmierung
- Fernsteuerung des OLED von Telegram aus über Bridge-Programmierung
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 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.
Über das OLED 128x32 Display
Das OLED 128x32 ist eine dünnere Version des 128x64 — es hat halb so viele vertikale Pixel, was es ideal für kompakte Gehäuse, Badge-Displays und minimalistische UI-Panels macht. Es verwendet den gleichen SSD1306-Controller und die gleiche Adafruit-Bibliothek.
OLED-Pinbelegung
- GND — mit GND verbinden
- VCC — mit 3,3V oder 5V verbinden
- SCL — I2C-Taktsignal
- SDA — I2C-Datensignal
※ Notiz:
Beziehen Sie sich immer auf die Beschriftungen auf Ihrem OLED-Modul — die Steckereihenfolge kann je nach Hersteller unterschiedlich sein.
Schaltplan
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
| OLED Pin | Arduino UNO Q Pin |
|---|---|
| GND | GND |
| VCC | 3.3V |
| SCL | SCL |
| SDA | SDA |
※ Notiz:
Der einzige Unterschied zwischen dem 128x64 und 128x32 im Code ist SCREEN_HEIGHT 32 statt 64. Die Bibliothek und Verdrahtung sind identisch.
Arduino UNO Q Code — Hello World auf SSD1306 OLED 128x32
Arduino UNO Q hat zwei Prozessoren: den STM32 MCU (verwaltet echtzeitnahe Hardwaresteuerung) und den Qualcomm MPU (läuft Debian Linux). In diesem Abschnitt wird nur der STM32 MCU programmiert — die Linux-Seite bleibt untätig. Ein späterer Abschnitt zeigt, wie beide Prozessoren zusammenarbeiten.
Die Skizze unten zeigt Text in zwei verschiedenen Größen auf dem OLED an.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
Monitor.begin(9600);
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println(F("SSD1306 allocation failed"));
for (;;);
}
delay(2000);
oled.clearDisplay();
// Row 1 — size 1
oled.setTextSize(1);
oled.setTextColor(WHITE);
oled.setCursor(0, 0);
oled.println(F("Hello, World!"));
// Row 2 — size 2
oled.setTextSize(2);
oled.setCursor(0, 14);
oled.println(F("DIYables"));
oled.display();
}
void loop() {}
Schnelle Schritte
- Erstes Mal mit Arduino UNO Q? Folgen Sie dem Tutorial Erste Schritte mit Arduino UNO Q, um Ihre Entwicklungsumgebung vorzubereiten, bevor Sie fortfahren.
- Verdrahten Sie das OLED: Verbinden Sie GND→GND, VCC→3.3V, SCL→SCL, SDA→SDA.
- Verbinden: Stecken Sie Arduino UNO Q mit einem USB-C-Kabel in Ihren Computer ein.
- Öffnen Sie Arduino App Lab: Starten Sie Arduino App Lab und warten Sie, bis es Ihre Arduino UNO Q erkennt.
- Erstellen Sie eine neue App: Klicken Sie auf die Schaltfläche App erstellen.
- Geben Sie der App einen Namen, z. B.: DIYables_OLED_128x32
- Klicken Sie auf Erstellen, um zu bestätigen.
- Sie sehen einen Satz von Ordnern und Dateien, die in Ihrer neuen App generiert werden.
- Finden Sie die Datei sketch/sketch.ino — hier fügen Sie die MCU-Skizze ein.
Fügen Sie die Skizze ein: Kopieren Sie den MCU-Code oben und fügen Sie ihn in die Skizzendatei ein.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Search for Adafruit SSD1306 created by Adafruit and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Upload: Klicken Sie auf die Schaltfläche "Ausführen" im Arduino App Lab, um zu kompilieren und auf den STM32 hochzuladen.
Schauen Sie sich das OLED an — es zeigt "Hello, World!" in der ersten Zeile und "DIYables" in größerem Text in der zweiten Zeile!
Arduino UNO Q Code — Text auf SSD1306 OLED 128x32 anzeigen
Dieses Beispiel demonstriert verschiedene Textgrößen und wie man Ganzzahlen, Dezimalzahlen und Hexadezimalzahlen auf dem OLED anzeigt.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
Monitor.begin(9600);
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println(F("SSD1306 allocation failed"));
for (;;);
}
delay(2000);
// ── Text size demo ──
oled.clearDisplay();
oled.setTextColor(WHITE);
oled.setTextSize(1);
oled.setCursor(0, 0);
oled.println(F("Size 1: Arduino UNO Q"));
oled.setTextSize(2);
oled.setCursor(0, 14);
oled.println(F("Size 2"));
oled.display();
delay(3000);
// ── Integer ──
oled.clearDisplay();
oled.setTextSize(1);
oled.setCursor(0, 0);
oled.print(F("Integer: "));
oled.println(12345);
oled.display();
delay(3000);
// ── Float ──
oled.clearDisplay();
oled.setTextSize(1);
oled.setCursor(0, 0);
oled.print(F("Float: "));
oled.println(3.14);
oled.display();
delay(3000);
// ── Hexadecimal ──
oled.clearDisplay();
oled.setTextSize(1);
oled.setCursor(0, 0);
oled.print(F("Hex: "));
oled.println(255, HEX);
oled.display();
delay(3000);
}
void loop() {}
Schnelle Schritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche "Ausführen" im Arduino App Lab.
Das OLED durchläuft Textgrößen-Demos, zeigt dann eine Ganzzahl, eine Dezimalzahl und eine Hexadezimalzahl an.
Nützliche Display-Funktionen
Schnellreferenz für häufig verwendete SSD1306 OLED-Funktionen:
- oled.clearDisplay() — Frame-Puffer löschen (alle Pixel aus)
- oled.display() — Puffer auf den Bildschirm übertragen — erforderlich nach jedem Zeichnungsbefehl
- oled.drawPixel(x, y, color) — einzelnes Pixel setzen oder löschen
- oled.setTextSize(n) — Schriftart um Faktor *n* skalieren (1 = 6×8 px, 2 = 12×16 px, …)
- oled.setCursor(x, y) — Text-Cursor zu Pixelkoordinaten *(x, y)* verschieben
- oled.setTextColor(WHITE) — nur Textvordergrund (transparenter Hintergrund)
- oled.setTextColor(BLACK, WHITE) — Text mit explizitem Hintergrund
- oled.println("message") — String drucken und zur nächsten Zeile wechseln
- oled.println(number) — Ganzzahl in Dezimal drucken
- oled.println(number, HEX) — Ganzzahl in Hexadezimal drucken
- oled.startscrollright(start, stop) — Hardware-Scroll rechts zwischen Seiten
- oled.startscrollleft(start, stop) — Hardware-Scroll links
- oled.startscrolldiagright(start, stop) — diagonales Scroll rechts
- oled.startscrolldiagleft(start, stop) — diagonales Scroll links
- oled.stopscroll() — jedes aktive Hardware-Scroll beenden
- oled.setContrast(value) — Helligkeit anpassen (0–255)
- oled.dim(true/false) — schneller Dim-Umschalter
- oled.invertDisplay(true/false) — Hardware-seitige Farbinversion
Arduino UNO Q Code — Formen auf SSD1306 OLED 128x32 zeichnen
Die Adafruit SSD1306-Bibliothek erbt von Adafruit_GFX und bietet Pixel, Linien, Rechtecke, Kreise, Dreiecke und abgerundete Rechtecke. Die Skizze unten durchläuft alle — mit Koordinaten angepasst an die 32-Pixel-Höhe.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
Monitor.begin(9600);
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println(F("SSD1306 allocation failed"));
for (;;);
}
delay(2000);
oled.clearDisplay();
oled.display();
}
void loop() {
// ── Dotted horizontal line ──
oled.clearDisplay();
for (int i = 0; i < SCREEN_WIDTH; i += 4)
oled.drawPixel(i, SCREEN_HEIGHT / 2, WHITE);
oled.display();
delay(2000);
// ── Diagonal lines ──
oled.clearDisplay();
oled.drawLine(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1, WHITE);
oled.drawLine(SCREEN_WIDTH - 1, 0, 0, SCREEN_HEIGHT - 1, WHITE);
oled.display();
delay(2000);
// ── Rectangle ──
oled.clearDisplay();
oled.drawRect(4, 4, 120, 24, WHITE);
oled.display();
delay(2000);
// ── Filled rectangle ──
oled.clearDisplay();
oled.fillRect(4, 4, 120, 24, WHITE);
oled.display();
delay(2000);
// ── Rounded rectangle ──
oled.clearDisplay();
oled.drawRoundRect(4, 4, 120, 24, 6, WHITE);
oled.display();
delay(2000);
// ── Filled rounded rectangle ──
oled.clearDisplay();
oled.fillRoundRect(4, 4, 120, 24, 6, WHITE);
oled.display();
delay(2000);
// ── Circle ──
oled.clearDisplay();
oled.drawCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 14, WHITE);
oled.display();
delay(2000);
// ── Filled circle ──
oled.clearDisplay();
oled.fillCircle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 14, WHITE);
oled.display();
delay(2000);
// ── Triangle ──
oled.clearDisplay();
oled.drawTriangle(64, 1, 10, 30, 118, 30, WHITE);
oled.display();
delay(2000);
// ── Filled triangle ──
oled.clearDisplay();
oled.fillTriangle(64, 1, 10, 30, 118, 30, WHITE);
oled.display();
delay(2000);
}
Schnelle Schritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche "Ausführen" im Arduino App Lab.
Beobachten Sie das OLED beim Durchlaufen aller Formen — Pixel, Linien, Rechtecke, Kreise, abgerundete Rechtecke und Dreiecke!
Arduino UNO Q Code — Hardware-Scrolling auf SSD1306 OLED 128x32
Der SSD1306 hat ein eingebautes Hardware-Scrolling-Modul, das Inhalte ohne CPU-Arbeit bewegt. Die Bibliothek bietet vier Scroll-Richtungen: rechts, links, diagonal-rechts und diagonal-links.
※ Notiz:
Rufen Sie immer oled.display() auf, um Ihren Inhalt zum OLED zu übertragen, bevor Sie das Scrollen starten. Rufen Sie stopscroll() auf, bevor Sie neue Inhalte zeichnen. Für das 128x32 Display verwenden Sie den Seitenbereich 0x00, 0x03 statt 0x00, 0x07.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
Monitor.begin(9600);
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println(F("SSD1306 allocation failed"));
for (;;);
}
delay(2000);
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
oled.setCursor(10, 8);
oled.println(F("DIYables"));
oled.display();
}
void loop() {
// Scroll right
oled.startscrollright(0x00, 0x03);
delay(3000);
oled.stopscroll();
delay(500);
// Scroll left
oled.startscrollleft(0x00, 0x03);
delay(3000);
oled.stopscroll();
delay(500);
// Diagonal scroll right
oled.startscrolldiagright(0x00, 0x03);
delay(3000);
oled.stopscroll();
delay(500);
// Diagonal scroll left
oled.startscrolldiagleft(0x00, 0x03);
delay(3000);
oled.stopscroll();
delay(500);
}
Schnelle Schritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche "Ausführen" im Arduino App Lab.
Das OLED scrollt "DIYables" rechts, links, diagonal-rechts und diagonal-links und wiederholt sich endlos.
Arduino UNO Q Code — Bitmap-Bild auf SSD1306 OLED 128x32 anzeigen
Um ein Bitmap auf dem OLED anzuzeigen, müssen Sie Ihr Bild zuerst in ein C-Byte-Array konvertieren. Verwenden Sie das kostenlose Image to Bitmap Converter Tool:
- Laden Sie Ihre Bilddatei hoch (PNG, JPG, BMP, etc.).
- Stellen Sie die Canvas-Größe auf 128×32 (oder kleiner) ein.
- Wählen Sie Arduino code als Ausgabeformat.
- Kopieren Sie das generierte Array in Ihre Skizze.
Die Skizze unten zeigt zuerst ein 16×16 Herzherz-Symbol, dann ein 72×32 DIYables-Symbol — beide als Byte-Arrays im Code gespeichert:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
// 16x16 heart bitmap
const unsigned char heart16x16[] PROGMEM = {
0x00, 0x00, 0x03, 0xc0, 0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfe, 0x3f, 0xfc,
0x1f, 0xf8, 0x0f, 0xf0, 0x03, 0xc0, 0x00, 0x00
};
// 72x32 DIYables icon bitmap
const unsigned char bitmap_DIYables[] PROGMEM = {
0x00, 0x0f, 0xff, 0xff, 0x8f, 0xf8, 0x07, 0x38, 0x07, 0x00, 0x0f, 0xff, 0xff, 0x8f, 0xfe, 0x07,
0x1c, 0x0e, 0x00, 0x0f, 0xff, 0xff, 0x8f, 0xff, 0x07, 0x1c, 0x1c, 0x00, 0x0f, 0xff, 0xff, 0x8e,
0x07, 0x87, 0x0e, 0x1c, 0x00, 0x0f, 0xff, 0xff, 0x8e, 0x03, 0xc7, 0x0f, 0x38, 0x00, 0x0f, 0xff,
0xff, 0x8e, 0x01, 0xc7, 0x07, 0x38, 0x00, 0x0f, 0xff, 0xff, 0x8e, 0x01, 0xc7, 0x03, 0xf0, 0xf0,
0x0f, 0xff, 0xff, 0x8e, 0x01, 0xc7, 0x03, 0xe0, 0xfc, 0x0f, 0xff, 0xff, 0x8e, 0x01, 0xc7, 0x01,
0xe0, 0xfe, 0x0f, 0xff, 0xff, 0x8e, 0x03, 0xc7, 0x01, 0xc0, 0xff, 0x8f, 0xff, 0xff, 0x8e, 0x03,
0x87, 0x01, 0xc0, 0xff, 0x8f, 0xff, 0xff, 0x8e, 0x0f, 0x87, 0x01, 0xc0, 0xff, 0xcf, 0xff, 0xff,
0x8f, 0xff, 0x07, 0x01, 0xc0, 0xff, 0xef, 0xff, 0xff, 0x8f, 0xfc, 0x07, 0x01, 0xc0, 0xff, 0xef,
0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xfc, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x0f, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xfc, 0xfc, 0xff, 0xff, 0xff,
0xef, 0xff, 0xff, 0x0e, 0x0c, 0x0c, 0xc3, 0x07, 0xff, 0xef, 0xff, 0xfe, 0x0f, 0xec, 0xec, 0x99,
0x7f, 0xff, 0xef, 0xff, 0xfe, 0x0f, 0x04, 0xe4, 0x81, 0x0f, 0xff, 0xcf, 0xff, 0xfc, 0x0e, 0x32,
0xe4, 0x9f, 0xc7, 0xff, 0x8f, 0xff, 0xf8, 0x0e, 0x32, 0x4c, 0x9b, 0x67, 0xff, 0x0f, 0xff, 0xf0,
0x0e, 0x04, 0x0c, 0xc3, 0x0f, 0xfe, 0x0f, 0xff, 0xe0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x0f,
0xff, 0x80, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xfc, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff
};
void setup() {
Monitor.begin(9600);
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println(F("SSD1306 allocation failed"));
for (;;);
}
delay(2000);
// Show heart icon centered
oled.clearDisplay();
oled.drawBitmap(
(SCREEN_WIDTH - 16) / 2,
(SCREEN_HEIGHT - 16) / 2,
heart16x16, 16, 16, WHITE);
oled.display();
delay(3000);
// Show DIYables icon centered (72x32 fits exactly in height)
oled.clearDisplay();
oled.drawBitmap(
(SCREEN_WIDTH - 72) / 2,
0,
bitmap_DIYables, 72, 32, WHITE);
oled.display();
}
void loop() {}
Schnelle Schritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche "Ausführen" im Arduino App Lab.
Das OLED zeigt das Herzherz-Symbol für 3 Sekunden, dann wechselt es zum DIYables-Symbol.
※ Notiz:
Bitmap-Abmessungen dürfen die Bildschirmauflösung (128×32) nicht überschreiten. Breite ≤ 128 und Höhe ≤ 32 halten.
Arduino UNO Q Code — Kontrast und Dim auf SSD1306 OLED 128x32
Der SSD1306 unterstützt 256 Kontraststufen (0–255). Verwenden Sie setContrast() für feine Kontrolle und dim() für einen schnellen Helligkeits-Umschalter.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
Monitor.begin(9600);
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println(F("SSD1306 allocation failed"));
for (;;);
}
delay(2000);
// Draw a checkerboard test pattern
oled.clearDisplay();
for (int x = 0; x < SCREEN_WIDTH; x += 8)
for (int y = 0; y < SCREEN_HEIGHT; y += 8)
if ((x / 8 + y / 8) % 2 == 0)
oled.fillRect(x, y, 8, 8, WHITE);
oled.display();
delay(2000);
}
void loop() {
// Ramp up: 0 → 255
for (int c = 0; c <= 255; c += 5) {
oled.setContrast((uint8_t)c);
delay(30);
}
delay(1000);
// Ramp down: 255 → 0
for (int c = 255; c >= 0; c -= 5) {
oled.setContrast((uint8_t)c);
delay(30);
}
delay(1000);
// Quick dim toggle
oled.dim(true); // minimum brightness
delay(2000);
oled.dim(false); // restore
delay(2000);
}
Schnelle Schritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche "Ausführen" im Arduino App Lab.
Beobachten Sie, wie die OLED-Helligkeit rampenförmig rauf und runter geht, gefolgt von einem Dim-an/Dim-aus-Zyklus.
Arduino UNO Q Code — Benutzerdefinierte externe Schriftarten auf SSD1306 OLED 128x32
Die Adafruit GFX-Bibliothek enthält viele FreeFont-Schriftarten. Mit nur 32 Pixel Höhe ermöglichen kleinere Schriftarten (9pt) zwei Zeilen, während größere Schriftarten (12pt) eine einzelne Zeile ausfüllen.
※ Notiz:
Wenn eine externe Schriftart aktiv ist, bezieht sich die Cursor Y-Koordinate auf die Text-Basislinie, nicht auf die obere linke Ecke. Dies unterscheidet sich von der eingebauten 5×7 Schriftart.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Fonts/FreeSerif9pt7b.h>
#include <Fonts/FreeSansBold12pt7b.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
Monitor.begin(9600);
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println(F("SSD1306 allocation failed"));
for (;;);
}
delay(2000);
oled.clearDisplay();
oled.display();
}
void loop() {
// ── Built-in 5×7 font ──
oled.clearDisplay();
oled.setFont(NULL);
oled.setTextSize(1);
oled.setTextColor(WHITE);
oled.setCursor(0, 0);
oled.println(F("Built-in 5x7 font"));
oled.setTextSize(2);
oled.setCursor(0, 14);
oled.println(F("DIYables"));
oled.display();
delay(3000);
// ── FreeSerif 9pt ──
// With 32px height, Y baseline for two rows: ~12 and ~28
oled.clearDisplay();
oled.setFont(&FreeSerif9pt7b);
oled.setTextSize(1);
oled.setTextColor(WHITE);
oled.setCursor(0, 12); // Y = baseline
oled.println(F("FreeSerif 9pt"));
oled.setCursor(0, 28);
oled.println(F("DIYables"));
oled.display();
delay(3000);
// ── FreeSansBold 12pt ──
// With 32px height, only one row fits comfortably
oled.clearDisplay();
oled.setFont(&FreeSansBold12pt7b);
oled.setTextSize(1);
oled.setTextColor(WHITE);
oled.setCursor(0, 22); // Y = baseline (≈18px ascent)
oled.println(F("SansBold 12pt"));
oled.display();
delay(3000);
}
Schnelle Schritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche "Ausführen" im Arduino App Lab.
Das OLED durchläuft die eingebaute Schriftart, FreeSerif 9pt (zwei Zeilen) und FreeSansBold 12pt (einzelne Zeile).
Linux + MCU Bridge-Programmierung
Arduino UNO Q hat zwei Prozessoren, die zusammenarbeiten: die MPU (Qualcomm, läuft Debian Linux) und die MCU (STM32, läuft Zephyr OS mit Ihrer Arduino-Skizze). Sie kommunizieren über RPC über die Arduino_RouterBridge-Bibliothek — niemals über rohe serielle Ports.
- Das OLED ist an den MCU (STM32) angeschlossen — über I2C (SCL/SDA). Nur der MCU kann es direkt ansteuern.
- Die MPU kann das OLED nicht direkt steuern — sie ruft Bridge.call("display_text", "text") auf, was das OLED aktualisiert und das Ergebnis im Monitor ausgibt.
- Die MPU hat Wi-Fi — da die MPU vollständiges Debian Linux mit Wi-Fi ausführt, kann es Telegram-Befehle empfangen und jede Nachricht auf dem OLED ferngesteuert anzeigen.
- Kommunikation: Bridge.call() auf der Linux-Seite ruft Bridge.provide_safe() Funktionen auf der MCU-Seite auf (da OLED-Schreibvorgänge Hardware-API-Aufrufe sind).
- ⚠️ Reserviert: /dev/ttyHS1 (Linux) und Serial1 (MCU) werden vom Arduino Router verwendet — öffnen Sie sie niemals direkt.
MCU-Skizze — OLED 128x32 mit Bridge und Monitor-Ausgabe:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
#include "Arduino_RouterBridge.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
String current_text = "";
void display_text(String text) {
current_text = text;
oled.clearDisplay();
oled.setTextSize(1);
oled.setTextColor(WHITE);
oled.setCursor(0, 0);
oled.println(text);
oled.display();
Monitor.println("OLED: " + text);
}
void clear_oled() {
current_text = "";
oled.clearDisplay();
oled.display();
Monitor.println("OLED cleared");
}
void get_status() {
Monitor.println("Text: " + current_text);
}
void setup() {
Bridge.begin();
Monitor.begin();
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println("OLED init failed");
while (true);
}
delay(1000);
oled.clearDisplay();
oled.setTextSize(1);
oled.setTextColor(WHITE);
oled.setCursor(0, 0);
oled.println("Bridge Ready");
oled.display();
Bridge.provide_safe("display_text", display_text);
Bridge.provide_safe("clear_oled", clear_oled);
Bridge.provide("get_status", get_status);
Monitor.println("OLED 128x32 Bridge ready");
}
void loop() {}
Python-Skript (Arduino App Lab) — Text auf OLED 128x32 von Linux anzeigen:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
from arduino.app_utils import *
import time
def loop():
result = Bridge.call("display_text", "Hello UNO Q\nOLED 128x32")
print(result)
time.sleep(3)
result = Bridge.call("clear_oled")
print(result)
time.sleep(1)
result = Bridge.call("display_text", "DIYables.io")
print(result)
time.sleep(3)
App.run(user_loop=loop)
Schnelle Schritte
- Erstellen Sie eine neue App: Öffnen Sie Arduino App Lab, klicken Sie auf App erstellen, nennen Sie sie DIYables_OLED_128x32_Bridge, und klicken Sie auf Erstellen.
- Fügen Sie die MCU-Skizze ein: Kopieren Sie den Bridge MCU-Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Fügen Sie das Python-Skript ein: Kopieren Sie den Python-Code oben und fügen Sie ihn in die Python-Datei in der App ein.
- Starten Sie die App: Klicken Sie auf die Schaltfläche "Ausführen" — die Python-Seite durchläuft Nachrichten auf dem OLED.
App Lab Console-Ausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
OLED 128x32 Bridge ready
OLED: Hello UNO Q
OLED cleared
OLED: DIYables.io
Telegram-Integration
Zeigen Sie jeden Text auf Ihrem OLED 128x32 ferngesteuert von überall über Telegram an.
Wenn Sie noch keinen Telegram-Bot haben, siehe How to Create a Telegram Bot, um Ihr Bot-Token zu erhalten, bevor Sie fortfahren.
MCU-Skizze: Behalten Sie die gleiche MCU-Skizze aus dem vorherigen Bridge-Abschnitt — keine Änderungen erforderlich. Stellen Sie sicher, dass er bereits auf den STM32 hochgeladen und ausgeführt wird, bevor Sie fortfahren.
Python-Skript (Arduino App Lab) — Telegram-Bot für OLED 128x32:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-oled-128x32
*/
from arduino.app_utils import *
import requests
import time
BOT_TOKEN = "YOUR_BOT_TOKEN"
API_URL = f"https://api.telegram.org/bot{BOT_TOKEN}"
last_update_id = 0
def send_message(chat_id, text):
requests.post(f"{API_URL}/sendMessage", json={"chat_id": chat_id, "text": text})
def get_updates():
global last_update_id
resp = requests.get(f"{API_URL}/getUpdates", params={"offset": last_update_id + 1, "timeout": 5})
return resp.json().get("result", [])
def loop():
global last_update_id
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
msg = update.get("message", {})
chat_id = msg.get("chat", {}).get("id")
text = msg.get("text", "").strip()
if text.startswith("/display "):
content = text[9:]
result = Bridge.call("display_text", content)
print(f"[Telegram] /display: {content}")
send_message(chat_id, result)
elif text == "/clear":
result = Bridge.call("clear_oled")
print(f"[Telegram] /clear")
send_message(chat_id, result)
elif text == "/status":
result = Bridge.call("get_status")
print(f"[Telegram] /status: {result}")
send_message(chat_id, result)
else:
send_message(chat_id, "Commands:\n/display <text> — show text on OLED\n/clear — clear the OLED\n/status — show current OLED content")
App.run(user_loop=loop)
- Anmerkung: Ersetzen Sie YOUR_BOT_TOKEN durch das Token von @BotFather auf Telegram.
- Senden Sie /display Hello — wird auf dem OLED angezeigt.
- Senden Sie /clear — löscht das OLED.
- Senden Sie /status — Bot antwortet mit dem aktuellen OLED-Text.
App Lab Console-Ausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 12:00:01] Telegram: /display Arduino UNO Q
[2026-04-29 12:00:01] OLED: Arduino UNO Q
[2026-04-29 12:05:10] Telegram: /status
[2026-04-29 12:05:10] Text: Arduino UNO Q
[2026-04-29 12:10:20] Telegram: /clear
[2026-04-29 12:10:20] OLED cleared
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
OpenClaw-Integration
Sie können die OpenClaw auf dieses Tutorial anpassen, indem Sie sich auf die Anweisung im Arduino Uno Q - OpenClaw Tutorial beziehen
Anwendungs-/Projektideen
- Tragbares Status-Display: Passen Sie das dünne 128x32 in ein Badge oder Armband, um Live-Sensormesswerte anzuzeigen
- Einzeiliges Warn-Display: Zeige die letzte Telegram-Warnmeldung auf dem OLED ständig an
- Wi-Fi-Netzwerk-Info: Zeige verbundene SSID und IP-Adresse von der Linux-Seite auf dem engen OLED an
- Minimales Dashboard: Verwende die zwei Textzeilen für Temperatur und Luftfeuchtigkeit nebeneinander
- Benachrichtigungsscroller: Scrolle eingehende Telegram-Nachrichten über den 128x32-Bildschirm
Fordere dich selbst heraus
- Einfach: Senden Sie /display ohne Leerzeichen — fügen Sie Fehlerbehandlung hinzu, die "Usage: /display
" antwortet - Mittel: Teilen Sie eine Nachricht in zwei Zeilen mit je 21 Zeichen auf und zeigen Sie beide auf dem 128x32 mit setCursor(0, 0) und setCursor(0, 16) an
- Fortgeschritten: Fügen Sie einen /blink Befehl hinzu, der das OLED 3 Mal blinkt, indem Sie clearDisplay()/display() in einer Schleife auf der MCU-Seite verwenden