Comment utiliser un écran E-ink avec Raspberry Pi

J’ai toujours été fasciné par les projets qui utilisent ces écrans façon papier (vous savez, comme l’écran d’un Kindle). Alors j’ai décidé de me lancer. Comme ce n’était pas aussi simple que je l’espérais, j’ai documenté toutes les étapes. Comme ça, vous avez une longueur d’avance si vous décidez de vous y mettre.

Un écran e-ink est un écran qui imite l’aspect du papier imprimé, consomme très peu d’énergie et reste lisible même en plein soleil. Avec un Raspberry Pi, il est souvent utilisé pour des affichages statiques ou de petits tableaux de bord qui n’ont pas besoin d’être rafraîchis en permanence.

Dans ce tutoriel, je partage ma progression pour vous donner quelques pistes. On commence par les bases : le matériel nécessaire, comment tout configurer, et les premiers tests. Je ne suis pas expert dans ce domaine, mais j’espère que ça vous aidera à démarrer plus vite que moi.

Si, comme moi, vous mélangez parfois la syntaxe entre différents langages de programmation, j’ai exactement ce qu’il vous faut. J’ai créé une fiche mémo Python avec toute la syntaxe essentielle au même endroit, pour que vous puissiez l’avoir sous la main et éviter toute confusion. Téléchargez-la gratuitement ici !

C’est quoi un écran e-ink (et pourquoi en utiliser un) ?

L’e-ink (ou « encre électronique ») est une technologie d’affichage qui ressemble à du papier imprimé. Vous en avez probablement déjà vu sur les Kindle ou autres liseuses. Au lieu d’émettre de la lumière comme un écran classique, il réfléchit la lumière ambiante, ce qui est bien plus agréable à lire.

Dans l’écosystème Raspberry Pi, le principal avantage de l’e-ink, c’est sa consommation d’énergie quasi nulle. En fait, l’image reste affichée même quand l’alimentation est coupée. Il ne consomme de l’énergie que lorsqu’on met à jour l’affichage.

Donc, si vous pensez à un badge avec votre nom et le logo de votre entreprise, ou à un projet outdoor qui tourne sur batterie et affiche quelques données tout en restant lisible en plein soleil, c’est le cas d’usage parfait.

Il y a quelques limitations, comme un taux de rafraîchissement lent (n’espérez pas faire des animations ou des vidéos) ou la qualité des couleurs (la plupart des modèles sont en noir et blanc), mais c’est vraiment sympa pour des petits tableaux de bord, des stations météo, des étiquettes de prix ou des notifications.

Si vous avez un projet qui doit afficher des données qui ne changent pas souvent, mais qui doit rester visible en toutes circonstances, ça peut coller. C’est aussi fun à utiliser, pas trop cher, et facile à intégrer dans n’importe quel projet Python.

Le matériel nécessaire pour utiliser un écran e-ink sur Raspberry Pi

Il ne faut pas grand chose pour démarrer, juste un Raspberry Pi et le HAT d’affichage, mais on va quand même passer en revue tout ce qu’il faut avant d’attaquer la partie technique.

Au passage, HAT signifie « Hardware Attached on Top » — c’est en gros une carte d’extension qui se branche directement sur votre Raspberry Pi pour lui ajouter de nouvelles fonctionnalités.

Ce qu’il vous faut

Il existe plein de marques et de modèles pour ce type de montage, mais voilà ce que j’utilise. Je trouve que c’est une config assez abordable. Si vous n’avez pas de contraintes particulières, c’est probablement un bon point de départ.

• Un HAT d’affichage e-ink : J’utilise la version 2.13″ de Waveshare, qui semble être la référence dans cette catégorie. Il existe d’autres tailles, donc vous pouvez opter pour quelque chose de plus grand selon vos besoins (ou votre modèle de Pi), mais les étapes techniques restent très similaires.
• Un Raspberry Pi 4 : Au départ, je voulais utiliser un Pi Zero 2, qui a le même format, mais ça ne s’adaptait pas bien avec mon boîtier, alors je suis passé au Pi 4. Cela dit, n’importe quel modèle devrait faire l’affaire. Ça ne demande pas beaucoup de ressources.

Pour le reste, vous avez juste besoin des basiques : une bonne carte microSD et une alimentation fiable, éventuellement un écran et un clavier/souris (en anglais), mais on peut aussi tout faire en headless si vous préférez.

Configurer votre Raspberry Pi

Avant d’écrire la moindre ligne de code Python, il faut brancher le tout et préparer le système. Voilà ce qu’il y a à faire.

Brancher le HAT

Mon HAT était livré avec des câbles GPIO, utiles pour un affichage déporté ou pour l’utiliser avec d’autres cartes et contrôleurs (il est compatible avec beaucoup d’entre eux, comme Arduino et ESP32), mais pas vraiment pour un test rapide sur Raspberry Pi.

Si vous utilisez un modèle standard de Raspberry Pi, le HAT se branche directement sur les pins GPIO. Pi éteint, posez le HAT sur les pins et appuyez doucement. Ensuite, vous pouvez allumer et suivre les étapes ci-dessous pour la partie logicielle.

Le gros avantage des HATs Raspberry Pi, c’est qu’ils sont quasi plug-and-play. Pas besoin de se battre avec le câblage et la soudure comme avec d’autres accessoires.

Si vous n’utilisez pas un Pi ou si votre projet nécessite des câbles, consultez la notice pour savoir comment le brancher correctement. Ça ne devrait pas être compliqué non plus.

Configuration de Raspberry Pi OS

Je recommande vraiment d’utiliser Raspberry Pi OS pour ça, tout sera plus fluide puisque c’est fait pour, et le HAT sera détecté directement. Je n’ai pas testé sur un autre système, mais c’est généralement comme ça que ça se passe.

Je teste sur une version Lite de Raspberry Pi OS, puisqu’aucune interface graphique n’est nécessaire pour ce type de projet.
Si vous avez besoin d’aide pour installer Raspberry Pi OS, consultez nos tutoriels. Une fois que vous avez accès à votre session (via SSH par exemple), voilà les principales étapes pour préparer votre système :

• Faites les mises à jour système, comme d’habitude :
  sudo apt update
sudo apt upgrade -y
  
• Activez le SPI :
  sudo raspi-config
Allez dans Interface Options > SPI et confirmez pour l’activer.
  
• Redémarrez le système :
  sudo reboot

Installer les dépendances

Une fois la config de base faite, il faut installer les principales bibliothèques avant d’écrire la moindre ligne de code. La documentation officielle était un peu brouillonne, donc j’essaie de simplifier les étapes ici.

Je donne les prérequis pour Python, mais si vous voulez coder en C ou dans un autre langage, il faudra suivre la documentation du fabricant. Les dépendances peuvent aussi varier légèrement selon le matériel. Voilà ce qu’il faut pour le produit Waveshare que j’ai testé.

Commencez par installer toutes ces bibliothèques Python :
sudo apt install python3-pip python3-pil python3-numpy python3-setuptools python3-gpiozero python3-spidev

Si les commandes Linux ce n’est pas trop votre truc, n’hésitez pas à jeter un œil à cet article qui vous explique les commandes qu’il faut absolument connaître. Je vous donne aussi une antisèche à télécharger pour les avoir toujours sous la main !

Premiers pas avec un écran e-ink

On passe au code. On va d’abord lancer un script fourni par le fabricant sans chercher à le comprendre (juste pour vérifier que tout fonctionne). Ensuite, on créera un script simple qu’on améliorera étape par étape, pour que vous compreniez la logique derrière la plupart des scripts e-ink.

Lancer la démo

Waveshare (comme la plupart des fabricants) fournit une démo pour tester l’écran. Je recommande vraiment de commencer par là avant d’écrire votre propre script. Ça permet de vérifier que tout fonctionne avec leur code et que la config est prête.

Voici les instructions pour l’écran Waveshare 2.13″ :

• Téléchargez le code de démo avec :
  wget https://files.waveshare.com/upload/7/71/E-Paper_code.zip
• Extrayez les fichiers :
  unzip E-Paper_code.zip -d ePaper
• Allez dans le sous-dossier Python pour Raspberry Pi :
  cd ePaper/RaspberryPi_JetsonNano/python/examples
• Lancez le script de démo :
  python3 epd_2in13_V4_test.py
  Consultez la documentation pour savoir quel script de démo utiliser avec votre matériel. Le format semble être epd_TAILLE_VERSION_test.py chez Waveshare.

Si tout se passe bien, l’écran va se mettre à clignoter et afficher différentes mises en page et contenus. Attendez de voir du texte et des formes à l’écran avant de continuer. Corrigez les éventuelles erreurs à cette étape. Si la démo ne fonctionne pas, votre propre script ne fonctionnera pas non plus.

Rendre la lib disponible dans votre projet

Si vous ne voulez pas rester dans le dossier de la démo et préférez créer un nouveau dossier pour votre projet, il faut rendre la bibliothèque accessible depuis n’importe où.

Il y a probablement plusieurs façons de faire, mais moi j’ai copié le dossier de la bibliothèque dans mon projet. Vous pouvez faire pareil avec ces commandes :
cd <VOTRE_PROJET>
cp /home/$USER/ePaper/RaspberryPi_JetsonNano/python/lib/waveshare_epd ./ -r

Adaptez les commandes ci-dessus à la structure de votre projet et au chemin où vous avez téléchargé les fichiers, mais ça devrait être très proche. Ensuite, testez un script minimaliste (comme le Hello World ci-dessous) pour vérifier que ça fonctionne.

Note : Je n’ai pas utilisé pip (en anglais) ni créé d’environnement virtuel, même si c’est possible. J’ai fait ça pour rester le plus simple possible. Pour des projets à long terme, ce serait une bonne idée.

Afficher votre premier texte (Hello World)

À ce stade, je recommande de créer un script minimal pour vérifier que la bibliothèque est bien détectée dans votre dossier de projet et que l’écran fonctionne comme prévu.

Je n’explique pas la syntaxe Python de base dans ce tutoriel. Si vous débutez, commencez par lire nos autres tutoriels. Voilà mon guide débutant pour utiliser Python sur Raspberry Pi, avec une cheat sheet des principaux éléments de syntaxe. Si vous préférez une approche plus guidée, vous pouvez aussi vous procurer mon e-book « Master Python on Raspberry Pi« .

Bref, comme pour la plupart des projets, j’ai commencé par un script « Hello World » basique. Voilà le script complet que vous pouvez copier-coller. J’explique les parties principales juste après :

import time
from PIL import Image, ImageDraw, ImageFont
from waveshare_epd import epd2in13_V4
# 1. Setup
epd = epd2in13_V4.EPD()
epd.init()
epd.Clear()
# 2. Create Image (using e-paper dimensions)
image = Image.new('1', (epd.width, epd.height), 255) #255 = white background
draw = ImageDraw.Draw(image)
font = ImageFont.load_default()
# 3. Draw directly
draw.text((10, 10), 'Hello Pi', font=font, fill=0)
# 4. Push to screen
epd.display(epd.getbuffer(image))
# 5. Cleanup
time.sleep(2)
epd.sleep()

Comme vous pouvez le voir avec les commentaires, il y a quelques étapes incontournables que vous utiliserez à chaque fois avec ce type d’écran :

• Importer les bibliothèques nécessaires : ici, on a surtout besoin du driver Waveshare, mais aussi d’une bibliothèque de gestion d’images comme Pillow.
• Initialisation : on définit l’écran comme indiqué dans la notice, et on l’efface pour repartir de zéro.
• Créer un canvas vierge : pensez à ces scripts comme des générateurs d’images. On part d’une image vierge, on y ajoute tous les éléments voulus, et seulement ensuite on envoie le résultat à l’écran.
• Modifier l’image : la fonction « draw.text » est la plus simple pour ajouter du texte sur ce canvas.
• Envoyer à l’écran : une fois le texte ajouté, on utilise la fonction « display » pour mettre à jour l’affichage.
• Ensuite, on fait une pause. L’écran ne doit pas être rafraîchi trop souvent. Mettez-le en veille si vous ne le mettez pas à jour après ça. N’oubliez pas qu’il n’a pas besoin d’énergie pour continuer à afficher votre texte.

Prenez quelques minutes pour bien comprendre cette logique, parce qu’on va l’utiliser dans tous les exemples qui suivent. Mon but maintenant, c’est d’améliorer ça et de vous montrer d’autres fonctions utiles pour faire plein de choses différentes. Mais l’idée principale est posée dans ce script de base.

Quelques modifications simples à essayer

L’exemple précédent utilise une police par défaut en petite taille, ce qui peut être difficile à lire. Si vous voulez afficher quelque chose de plus grand, il faudra avoir une police installée. J’ai testé avec « Deja vu », installée avec :
sudo apt install fonts-dejavu

Vous pouvez ensuite l’utiliser comme ça à la place de la police par défaut :
font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', 24)
Le dernier chiffre, c’est la taille de la police. Ajustez-le selon la longueur du texte.

J’utilise aussi l’écran en mode paysage plutôt qu’en portrait. Ça permet d’écrire des textes plus longs ou d’utiliser une police plus grande pour une meilleure lisibilité.

Bizarrement, je ne pense pas qu’il y ait un moyen simple de faire ça directement avec la fonction text(). J’ai dû créer une image temporaire avec le texte dessus, puis la faire pivoter de 90°. Et vous voudrez probablement centrer le texte ou avoir un positionnement dynamique, ce qui ajoute une couche de complexité.

Voilà mon script pour tout ça (police, taille, paysage et centrage). Vous pouvez partir de là et l’adapter selon vos besoins. Et si vous trouvez une façon plus simple, dites-le moi !

import time
from PIL import Image, ImageDraw, ImageFont
from waveshare_epd import epd2in13_V4
# Initialize the e-Paper display
epd = epd2in13_V4.EPD()
epd.init()
epd.Clear()
# Create a blank image for drawing
width, height = epd.width, epd.height
image = Image.new('1', (width, height), 255)
draw = ImageDraw.Draw(image)
# Load a font
try:
    font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', 28)
except:
    font = ImageFont.load_default()
# Get the exact size of the text so the "sticker" isn't too big
text = 'RaspberryTips'
bbox = font.getbbox(text) # Returns (left, top, right, bottom)
text_width = bbox[2]
text_height = bbox[3]
# Create a temporary image for the text
text_img = Image.new('1', (text_width, text_height), 255) 
text_draw = ImageDraw.Draw(text_img)
text_draw.text((0, 0), text, font=font, fill=0)
# Rotate this text image to display it horizontally
rotated_text_img = text_img.rotate(90, expand=True)
# Center it on the screen
margin_left = (epd.width - text_height) // 2 #Top in landscape
margin_top = (epd.height - text_width) // 2 #Right in landscape
image.paste(rotated_text_img, (margin_left, margin_top))
# Display the image
epd.display(epd.getbuffer(image))
time.sleep(2)
# Put the display to sleep
epd.sleep()

Et voilà le résultat de ce script :

J’espère que c’est clair. La partie un peu délicate, c’est le calcul des marges selon la police et sa taille, mais vous pouvez zapper ça et utiliser des valeurs fixes obtenues par tâtonnement si vous affichez quelque chose de statique et prévisible.

Le reste des étapes est pratiquement identique à la version précédente : imports, initialisation, génération d’une image avec du texte, envoi à l’écran, puis mise en veille.

Aller plus loin avec l’écran e-ink

Je ne veux pas vous noyer dans des concepts complexes, mais j’ai passé du temps à trouver des fonctions utiles dont vous aurez probablement besoin pour vos projets.

Je les partage dans cette dernière section pour vous éviter de trop tâtonner. Prenez ce qui vous intéresse et essayez de l’intégrer dans vos projets.

Rafraîchissement partiel

Vous avez peut-être remarqué que chaque fois qu’on change le texte dans notre dernier exemple, l’écran clignote pendant quelques secondes. Donc, si vous essayez d’afficher une horloge avec une boucle Python, le résultat ne sera pas terrible.

Pour éviter ça, on peut demander à l’écran de faire un rafraîchissement partiel, en utilisant cette fonction à la place à la fin du script :
epd.displayPartial(epd.getbuffer(image))

Pour tester ça en affichant l’heure sur l’écran, voilà comment faire :

import time
from PIL import Image, ImageDraw, ImageFont
from waveshare_epd import epd2in13_V4
# Initialize the e-Paper display
epd = epd2in13_V4.EPD()
epd.init()
epd.Clear()
# Define font
try:
    font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', 20)
except:
    font = ImageFont.load_default()
# Create image
image = Image.new('1', (epd.width, epd.height), 255)
draw = ImageDraw.Draw(image)
try:
    while True:
        text = time.strftime("%H:%M:%S")
        # Clear the canvas
        draw.rectangle((0, 0, epd.width, epd.height), fill=255)
        # Draw text directly on the main image
        draw.text((5, 10), text, font=font, fill=0)
        # Display the image
        epd.displayPartial(epd.getbuffer(image))
        
        # Refresh every second or so
        time.sleep(1)
except KeyboardInterrupt:
    print("Stopping...")
    epd.init() 
    epd.Clear()
    epd.sleep()

En gros, la structure reste la même que dans notre exemple « Hello World », sauf qu’on utilise « displayPartial » à la place de « display ».

J’ai ajouté une boucle pour envoyer la mise à jour à intervalles réguliers et récupérer l’heure courante avec la fonction strftime(). J’ai aussi ajouté une structure try/except pour gérer un arrêt propre quand vous appuyez sur CTRL+C pour stopper le script Python (il effacera l’écran).

Créer un tableau de bord en temps réel

Une fois qu’on sait mettre du texte sur l’écran et le rafraîchir régulièrement, l’étape suivante, c’est probablement un tableau de bord affichant des données clés pour suivre l’état de vos projets ou de votre système.

Comme exemple, j’ai fait un test qui affiche la charge système en temps réel. Je vais vous montrer comment récupérer ces infos en Python et surtout comment afficher du texte sur plusieurs lignes.

Voilà le script complet, j’explique après :

import time
import os
import psutil #sudo apt install python3-psutil
from PIL import Image, ImageDraw, ImageFont
from waveshare_epd import epd2in13_V4
# Initialize
epd = epd2in13_V4.EPD()
epd.init()
epd.Clear()
time.sleep(1)
# Setup base image (Portrait for the hardware)
image = Image.new('1', (epd.width, epd.height), 255)
epd.displayPartial(epd.getbuffer(image)) # Show blank screen immediately
try:
    font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', 16)
except:
    font = ImageFont.load_default()
try:
    while True:
        # 1. Fetch Stats
        load_1, load_5, load_15 = os.getloadavg()
        ram = psutil.virtual_memory()
        
        # Format strings
        line1 = f"Load: {float(load_1):.2f}, {float(load_5):.2f}"
        line2 = f"RAM: {ram.percent}% used"
        line3 = time.strftime("%H:%M:%S")
        
        full_text = f"{line1}\n{line2}\n{line3}"
        # 2. Prepare Drawing
        draw = ImageDraw.Draw(image)
        draw.rectangle((0, 0, epd.width, epd.height), fill=255) # Clear frame
        # Use multiline_textbbox for multiple lines
        bbox = draw.multiline_textbbox((0, 0), full_text, font=font)
        tw, th = bbox[2], bbox[3]
        # 3. Create Sticker
        text_img = Image.new('1', (tw, th), 255)
        text_draw = ImageDraw.Draw(text_img)
        text_draw.multiline_text((0, 0), full_text, font=font, fill=0, align="center")
        
        # 4. Rotate and Paste
        rotated_text = text_img.rotate(90, expand=True)
        
        # Calculate margins for centering
        margin_left = (epd.width - th) // 2
        margin_top = (epd.height - tw) // 2
        image.paste(rotated_text, (margin_left, margin_top))
        # 5. Partial Update
        epd.displayPartial(epd.getbuffer(image))
        
        time.sleep(5) # Update every 5 seconds is plenty for a monitor
except KeyboardInterrupt:
    print("Stopping...")
    epd.init()
    epd.Clear()
    epd.sleep()

On s’appuie sur les scripts précédents, donc vous devriez déjà comprendre la majeure partie (les grandes étapes sont les mêmes, y compris la rotation et le calcul des marges).

Voilà les principaux changements :

• J’utilise les bibliothèques « psutil » et « os » pour récupérer la charge système (charge moyenne et utilisation de la RAM). Les valeurs sont stockées dans des variables spécifiques (load_1, ram, etc.).
• J’utilise 3 variables de texte, une par ligne, avec un libellé et la valeur récupérée à l’étape précédente. Si vous n’êtes pas familier avec la syntaxe utilisée pour intégrer ces variables, jetez un œil à Master Python on Raspberry Pi ou à de la documentation sur le sujet.
• Ensuite, je fusionne les trois lignes dans la variable full_text (séparées par des sauts de ligne avec « \n »).
• On utilise des fonctions comme multiline_text à la place de text. Elles fonctionnent pareil, mais pour plusieurs lignes de texte (d’où le nom !).

La fin du script est identique aux précédents. Si tout fonctionne comme prévu, vous devriez voir quelque chose comme ça :

Note : Si vous avez une erreur avec la bibliothèque psutil, il faut probablement l’installer, elle n’est pas préinstallée sur Raspberry Pi OS Lite :
sudo apt install python3-psutil

Afficher une image

Chose amusante, la chose la plus simple à faire avec ce type d’accessoire, c’est d’afficher une image sur l’écran.

Jusqu’ici, on créait une image avec les éléments voulus, puis on l’envoyait à l’écran. Et bien, si vous avez déjà une image dans un format compatible (comme PNG), vous pouvez l’envoyer directement.

Voilà un exemple simple :

from waveshare_epd import epd2in13_V4
from PIL import Image
# 1. Initialize
epd = epd2in13_V4.EPD()
epd.init()
epd.Clear()
# 2. Open the image
# It's best if the PNG is already 250x122 (landscape) or 122x250 (portrait)
img = Image.open('epaper.png')
# 3. Convert to 1-bit color (Black and White)
# '1' mode is required for the e-paper buffer
img = img.convert('1')
# 4. Handle Rotation (if needed)
img_rotated = img.rotate(90, expand=True)
# 5. Display
epd.display(epd.getbuffer(img_rotated))
# 6. Sleep
epd.sleep()

Simple, non ?

L’astuce, c’est d’utiliser une image à la bonne taille pour ne pas avoir à gérer le redimensionnement et le positionnement dans votre script.

Au passage, si vous savez déjà générer des images « dynamiques » en Python avec d’autres bibliothèques, il peut être plus simple de créer un fichier PNG temporaire et de l’envoyer à l’écran de cette façon à chaque fois.

Afficher plusieurs éléments sur l’écran

La dernière étape (ou du moins là où je me suis arrêté), c’est de mélanger différents éléments sur le même écran. Pour un badge, par exemple, vous aurez le logo de l’entreprise (image), le nom (texte), et peut-être même des éléments dynamiques.

Pour faire quelque chose comme ça, on ajoute les éléments au canvas principal les uns après les autres, comme ceci :

import time
from PIL import Image, ImageDraw, ImageFont
from waveshare_epd import epd2in13_V4
epd = epd2in13_V4.EPD()
epd.init()
# 1. Create the main canvas
canvas = Image.new('1', (epd.height, epd.width), 255) 
draw = ImageDraw.Draw(canvas)
# 2. Add the image (Logo/Icon)
icon = Image.open('epaper.png').convert('1')
canvas.paste(icon, (-10, -20)) 
# 3. Add the text
try:
    font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', 20)
except:
    font = ImageFont.load_default()
text = "Patrick FROMAGET"
bbox = font.getbbox(text)
tw, th = bbox[2], bbox[3]
# Adjust margins and positions
text_x = (epd.height - tw) // 2
text_y = 90
draw.text((text_x, text_y), text, font=font, fill=0)
# 4. Final rotation & display
final_image = canvas.rotate(90, expand=True)
epd.displayPartial(epd.getbuffer(final_image))
epd.sleep()

Rien de nouveau dans ce script. On réutilise les mêmes fonctions, mais on ajoute des éléments au canvas deux fois (et vous pouvez en ajouter autant que nécessaire). J’ai utilisé « displayPartial » au cas où vous ajoutez des éléments dynamiques, mais pour un badge simple, utilisez « display ».

Si vous avez suivi tous les exemples, vous devriez vous sentir bien plus à l’aise maintenant. N’hésitez pas à partager ce que vous avez fait et à me dire si vous avez trouvé des optimisations pour mes exemples. Comme je l’ai dit en intro, je suis loin d’être un expert sur ce sujet.

Pour info, vous trouverez la documentation Waveshare ici, et quelques exemples sur leur GitHub. J’ai été un peu déçu de voir que ce n’était pas aussi bien documenté que je l’aurais espéré pour quelque chose d’aussi populaire, donc j’espère que cet article vous a aidé à démarrer.

Ressources supplémentaires pour votre Raspberry Pi

Initiation au Raspberry Pi en vidéo
Si vous débutez et voulez passer rapidement à la vitesse supérieure, j’ai exactement ce qu’il vous faut.
Regardez ma formation vidéo qui vous aidera à démarrer du bon bien, choisir votre matériel, installer les meilleures applications et vous lancer directement dans vos premiers projets avec mon aide.
Regarder les vidéos dès maintenant

Maîtrisez votre Raspberry Pi en 30 jours
Vous avez besoin de plus ? Si vous êtes à la recherche des meilleures astuces pour devenir expert sur Raspberry Pi, ce livre est fait pour vous. Développez vos compétences sous Linux et pratiquez via de nombreux projets en suivant mes guides étape par étape. 10% de remise aujourd’hui !
Télécharger le livre au format PDF ici

Maîtrisez Python sur Raspberry Pi
Pas besoin d’être un génie pour coder quelques lignes pour votre Raspberry Pi.
Je vous apprends juste ce qu’il faut sur Python afin de réaliser n’importe quel projet. La seconde partie du livre est d’ailleurs consacrée à des exemples de projets où je vous guide pas à pas.
Ne perdez pas de temps, apprenez le strict nécessaire et économisez 10% avec ce lien :
Télécharger maintenant

Autres ressources pour profiter de votre Raspberry Pi
J’ai regroupé toutes mes recommandations de logiciels, sites utiles et de matériel sur cette page de ressources. Je vous invite à la consulter régulièrement pour faire les bons choix et rester à jour.
Visiter les pages ressources