29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 1 :
Ligne 1 : − + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aucun résumé de modification
{{RASP-PiOLED-NAV}}
{{RASP-PiOLED-NAV}}
{{traduction}}
== Introduction ==
Nous allons utiliser Python pour contrôler l'afficheur. En théorie, vous pouvez utiliser n'importe quel langage offrant un accès au bus I2C de l'ordinateur mais Adafruit ne fournit qu'une bibliothèque Python!
{{ambox-stop|text=Ce guide par du principe que vous disposez d'un Raspberry-Pi avec un système d'exploitation configuré, une connectivité réseau et SSH!}}
== Etape 1. Les dépendances ==
Avant d'utiliser la bibliothèque Adafruit, vous devez vous assurer d'avoir les différentes dépendances installées. [[PI-SSH|Connectez vous en SSH sur votre Pi]] et suivez les étapes suivantes:
Installer la bibliothèque RPi.GPIO en exécutant la ligne de commande:
<syntaxhighlight lang="bash">
sudo apt-get update
sudo apt-get install build-essential python-dev python-pip
sudo pip install RPi.GPIO
</syntaxhighlight>
Pour finir, installer la [http://effbot.org/imagingbook/pil-index.htm bibliothèque Python Imaging Library (PIL)] et bibliothèque smbus en exécutant :
<syntaxhighlight lang="bash">
sudo apt-get install python-imaging python-smbus
</syntaxhighlight>
Vous pouvez maintenant instlaller la dernière version de la bibliothèque Python SSD1306 d'Adafruit (et les exemples). Exécutez les commandes suivantes:
<syntaxhighlight lang="bash">
sudo apt-get install git
git clone https://github.com/adafruit/Adafruit_Python_SSD1306.git
cd Adafruit_Python_SSD1306
sudo python setup.py install
</syntaxhighlight>
{{ADFImage|RASP-PiOLED-Utiliser-01.png|640px}}
== Etape 2. Activer I2C ==
[[Rasp-Hack-GPIO_Configurer_I2C|Suivez ce guide pour activer le support I2C]] sur votre Raspberry-Pi.
Après avoir activer le support I2C, il sera nécessaire d'arrêter le Pi à l'aide de la commande {{fname|sudo halt}}.
Une fois à l'arrêt, branchez le PiOled puis remettez le Pi sous tension.
Connectez vous à nouveau sur votre Pi et exécutez la commande suivante dans un terminal pour scanner et détecter les périphériques I2C.
<syntaxhighlight lang="bash">
sudo i2cdetect -y 1
</syntaxhighlight>
Vous devriez voir le résultat suivant indiquant que l'adresse '''0x3c''' (l'afficheur OLED) à été trouvé.
{{ADFImage|RASP-PiOLED-Utiliser-02.png|640px}}
== Etape 3. Vérifier le périphérique I2C ==
Une dois dans le répertoire '''Adafruit_Python_SSD1306''', vous pouvez exécuter l'exemple stats d'Adafruit. Cet exemple extrait des données statistiques sur la charge CPU du Pi, l'espace disque, etc -ET- affiche ces informations sur l'OLED.
Exécutez {{fname|sudo python examples/stats.py}} pour démarrer la démo, vous devriez vois quelque-chose comme ceci:
{{ADFImage|RASP-PiOLED-Utiliser-03.png|640px}}
{{ADFImage|RASP-PiOLED-Utiliser-04.jpg|640px}}
== Démarrer stats.py au Boot ==
=== Raspbian Wheezy - avant SystemD ===
Il est très facile de démarrer le script à chaque au boot du Raspberry-Pi.
L'approche la plus simple est de le mettre dans '''/etc/rc.local'''
Exécuté {{fname|'''sudo nano /etc/rc.local'''}} et ajouter la ligne
<syntaxhighlight lang="bash">
sudo python /home/pi/Adafruit_Python_SSD1306/examples/stats.py &
</syntaxhighlight>
'''juste avant le {{fname|exit 0}}'''
Puis sauver et quitter l'éditeur nano. Redémarrer le Pi afin de voir si l'information apparaît à l'écran!
{{ADFImage|RASP-PiOLED-Utiliser-05.png|640px}}
=== Raspbian Jessy - avec SystemD ===
Sur base des informations ci-dessus, vous pouvez adapter le démarrage pour SystemD.
Nous avons un tutoriel dévolu au démarrage de script Python avec SystemD.
{{ttuto-begin}}
{{ttuto
|label=Démarrage automatique
|descr=Démarrer automatiquement un script Python sous Raspbian.
|img=tlogo-autostart-script.jpg
|link=Rasp-AutoStart-Script
}}
{{ttuto-end}}
== Utilisation de la bibliothèque ==
Vous trouverez des scripts python d'exemple dans le sous répertoire {{fname|examples}} qui montre comment utiliser la bibliothèque. Adafruit [https://learn.adafruit.com/ssd1306-oled-displays-with-raspberry-pi-and-beaglebone-black/ Ce guide OLED d'Adafruit (''anglais'') couvre plus de détails concernant l'utilisation des afficheurs], n'hésitez pas à le consulter.
Pour débuter plus facilement, nous allons réviser le code de {{fname|stats.py}}. De sorte, vous pourrez utiliser ce script comme base de départ pour vos propres projets.
<syntaxhighlight lang="python">
import time
import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import subprocess
</syntaxhighlight>
Nous commençons par importer quelques modules, y compris le module '''Adafruit_SSD1306''' qui contient le pilote de l'afficheur OLED.
Vous pouvez également noter l'importation de quelques éléments de la bibliothèque'' '''P'''ython '''I'''maging '''L'''ibrary'' comme '''Image''', '''ImageDraw''' et '''ImageFont'''. Comme vous pouvez l'imaginer, ces éléments servirons a dessiner des images, des formes et du texte/font!
Ci dessous les différentes valeurs de configuration et classe pour les afficheurs OLED. Il y a 4 variantes d'afficheur OLED, avec 128x32 pixels ou 128x64 pixels -ET- avec I2C ou avec SPI.
<syntaxhighlight lang="python">
# Commentaire traduis par Meurisse D. pour faciliter la compréhension du code.
# -- shop.mchobby.be --
# Configuration des broches du Raspberry Pi:
RST = None
# Note: uniquement utilisé avec bus SPI:
DC = 23
SPI_PORT = 0
SPI_DEVICE = 0
# Afficheur 128x32 sur bus I2C matériel:
disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
# Afficheur 128x64 sur bus I2C matériel:
# disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)
# Alternativement, vous pouvez spécifier le n° de bus I2C, par exemple
# avec l'afficheur 128x32, vous pouvez utiliser:
# disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, i2c_bus=2)
# Afficheur 128x32 avec bus SPI matériel:
# disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=8000000))
# Afficheur 128x64 avec bus SPI matériel:
# disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=8000000))
# Vous pouvez également spécifier un SPI logiciel en fournissant
# les numéros de broches GPIO digital (pour toutes les broches
# utilisées par l'afficheur). Par exemple:
# Sur un Raspberry Pi avec afficher 128x32 vous pourriez utiliser:
# disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, dc=DC, sclk=18, din=25, cs=22)
</syntaxhighlight>
Etant donné que l'afficheur PiOLED est un afficheur OLED 128x32 sur bus (uniquement), vous devez uniquement utiliser le code:
<syntaxhighlight lang="python">
# afficheur 128x32 avec bus I2C matériel:
disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
</syntaxhighlight>
Le restant du code peut rester en commentaire.
Notez que ci-dessus, nous avons initialisé {{fname|1=RST = None}} parce que le PiOLED ne nécessite pas l'utilisation de la broche "reset".
<syntaxhighlight lang="python">
# initialiser la bibliothèque d'affichage.
disp.begin()
# Effacer l'affichage.
disp.clear()
disp.display()
# Créer une image vierge pour dessiner dessus.
# L'image doit être créé avec mode '1' (couleur 1-bit).
width = disp.width
height = disp.height
image = Image.new('1', (width, height))
# Obtenir un objet ImageDraw (dessiner sur l'image)
# pour l'image.
draw = ImageDraw.Draw(image)
# Dessiner un rectangle noir (rempli) pour effacer
# le fond de l'image (sinon cela allumera les Pixels).
draw.rectangle((0,0,width,height), outline=0, fill=0)
</syntaxhighlight>
La portion de code ci-dessus, initialise la bibliothèque d'affichage avec {{fname|begin()}} et efface le contenu avec {{fname|clear()}} et {{fname|display()}} .
Ensuite, nous configurons une classe PIL drawing pour dessiner des graphiques. La mémoire tampon de l'image est crée avec un bit de profondeur (mode avec paramètre {{fname|'1'}}. Ce mode est important puisque l'afficheur ne propose que deux couleurs noir et blanc.
Ensuite nous redessinons un grand rectangle noir pour effacer effacer le contenu de l'écran (éteindre tous les pixels). En théorie, il n'est pas nécessaire d'effacer une seconde fois l'écran... mais c'est toujours un bonne idée de savoir comment dessiner une forme!
<syntaxhighlight lang="python">
# Charger la font par défaut.
font = ImageFont.load_default()
# Chargement d'une autre font TTF.
# D'autres fonts sont disponibles sur: http://www.dafont.com/bitmap.php
#font = ImageFont.truetype('Minecraftia.ttf', 8)
</syntaxhighlight>
Une fois l'afficheur initialisé et un objet dessin (ImageDrawing) préparé, vous pouvez dessiner des formes, du texte et des graphiques en utilisant [http://effbot.org/imagingbook/imagedraw.htm des commandes de dessin PIL] (''effbot.org, anglais''). Dans le cas présent, le code charge la font {{fname|par défaut}} qui est parfaite mais vous pouvez également charger d'autres fonts. Il es possible de charger des fonts TrueType et de les utiliser pour faire du rendu de texte de tout style
Une fois la font par défaut chargée, il est possible d'afficher quelques lignes de texte.
<syntaxhighlight lang="python">
while True:
# Afficher un rectangle noir pour effacer l'image de l'écran.
draw.rectangle((0,0,width,height), outline=0, fill=0)
# Script shell pour surveiller les paramètres système :
# https://unix.stackexchange.com/questions/119126/command-to-display-memory-usage-disk-usage-and-cpu-load
cmd = "hostname -I | cut -d\' \' -f1"
IP = subprocess.check_output(cmd, shell = True )
cmd = "top -bn1 | grep load | awk '{printf \"CPU Load: %.2f\", $(NF-2)}'"
CPU = subprocess.check_output(cmd, shell = True )
cmd = "free -m | awk 'NR==2{printf \"Mem: %s/%sMB %.2f%%\", $3,$2,$3*100/$2 }'"
MemUsage = subprocess.check_output(cmd, shell = True )
cmd = "df -h | awk '$NF==\"/\"{printf \"Disk: %d/%dGB %s\", $3,$2,$5}'"
Disk = subprocess.check_output(cmd, shell = True )
# Ecrire quatre lignes de texte
draw.text((x, top), "IP: " + str(IP), font=font, fill=255)
draw.text((x, top+8), str(CPU), font=font, fill=255)
draw.text((x, top+16), str(MemUsage), font=font, fill=255)
draw.text((x, top+25), str(Disk), font=font, fill=255)
# Afficher l'image sur l'écran
disp.image(image)
disp.display()
# pause de 100 millisecondes
time.sleep(.1)
</syntaxhighlight>
En utilisant la classe subprocess, python peut utiliser des commandes Linux pour accéder aux informations systèmes du Pi. La boucle {{fname|while}} effectue un rafraîchissement de l'écran 10 fois par seconde.
Voilà, c'est tout en ce qui concerne le code de '''stats.py''' !
== Plus d'exemples ==
Vous pouvez consulter les autres exemples du sous-répertoire {{fname|examples}}.
Assurez-vous d'éditer chacun des exemples (avec '''nano animate.py''' par exemple) et trouvez la ligne mentionnant:
<syntaxhighlight lang="python">
# Raspberry Pi pin configuration:
RST = 24
</syntaxhighlight>
et la changer en :
<syntaxhighlight lang="python">
# Raspberry Pi pin configuration:
RST = None # PiOLED n'a pas besoin de la broche Reset
</syntaxhighlight>
puis assurez vous que la configuration section utilise la déclaration correspond à votre afficheur PiOled... comme ceci:
<syntaxhighlight lang="python">
# 128x32 display with hardware I2C:
disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
# 128x64 display with hardware I2C:
# disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)
# 128x32 display with hardware SPI:
# disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_POR$
# 128x64 display with hardware SPI:
# disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_POR$
</syntaxhighlight>
Voila, le script d'exemple utilise maintenant un afficheur I2C 128x32 pixels (sans broche Reset)!
== Améliorer la vitesse de l'afficheur ==
Pour de meilleures performances, plus spécialement si vous avez besoin d'animation rapide, vous pouvez optimiser le fonctionnement du bus I2C pour qu'il fonctionne 1MHz. En effet, le bus est configuré à la fréquence 100KHz ou 400KHz
Pour modifier la vitesse du bus, éditez le fichier de configuration avec '''sudo nano /boot/config.txt'''
et ajoutez la ligne suivante à la fin du fichier
<syntaxhighlight lang="python">
dtparam=i2c_baudrate=1000000
</syntaxhighlight>
{{ADFImage|RASP-PiOLED-Utiliser-06.png|640px}}
Redémarrer le Pi pour appliquer les modifications.
{{RASP-PiOLED-TRAILER}}
{{RASP-PiOLED-TRAILER}}