Arduino UNO Q - OLED 128x32
Ce tutoriel vous montre comment utiliser un écran OLED SSD1306 128x32 avec Arduino UNO Q — du texte de base aux formes, images et contrôle à distance via Telegram.
- Comment connecter un OLED SSD1306 128x32 à Arduino UNO Q
- Comment afficher le texte "Hello World" en plusieurs tailles sur l'OLED
- Comment afficher du texte, des entiers, des flottants et des nombres hexadécimaux
- Comment dessiner des formes : pixels, lignes, rectangles, cercles et triangles
- Comment utiliser le défilement matériel (droite, gauche, diagonal)
- Comment afficher des images bitmap sur l'OLED
- Comment contrôler la luminosité et le contraste de l'afficheur
- Comment utiliser des polices externes personnalisées
- Comment contrôler l'OLED à distance depuis Linux via la programmation Bridge
- Comment contrôler l'OLED à distance depuis Telegram via la programmation Bridge
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À Propos de l'Écran OLED 128x32
L'OLED 128x32 est une version plus fine du 128x64 — il a deux fois moins de pixels verticaux, ce qui le rend idéal pour les boîtiers compacts, les affichages de badges et les panneaux d'interface minimaux. Il utilise le même contrôleur SSD1306 et la même bibliothèque Adafruit.
Brochage de l'OLED
- GND — connecter à GND
- VCC — connecter à 3,3V ou 5V
- SCL — signal d'horloge I2C
- SDA — signal de données I2C
※ Note:
Référez-vous toujours aux étiquettes imprimées sur votre module OLED — l'ordre des broches peut différer selon les fabricants.
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
| Broche OLED | Broche Arduino UNO Q |
|---|---|
| GND | GND |
| VCC | 3.3V |
| SCL | SCL |
| SDA | SDA |
※ Note:
La seule différence entre le 128x64 et le 128x32 dans le code est SCREEN_HEIGHT 32 au lieu de 64. La bibliothèque et le câblage sont identiques.
Code Arduino UNO Q — Hello World sur OLED SSD1306 128x32
L'Arduino UNO Q dispose de deux processeurs : le STM32 MCU (gère le contrôle matériel en temps réel) et le Qualcomm MPU (exécute Debian Linux). Dans cette section, seul le STM32 MCU est programmé — le côté Linux reste inactif. Une section ultérieure montrera comment les deux processeurs fonctionnent ensemble.
Le sketch ci-dessous affiche du texte en deux tailles différentes sur l'OLED.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Première utilisation d'Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q pour préparer votre environnement de développement avant de continuer.
- Câblez l'OLED : Connectez GND→GND, VCC→3,3V, SCL→SCL, SDA→SDA.
- Connectez : Branchez l'Arduino UNO Q à votre ordinateur avec un câble USB-C.
- Ouvrez Arduino App Lab : Lancez Arduino App Lab et attendez qu'il détecte votre Arduino UNO Q.
- Créez une nouvelle App : Cliquez sur le bouton Create New App.
- Donnez un nom à l'App, par exemple : DIYables_OLED_128x32
- Cliquez sur Create pour confirmer.
- Vous verrez un ensemble de dossiers et de fichiers générés dans votre nouvelle App.
- Trouvez le fichier sketch/sketch.ino — c'est là que vous collerez le sketch MCU.
Collez le sketch : Copiez le code MCU ci-dessus et collez-le dans le fichier sketch.
- 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
- Téléversez : Cliquez sur le bouton Run dans Arduino App Lab pour compiler et téléverser vers le STM32.
Regardez l'OLED — il affiche "Hello, World!" sur la première ligne et "DIYables" en plus grand texte sur la deuxième ligne !
Code Arduino UNO Q — Afficher du Texte sur OLED SSD1306 128x32
Cet exemple illustre différentes tailles de texte et comment afficher des entiers, des flottants et des nombres hexadécimaux sur l'OLED.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
L'OLED alterne entre les démonstrations de taille de texte, puis affiche un entier, un flottant et un nombre hexadécimal.
Référence des Fonctions d'Affichage Utiles
Référence rapide des fonctions SSD1306 OLED les plus utilisées :
- oled.clearDisplay() — efface le tampon de trame (tous les pixels éteints)
- oled.display() — envoie le tampon à l'écran — requis après chaque appel de dessin
- oled.drawPixel(x, y, color) — définit ou efface un seul pixel
- oled.setTextSize(n) — met à l'échelle la police par le facteur *n* (1 = 6×8 px, 2 = 12×16 px, …)
- oled.setCursor(x, y) — déplace le curseur de texte aux coordonnées en pixels *(x, y)*
- oled.setTextColor(WHITE) — premier plan de texte uniquement (fond transparent)
- oled.setTextColor(BLACK, WHITE) — texte avec fond explicite
- oled.println("message") — imprime une chaîne et passe à la ligne suivante
- oled.println(number) — imprime un entier en décimal
- oled.println(number, HEX) — imprime un entier en hexadécimal
- oled.startscrollright(start, stop) — défilement matériel vers la droite entre les pages
- oled.startscrollleft(start, stop) — défilement matériel vers la gauche
- oled.startscrolldiagright(start, stop) — défilement diagonal vers la droite
- oled.startscrolldiagleft(start, stop) — défilement diagonal vers la gauche
- oled.stopscroll() — arrête tout défilement matériel actif
- oled.setContrast(value) — ajuste la luminosité (0 à 255)
- oled.dim(true/false) — bascule rapide de l'atténuation
- oled.invertDisplay(true/false) — inversion des couleurs au niveau matériel
Code Arduino UNO Q — Dessiner des Formes sur OLED SSD1306 128x32
La bibliothèque Adafruit SSD1306 hérite d'Adafruit_GFX, vous donnant des pixels, des lignes, des rectangles, des cercles, des triangles et des rectangles arrondis. Le sketch ci-dessous les parcourt tous — avec des coordonnées ajustées pour s'adapter à la hauteur de 32 pixels.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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);
}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
Regardez l'OLED alterner entre toutes les formes — pixels, lignes, rectangles, cercles, rectangles arrondis et triangles !
Code Arduino UNO Q — Défilement Matériel sur OLED SSD1306 128x32
Le SSD1306 dispose d'un moteur de défilement matériel intégré qui déplace le contenu sans aucun travail du CPU. La bibliothèque offre quatre directions de défilement : droite, gauche, diagonal-droite et diagonal-gauche.
※ Note:
Appelez toujours oled.display() pour transférer votre contenu vers l'OLED avant de démarrer un défilement. Appelez stopscroll() avant de dessiner un nouveau contenu. Pour l'afficheur 128x32, utilisez la plage de pages 0x00, 0x03 au lieu de 0x00, 0x07.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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);
}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
L'OLED fait défiler "DIYables" vers la droite, la gauche, diagonal-droite et diagonal-gauche, en se répétant indéfiniment.
Code Arduino UNO Q — Afficher une Image Bitmap sur OLED SSD1306 128x32
Pour afficher un bitmap sur l'OLED, vous devez d'abord convertir votre image en un tableau d'octets C. Utilisez l'outil gratuit Image to Bitmap Converter :
- Téléchargez votre fichier image (PNG, JPG, BMP, etc.).
- Définissez la taille du canevas à 128×32 (ou plus petit).
- Sélectionnez Arduino code comme format de sortie.
- Copiez le tableau généré dans votre sketch.
Le sketch ci-dessous affiche une icône cœur 16×16 puis passe à une icône DIYables 72×32 — toutes deux stockées sous forme de tableaux d'octets dans le code :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
L'OLED affiche l'icône cœur pendant 3 secondes, puis passe à l'icône DIYables.
※ Note:
Les dimensions du bitmap ne doivent pas dépasser la résolution de l'écran (128×32). Gardez la largeur ≤ 128 et la hauteur ≤ 32.
Code Arduino UNO Q — Contraste et Atténuation sur OLED SSD1306 128x32
Le SSD1306 supporte 256 niveaux de contraste (0 à 255). Utilisez setContrast() pour un contrôle précis et dim() pour une bascule rapide de la luminosité.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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);
}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
Regardez la luminosité de l'OLED augmenter puis diminuer, suivie d'un cycle d'atténuation activée/désactivée.
Code Arduino UNO Q — Polices Externes Personnalisées sur OLED SSD1306 128x32
La bibliothèque Adafruit GFX inclut de nombreuses polices FreeFont. Avec seulement 32 pixels de hauteur, les polices plus petites (9pt) permettent deux lignes tandis que les polices plus grandes (12pt) remplissent une seule rangée.
※ Note:
Lorsqu'une police externe est active, la coordonnée Y du curseur fait référence à la ligne de base du texte, et non au coin supérieur gauche. Cela diffère de la police intégrée 5×7.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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);
}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
L'OLED alterne entre la police intégrée, FreeSerif 9pt (deux lignes) et FreeSansBold 12pt (une seule rangée).
Programmation Bridge Linux + MCU
L'Arduino UNO Q dispose de deux processeurs qui fonctionnent ensemble : le MPU (Qualcomm, exécute Debian Linux) et le MCU (STM32, exécute Zephyr OS avec votre sketch Arduino). Ils communiquent via RPC grâce à la bibliothèque Arduino_RouterBridge — jamais via des ports série bruts.
- L'OLED est connecté au MCU (STM32) — via I2C (SCL/SDA). Seul le MCU peut le piloter directement.
- Le MPU ne peut pas contrôler l'OLED directement — il appelle Bridge.call("display_text", "text") qui met à jour l'OLED et imprime le résultat dans le Monitor.
- Le MPU dispose du Wi-Fi — parce que le MPU exécute Debian Linux complet avec Wi-Fi, il peut recevoir des commandes Telegram et afficher n'importe quel message sur l'OLED à distance.
- Communication : Bridge.call() côté Linux invoque des fonctions Bridge.provide_safe() côté MCU (puisque les écritures OLED sont des appels API matériels).
- ⚠️ Réservé : /dev/ttyHS1 (Linux) et Serial1 (MCU) sont utilisés par l'Arduino Router — ne les ouvrez jamais directement.
Sketch MCU — OLED 128x32 avec Bridge et sortie Monitor :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Script Python (Arduino App Lab) — afficher du texte sur OLED 128x32 depuis Linux :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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)
Étapes Rapides
- Créez une nouvelle App : Ouvrez Arduino App Lab, cliquez sur Create New App, nommez-la DIYables_OLED_128x32_Bridge, et cliquez sur Create.
- Collez le sketch MCU : Copiez le code Bridge MCU ci-dessus et collez-le dans sketch/sketch.ino.
- Collez le script Python : Copiez le code Python ci-dessus et collez-le dans le fichier Python de l'App.
- Exécutez l'App : Cliquez sur le bouton Run — le côté Python alterne entre les messages sur l'OLED.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
OLED 128x32 Bridge ready
OLED: Hello UNO Q
OLED cleared
OLED: DIYables.io
Intégration Telegram
Affichez n'importe quel texte sur votre OLED 128x32 à distance depuis n'importe où via Telegram.
Si vous n'avez pas encore de bot Telegram, consultez Arduino UNO Q - Bot Telegram pour obtenir votre token de bot avant de continuer.
Sketch MCU : Conservez le même sketch MCU de la section Bridge précédente — aucune modification nécessaire. Assurez-vous qu'il est déjà téléversé et en cours d'exécution sur le STM32 avant de continuer.
Script Python (Arduino App Lab) — bot Telegram pour OLED 128x32 :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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)
- Remarque : Remplacez YOUR_BOT_TOKEN par le token obtenu depuis @BotFather sur Telegram.
- Envoyez /display Hello — apparaît sur l'OLED.
- Envoyez /clear — efface l'OLED.
- Envoyez /status — le bot répond avec le texte actuel de l'OLED.
Sortie de la Console App Lab
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
Intégration d'OpenClaw
Vous pouvez adapter OpenClaw à ce tutoriel en vous référant aux instructions du tutoriel Arduino UNO Q - OpenClaw.
Idées d'Applications/Projets
- Affichage de statut portable : Intégrez le fin 128x32 dans un badge ou un bracelet pour afficher des mesures de capteurs en temps réel
- Affichage d'alerte sur une seule ligne : Affichez en permanence le dernier message d'alerte Telegram sur l'OLED
- Infos réseau Wi-Fi : Affichez le SSID connecté et l'adresse IP depuis le côté Linux sur l'OLED compact
- Tableau de bord minimal : Utilisez les deux lignes de texte pour la température et l'humidité côte à côte
- Bandeau de notifications : Faites défiler les messages Telegram entrants sur l'écran 128x32
Défiez-vous
- Facile : Envoyez /display sans espace — ajoutez une gestion d'erreur qui répond "Utilisation : /display
" - Moyen : Divisez un message en deux lignes de 21 caractères chacune et affichez les deux sur le 128x32 en utilisant setCursor(0, 0) et setCursor(0, 16)
- Avancé : Ajoutez une commande /blink qui fait clignoter l'OLED 3 fois en utilisant clearDisplay()/display() dans une boucle côté MCU