Présentation du matériel

L'écran OLED de 0,96 pouce est un composant de choix pour ajouter une interface visuelle à vos projets Raspberry Pi. Le contrôleur SSD1315, qui équipe ces modules, est entièrement compatible avec les registres du célèbre SSD1306. Cela permet d'utiliser les bibliothèques existantes sans modification majeure. Ce guide détaille les étapes de branchement, la configuration logicielle et la programmaiton en Python.

Schéma de branchement (Interface I2C)

La version la plus courante de cet écran utilise le bus I2C, nécessitant seulement quatre connexions :

Configuration du système

L'interface I2C doit être activée manuellement sur Raspberry Pi OS. Ouvrez un terminal et lancez l'utilitaire de configuration :

sudo raspi-config

Naviguez dans Interface Options > I2C, sélectionnez Yes, puis validez et redémarrez votre Pi.

Une fois redémarré, vérifiez la présence de l'écran avec les outils I2C :

sudo apt update && sudo apt install -y i2c-tools
sudo i2cdetect -y 1

Si le câblage est correct, une adresse (généralement 3c) apparaîtra dans la matrice.

Installation de l'environnement Python

Nous utiliserons la bibliothèque luma.oled, reconnue pour sa robustesse. Installze d'abord les dépendances système, puis le paquet Python :

sudo apt install -y python3-pip python3-dev libfreetype6-dev libjpeg-dev libopenjp2-7 libtiff5
pip3 install luma.oled

Exemple de code : Affichage de base

Voici un script simple pour initialiser l'écran et afficher quelques lignes de texte.

from luma.core.interface.serial import i2c
from luma.core.render import canvas
from luma.oled.device import ssd1306
from PIL import ImageFont
import time

def demo_affichage():
    # Configuration de l'interface
    bus_i2c = i2c(port=1, address=0x3C)
    ecran = ssd1306(bus_i2c, width=128, height=64)

    # Chargement d'une police par défaut
    police_defaut = ImageFont.load_default()

    with canvas(ecran) as dessin:
        dessin.text((5, 5), "Système OK", font=police_defaut, fill="white")
        dessin.text((5, 20), "OLED SSD1315", font=police_defaut, fill="white")
        dessin.rectangle((0, 0, 127, 63), outline="white")

    print("Affichage actif pendant 10 secondes...")
    time.sleep(10)

if __name__ == "__main__":
    demo_affichage()

Monitoring système en temps réel

Ce script plus avancé récupère les paramètres de la machine (IP, température CPU) pour les afficher de manière dynamique.

import os
import time
import subprocess
from luma.core.interface.serial import i2c
from luma.core.render import canvas
from luma.oled.device import ssd1306
from PIL import ImageFont

def lecture_temp():
    with open("/sys/class/thermal/thermal_zone0/temp", "r") as f:
        temp_raw = int(f.read())
    return f"{temp_raw / 1000:.1f}°C"

def lecture_ip():
    try:
        commande = "hostname -I | cut -d' ' -f1"
        return subprocess.check_output(commande, shell=True).decode().strip()
    except:
        return "Pas d'IP"

def moniteur_systeme():
    liaison = i2c(port=1, address=0x3C)
    periph = ssd1306(liaison)
    fnt = ImageFont.load_default()

    try:
        while True:
            with canvas(periph) as draw:
                draw.text((0, 0), "MONITEUR RASPBERRY", font=fnt, fill="white")
                draw.line((0, 12, 128, 12), fill="white")
                draw.text((0, 16), f"IP: {lecture_ip()}", font=fnt, fill="white")
                draw.text((0, 30), f"CPU Temp: {lecture_temp()}", font=fnt, fill="white")
                draw.text((0, 44), time.strftime("%d/%m/%Y"), font=fnt, fill="white")
                draw.text((0, 54), time.strftime("%H:%M:%S"), font=fnt, fill="white")
            time.sleep(1)
    except KeyboardInterrupt:
        pass

if __name__ == "__main__":
    moniteur_systeme()

Gestion des caractères spéciaux et polices TTF

La police par défaut ne supporte pas les accents français. Pour un affichage correct, il est conseillé d'utiliser une police TrueType (.ttf) :

# Exemple de chargement d'une police système (si installée)
# sudo apt install fonts-freefont-ttf
font_path = "/usr/share/fonts/truetype/freefont/FreeSans.ttf"
custom_font = ImageFont.truetype(font_path, 12)

with canvas(device) as draw:
    draw.text((0, 0), "Température :", font=custom_font, fill="white")

Automatisation au démarrage

Pour transformer votre Raspberry Pi en appareil dédié avec écran, créez un service systemd pour lancer votre script au boot :

sudo nano /etc/systemd/system/oled_stats.service

Ajoutez la configuration suivante :

[Unit]
Description=Stats OLED Service
After=network.target

[Service]
ExecStart=/usr/bin/python3 /home/pi/votre_script.py
Restart=always
User=pi

[Install]
WantedBy=multi-user.target

Activez-le ensuite :

sudo systemctl enable oled_stats.service
sudo systemctl start oled_stats.service

Dépannage courant

• Écran noir : Vérifiez que le bus I2C est bien alimenté en 3.3V. Testez l'inversion de SDA et SCL si i2cdetect ne renvoie rien.
• Affichage décalé : Si l'image semble décalée de quelques pixels, vérifiez si votre module n'utilise pas un driver SH1106 au lieu du SSD1306. Dans ce cas, remplacez from luma.oled.device import ssd1306 par sh1106.
• Lenteur : Augmentez la vitesse du bus I2C dans /boot/config.txt en ajoutant dtparam=i2c_arm_baudrate=400000.