Raspberry Pi Pico MicroPython - OLED SSD1309
Le Raspberry Pi Pico est une carte microcontrôleur performante et économique construite sur la puce RP2040. Associé à MicroPython et à la bibliothèque DIYables OLED SSD1309, vous pouvez facilement ajouter un écran OLED monochrome net à votre projet.
Ce tutoriel vous guide à travers :
- La connexion de l'OLED SSD1309 à un Raspberry Pi Pico — seulement 2 broches de données nécessaires (I2C).
- L'affichage de texte et de nombres.
- Le dessin de formes : pixels, lignes, rectangles et bitmaps.
- L'utilisation du défilement matériel.
- Le réglage du contraste et l'atténuation de l'affichage.
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.
L'Écran OLED SSD1309
Le SSD1309 est un pilote OLED/PLED CMOS monopuce avec contrôleur pour systèmes d'affichage graphique à matrice de points en diode électroluminescente organique/polymère. Il se connecte à un microcontrôleur via le protocole I2C (deux fils), ce qui minimise le câblage — seules les lignes SDA et SCL sont nécessaires en plus de l'alimentation.
L'affichage est auto-lumineux (pas de rétroéclairage nécessaire), offre un contraste élevé, un angle de vision large, et est lisible dans les environnements lumineux comme sombres. Il est couramment disponible en variantes de 128×64 et 128×32 pixels.
Caractéristiques clés :
- Interface I2C (adresse par défaut 0x3C)
- Résolution 128×64 pixels (ou 128×32, 96×16, 64×48, 64×32)
- Défilement matériel intégré en directions horizontale et diagonale
- Contraste réglable (0–255)
- Étend framebuf.FrameBuffer — toutes les primitives de dessin MicroPython fonctionnent immédiatement
Description des Broches
| Broche | Fonction | Connexion Raspberry Pi Pico |
|---|---|---|
| SDA | Ligne de données I2C | Connecter à GP0 (broche 1) |
| SCL | Ligne d'horloge I2C | Connecter à GP1 (broche 2) |
| VCC | Entrée d'alimentation 3,3V à 5V | Connecter à 3V3(OUT) |
| GND | Masse | Connecter à GND |
Câblage
Le Raspberry Pi Pico fonctionne nativement à 3,3V logique, ce qui est compatible avec l'écran SSD1309.
| OLED SSD1309 | Raspberry Pi Pico | Remarques |
|---|---|---|
| SDA | GP0 (broche 1) | Données I2C |
| SCL | GP1 (broche 2) | Horloge I2C |
| VCC | 3V3(OUT) (broche 36) | Alimentation (3,3 V) |
| GND | GND (broche 38) | Masse |
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Conseil : Vous pouvez utiliser n'importe quelles broches GP compatibles I2C disponibles sur le Pico. Mettez simplement à jour les valeurs SCL_PIN et SDA_PIN dans le code.
Étapes Rapides
Voici les instructions pour configurer et exécuter votre code MicroPython sur le Raspberry Pi Pico avec Thonny IDE :
- Assurez-vous que Thonny IDE est installé sur votre ordinateur.
- Confirmez que le firmware MicroPython est chargé sur votre carte Raspberry Pi Pico.
- Si c'est votre première utilisation d'un Raspberry Pi Pico avec MicroPython, consultez le guide Démarrage avec Raspberry Pi Pico MicroPython pour des instructions étape par étape.
- Connectez la carte Raspberry Pi Pico à l'OLED SSD1309 selon le schéma fourni.
- Connectez la carte Raspberry Pi Pico à votre ordinateur avec un câble USB.
- Ouvrez Thonny IDE sur votre ordinateur.
- Dans Thonny IDE, allez dans Outils Options.
- Sous l'onglet Interpréteur, choisissez MicroPython (Raspberry Pi Pico) dans le menu déroulant.
- Assurez-vous que le bon port est sélectionné. Thonny IDE le détecte généralement automatiquement, mais vous devrez peut-être le sélectionner manuellement (comme COM12 sur Windows ou /dev/ttyACM0 sur Linux).
- Naviguez vers Outils Gérer les paquets dans Thonny IDE.
- Recherchez "DIYables-MicroPython-OLED-SSD1309", puis trouvez la bibliothèque OLED SSD1309 créée par DIYables.
- Cliquez sur DIYables-MicroPython-OLED-SSD1309, puis cliquez sur le bouton Installer pour installer la bibliothèque.
- Copiez le code MicroPython fourni et collez-le dans l'éditeur de Thonny.
- Sauvegardez le code sur votre Raspberry Pi Pico en :
- Cliquant sur le bouton Sauvegarder ou en appuyant sur Ctrl+S.
- Dans la boîte de dialogue de sauvegarde, choisissez Appareil MicroPython.
- Nommez le fichier main.py.
- Cliquez sur le bouton vert Exécuter (ou appuyez sur F5) pour exécuter le script.
- Observez le résultat — du texte et des graphiques devraient apparaître sur l'écran OLED.
Code de Départ
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
# Configuration des broches — modifiez pour correspondre à votre câblage
SCL_PIN = 1 # GP1
SDA_PIN = 0 # GP0
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# Effacer l'affichage, dessiner quelque chose, puis envoyer à l'écran
oled.fill(0)
oled.text("Hello, World!", 0, 0)
oled.show()
Code Raspberry Pi Pico — Bonjour le Monde
"""
Example: Hello World – basic text on SSD1309 OLED
Works with: Raspberry Pi Pico
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
Raspberry Pi Pico:
OLED SSD1309 Raspberry Pi Pico
──────────── ─────────────────
SDA -> GP0 (pin 1)
SCL -> GP1 (pin 2)
VCC -> 3V3(OUT) (pin 36)
GND -> GND (pin 38)
"""
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 1 # GP1
SDA_PIN = 0 # GP0
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# ── Draw ─────────────────────────────────────────────────────────────────────
oled.fill(0)
# Line 1 – normal 8×8 font
oled.text("Hello, World!", 0, 0)
# Line 3
oled.text("DIYables", 0, 16)
# Line 4
oled.text("SSD1309 OLED", 0, 32)
oled.text("128 x 64", 0, 40)
oled.show()
Essayez
- Câblez l'OLED SSD1309 au Raspberry Pi Pico selon le schéma ci-dessus.
- Téléversez le code avec Thonny IDE.
- Vous devriez voir "Hello, World!", "DIYables", et "SSD1309 OLED 128 x 64" affichés à l'écran.
Référence de Dessin de Texte
| Appel de Méthode | Ce qu'elle fait | Remarques |
|---|---|---|
| oled.fill(0) | Effacer l'écran entier (tous les pixels éteints) | Toujours appeler avant de dessiner une nouvelle trame |
| oled.text("Hello!", 0, 0) | Dessiner du texte en colonne 0, rangée 0 | Police intégrée 8×8 pixels ; 16 caractères par rangée, 8 rangées sur un affichage 64px |
| oled.text("Ligne 2", 0, 16) | Dessiner du texte sur la deuxième ligne | Les rangées font 8 px de haut ; la ligne suivante est y+8 ou y+16 pour l'espacement |
| oled.show() | Envoyer le tampon de trame à l'affichage physique | Rien n'est visible jusqu'à ce que show() soit appelé |
Code Raspberry Pi Pico — Dessiner des Formes
"""
Example: Draw Shapes – lines, rectangles, and circles on SSD1309 OLED
Works with: Raspberry Pi Pico
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
Raspberry Pi Pico:
OLED SSD1309 Raspberry Pi Pico
──────────── ─────────────────
SDA -> GP0 (pin 1)
SCL -> GP1 (pin 2)
VCC -> 3V3(OUT) (pin 36)
GND -> GND (pin 38)
Note:
framebuf.FrameBuffer provides: pixel, fill, fill_rect, rect, line,
hline, vline, text, blit, scroll, and (on newer MicroPython) ellipse & poly.
Circles and triangles require manual drawing or the ellipse/poly helpers.
"""
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
import time
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 1 # GP1
SDA_PIN = 0 # GP0
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
def demo_pixels():
"""Scatter individual pixels diagonally."""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
for i in range(0, w, 4):
oled.pixel(i, i * h // w, 1)
oled.show()
time.sleep_ms(1500)
def demo_lines():
"""Fan of lines from the top-left corner.
"""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
for i in range(0, w, 8):
oled.line(0, 0, i, h - 1, 1)
for i in range(0, h, 8):
oled.line(0, 0, w - 1, i, 1)
oled.show()
time.sleep_ms(1500)
def demo_h_v_lines():
"""Horizontal and vertical lines."""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
# horizontal lines
for y in range(0, h, 8):
oled.hline(0, y, w, 1)
# vertical lines
for x in range(0, w, 16):
oled.vline(x, 0, h, 1)
oled.show()
time.sleep_ms(1500)
def demo_rectangles():
"""Nested rectangle outlines.
"""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
for i in range(0, h // 2, 4):
oled.rect(i, i, w - 2 * i, h - 2 * i, 1)
oled.show()
time.sleep_ms(1500)
def demo_filled_rects():
"""Alternating filled rectangles."""
oled.fill(0)
w, h = SCREEN_WIDTH, SCREEN_HEIGHT
for i in range(0, h // 2, 6):
color = 1 if (i // 6) % 2 == 0 else 0
oled.fill_rect(i, i, w - 2 * i, h - 2 * i, color)
oled.show()
time.sleep_ms(1500)
def demo_ellipse():
"""Ellipses (requires MicroPython 1.20+ for framebuf.ellipse).
"""
oled.fill(0)
cx, cy = SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2
try:
for r in range(4, min(cx, cy), 8):
oled.ellipse(cx, cy, r, r, 1) # circle outline
oled.show()
except AttributeError:
# ellipse not available; fall back to a manual Bresenham circle
_draw_circle(cx, cy, 20, 1)
oled.show()
time.sleep_ms(1500)
def _draw_circle(cx, cy, r, c):
"""Bresenham circle (fallback when framebuf.ellipse is unavailable)."""
x, y, err = r, 0, 1 - r
while x >= y:
for dx, dy in [(x, y), (y, x), (-y, x), (-x, y),
(-x, -y), (-y, -x), (y, -x), (x, -y)]:
oled.pixel(cx + dx, cy + dy, c)
y += 1
if err < 0:
err += 2 * y + 1
else:
x -= 1
err += 2 * (y - x) + 1
# ── Main loop ────────────────────────────────────────────────────────────────
while True:
demo_pixels()
demo_lines()
demo_h_v_lines()
demo_rectangles()
demo_filled_rects()
demo_ellipse()
"""
Essayez
- Téléversez le code avec Thonny IDE.
- L'affichage passe par des démos : pixels diagonaux, éventails de lignes, lignes de grille, contours de rectangles et rectangles remplis.
Référence des Méthodes de Dessin
| Appel de Méthode | Ce qu'elle dessine | Remarques |
|---|---|---|
| oled.pixel(x, y, 1) | Pixel unique en (x, y) | 0 = éteint, 1 = allumé |
| oled.line(x1, y1, x2, y2, 1) | Ligne entre deux points | Algorithme de Bresenham |
| oled.hline(x, y, w, 1) | Ligne horizontale de largeur w | Plus rapide que line() pour l'horizontal |
| oled.vline(x, y, h, 1) | Ligne verticale de hauteur h | Plus rapide que line() pour le vertical |
| oled.rect(x, y, w, h, 1) | Contour de rectangle | Coin supérieur gauche en (x, y) |
| oled.fill_rect(x, y, w, h, 1) | Rectangle rempli | Mêmes paramètres que rect() |
Code Raspberry Pi Pico — Faire Défiler le Texte
"""
Example: Scroll Text – hardware scrolling on SSD1309 OLED
Works with: Raspberry Pi Pico
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
Raspberry Pi Pico:
OLED SSD1309 Raspberry Pi Pico
──────────── ─────────────────
SDA -> GP0 (pin 1)
SCL -> GP1 (pin 2)
VCC -> 3V3(OUT) (pin 36)
GND -> GND (pin 38)
"""
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
import time
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 1 # GP1
SDA_PIN = 0 # GP0
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# ── Draw static content ───────────────────────────────────────────────────────
oled.fill(0)
oled.text("DIYables", 20, 28) # centred-ish on 128×64
oled.show()
time.sleep_ms(2000)
# ── Scroll loop ───────────────────────────────────────────────────────────────
while True:
# Scroll right across all pages (0–7)
oled.scroll_right(0x00, 0x07)
time.sleep_ms(3000)
oled.stop_scroll()
time.sleep_ms(500)
# Scroll left
oled.scroll_left(0x00, 0x07)
time.sleep_ms(3000)
oled.stop_scroll()
time.sleep_ms(500)
# Diagonal scroll right
oled.scroll_diag_right(0x00, 0x07)
time.sleep_ms(3000)
oled.stop_scroll()
time.sleep_ms(500)
# Diagonal scroll left
oled.scroll_diag_left(0x00, 0x07)
time.sleep_ms(3000)
oled.stop_scroll()
time.sleep_ms(500)
Essayez
- Téléversez le code avec Thonny IDE.
- L'affichage défile vers la droite, puis vers la gauche, puis en diagonale vers la droite, puis en diagonale vers la gauche, et recommence.
Référence de Défilement Matériel
| Appel de Méthode | Direction de Défilement | Remarques |
|---|---|---|
| oled.scroll_right(0x00, 0x07) | Droite | Pages 0–7 = toutes les rangées sur un affichage 64 px |
| oled.scroll_left(0x00, 0x07) | Gauche | Les pages 0–7 couvrent toute la hauteur de l'écran |
| oled.scroll_diag_right(0x00, 0x07) | Diagonale droite (droite + bas) | Combine le défilement horizontal et vertical |
| oled.scroll_diag_left(0x00, 0x07) | Diagonale gauche (gauche + bas) | Combine le défilement horizontal et vertical |
| oled.stop_scroll() | Arrêter le défilement | Appeler avant de dessiner du nouveau contenu |
Remarque : Modifiez le tampon de trame (ex. appelez oled.fill() + oled.show()) avant de démarrer un nouveau défilement pour mettre à jour le contenu défilant. Appelez toujours stop_scroll() avant d'envoyer de nouvelles commandes de dessin.
Code Raspberry Pi Pico — Contraste et Atténuation
"""
Example: Contrast & Dim – contrast control on SSD1309 OLED
Works with: Raspberry Pi Pico
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
Raspberry Pi Pico:
OLED SSD1309 Raspberry Pi Pico
──────────── ─────────────────
SDA -> GP0 (pin 1)
SCL -> GP1 (pin 2)
VCC -> 3V3(OUT) (pin 36)
GND -> GND (pin 38)
"""
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
import time
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 1 # GP1
SDA_PIN = 0 # GP0
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# ── Draw a test pattern ───────────────────────────────────────────────────────
oled.fill(0)
oled.fill_rect(0, 0, 64, 32, 1) # top-left filled block
oled.fill_rect(64, 32, 64, 32, 1) # bottom-right filled block
oled.text("Contrast Demo", 8, 28) # label over the blocks
oled.show()
time.sleep_ms(2000)
# ── Contrast / dim loop ───────────────────────────────────────────────────────
while True:
# Gradually increase contrast 0 → 255
for c in range(0, 256, 5):
oled.set_contrast(c)
time.sleep_ms(30)
time.sleep_ms(1000)
# Gradually decrease contrast 255 → 0
for c in range(255, -1, -5):
oled.set_contrast(c)
time.sleep_ms(30)
time.sleep_ms(1000)
# Dim on / off toggle
oled.dim(True)
time.sleep_ms(2000)
oled.dim(False)
time.sleep_ms(2000)
Essayez
- Téléversez le code avec Thonny IDE.
- Observez la luminosité de l'affichage augmenter et diminuer progressivement, puis basculer entre atténué et pleine luminosité.
Référence Contraste et Atténuation
| Appel de Méthode | Effet | Remarques |
|---|---|---|
| oled.set_contrast(0) | Luminosité minimale | Plage de valeurs 0–255 |
| oled.set_contrast(128) | Luminosité moyenne | La valeur est sauvegardée en interne pour l'atténuation/restauration |
| oled.set_contrast(255) | Luminosité maximale | La valeur par défaut après initialisation est 0xCF (207) |
| oled.dim(True) | Réduire le contraste à 0 (atténuer) | Ne modifie pas la valeur de contraste sauvegardée |
| oled.dim(False) | Restaurer le contraste sauvegardé | Restaure la valeur définie par set_contrast() |
| oled.invert(True) | Inverser tous les pixels au niveau matériel | Aucun changement du tampon de trame |
| oled.invert(False) | Restaurer la polarité normale des pixels | — |
Code Raspberry Pi Pico — Bitmap
"""
Example: Bitmap – display a monochrome bitmap image on SSD1309 OLED
Works with: Raspberry Pi Pico
Product page: https://diyables.io/products/2.4-inch-oled-display-module-ssd1309-128x64
Wiring guide:
Raspberry Pi Pico:
OLED SSD1309 Raspberry Pi Pico
──────────── ─────────────────
SDA -> GP0 (pin 1)
SCL -> GP1 (pin 2)
VCC -> 3V3(OUT) (pin 36)
GND -> GND (pin 38)
How bitmap drawing works:
framebuf.FrameBuffer.blit() copies one FrameBuffer onto another.
Bitmap data must be stored row-by-row, MSB first → use framebuf.MONO_HMSB.
The blit() call then handles the conversion into the display's MONO_VLSB
layout automatically.
"""
import framebuf
from machine import I2C, Pin
from DIYables_MicroPython_OLED_SSD1309 import OLED_SSD1309
import time
# ── Pin configuration ────────────────────────────────────────────────────────
SCL_PIN = 1 # GP1
SDA_PIN = 0 # GP0
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64
SCREEN_ADDRESS = 0x3C
# ── Bitmap data – 16 × 16 heart, stored row-by-row MSB first ─────────────────
# Each row uses 2 bytes (ceil(16 / 8) = 2).
HEART_W = 16
HEART_H = 16
heart_data = bytearray([
0x00, 0x00, # ................
0x0C, 0x30, # ....##....##....
0x1E, 0x78, # ...####..####...
0x3F, 0xFC, # ..############..
0x7F, 0xFE, # .##############.
0x7F, 0xFE, # .##############.
0xFF, 0xFF, # ################
0xFF, 0xFF, # ################
0xFF, 0xFF, # ################
0x7F, 0xFE, # .##############.
0x3F, 0xFC, # ..############..
0x1F, 0xF8, # ...##########...
0x0F, 0xF0, # ....########....
0x07, 0xE0, # .....######.....
0x03, 0xC0, # ......####......
0x01, 0x80, # .......##.......
])
# ── Setup ────────────────────────────────────────────────────────────────────
i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=400_000)
oled = OLED_SSD1309(SCREEN_WIDTH, SCREEN_HEIGHT, i2c, addr=SCREEN_ADDRESS)
# Wrap the raw bytes in a FrameBuffer using MONO_HMSB (row-major, MSB first)
heart_fb = framebuf.FrameBuffer(heart_data, HEART_W, HEART_H, framebuf.MONO_HMSB)
# ── Draw and animate ──────────────────────────────────────────────────────────
while True:
# Draw the heart centred on the display
x = (SCREEN_WIDTH - HEART_W) // 2
y = (SCREEN_HEIGHT - HEART_H) // 2
oled.fill(0)
oled.blit(heart_fb, x, y)
oled.text("DIYables", 24, 50)
oled.show()
time.sleep_ms(800)
# Invert colours for a "pulse" effect
oled.fill(1)
oled.blit(heart_fb, x, y, 1) # key=1 → blit only pixels that are OFF in source
oled.show()
time.sleep_ms(400)
Essayez
- Téléversez le code avec Thonny IDE.
- Une icône de cœur 16×16 apparaît centrée sur l'affichage. Elle pulse en alternant entre les trames normale et inversée.
Référence de Dessin Bitmap
| Appel de Méthode | Description | Remarques |
|---|---|---|
| framebuf.FrameBuffer(data, w, h, framebuf.MONO_HMSB) | Enveloppe des octets bruts comme un FrameBuffer bitmap | Utilisez MONO_HMSB pour les données en rangée principale MSB en premier |
| oled.blit(icon_fb, x, y) | Copie le bitmap sur le tampon de trame de l'affichage en (x, y) | Tous les pixels sont copiés (pas de transparence) |
| oled.blit(icon_fb, x, y, 1) | Blit avec key=1 — ignorer les pixels avec la valeur 1 | Utile pour les effets de style XOR sur des arrière-plans remplis |
Comment les données bitmap sont stockées : Chaque rangée est stockée de gauche à droite, bit le plus significatif en premier (MONO_HMSB). Le nombre d'octets par rangée est ceil(largeur / 8). Pour une image de 16 pixels de large, c'est 2 octets par rangée.
Référence de la Bibliothèque
Consultez la Référence de la Bibliothèque DIYables MicroPython OLED SSD1309 pour la documentation complète de l'API, y compris tous les constructeurs, méthodes et constantes.
Prochaines Étapes
- Combinez avec un capteur DHT11 ou DHT22 pour afficher les lectures de température et d'humidité en temps réel.
- Ajoutez un bouton pour passer entre plusieurs écrans d'affichage.
- Utilisez framebuf.FrameBuffer.blit() pour construire un affichage de sprite animé.