Le pcDuino : Programmer les broches E/S du ... - Mon Club-Elec

Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en
utilisant les instructions Arduino !
Par X. HINAULT – Juin 2013– MAJ : Juin 2013 – www.mon-club-elec.fr
Intro
• Vous devez avoir très envie de tester (enfin!) la programmation des broches numériques E/S de votre pcDuino. C'est ce que nous allons faire ici.
• Je rappelle ici les caractéristiques des broches E/S numériques et analogiques du pcDuino :
◦ GPIO : 18 E/S en 3.3V – Topographie « Arduino-like »
◦ Entrées Analogiques : 2 x 6 bits en 0-2V et 4 x 12 bits en 0-3.3V
◦ Sorties analogiques : 6 x PWM (2 broches « fast » en 520Hz – 8 bits et 4 broches « slow » en 5Hz – 20 niveaux)
◦ Comm. Sérielles : I2C, SPI, UART
• Comme déjà dit, on retrouve la plupart des possibilités de l'Arduino à quelques adaptation près. Nous allons commencer par utiliser les broches E/S
numériques, le plus simple.
Pré-requis
• Je suppose ici que vous avez installé l'éditeur de code Geany et de vous connaissez les rudiments de Python, ainsi que le langage Arduino, bien sûr !
• Si ce n'est pas le cas, voir le tuto précédent.
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 1 / 27

Matériel nécessaire :
◦ une plaque d'essai (ou bread board)
◦ des straps (ou jumpers) mâles/femelles simples
◦ quelques composants de base, notamment :
▪ LEDs et résistances de 270 Ohms, (qui fera l'affaire bien que l'on soit en 3.3V, car on veut le minimum d'intensité ici...)
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 2 / 27

Le brochage du pcDuino
• Le brochage est vraiment semblable à celui de l'Arduino sauf pour :
◦ les E/S 14 à 17 qui sont sur bornier séparé
◦ SCL et SDA qui ne sont pas sur A4 et A5 mais séparées (peuvent être mises sur A4/A5 par soudure d'un pont, mais on doit perdre analogique dans ce
cas)
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 3 / 27

Faire des montages avec le pcDuino
• Il suffit d'utiliser une plaque d'essai et des straps femelle (côté pcDuino) /mâle (côté plaque d'essai)
• Utiliser le 3.3V et le 0V pour alimenter la plaque d'essai (et non le 5V..)
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 4 / 27

Le bornier d'alimentation
• Pour info, le bornier d'alimentation est le suivant, comme sur l'Arduino, à la différence près que Vin est connecté au 5V de l'alimentation (n'allez pas y
connecter du 12V!!) :
Vue de dessus
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 5 / 27

Programmer les broches E/S numériques en sortie
Où sont-elles ?
Caractéristiques électriques
• Ces broches fonctionnent en 3,3V ( et pas en 5V) en ne peuvent fournir que quelques mA... donc attention, prudence... !
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 6 / 27

Montage de test
Principe d'accès aux broches E/S
Tout est fichier...
• Comme déjà dit précédemment, les broches E/S sont gérées par de simples fichiers (c'est un principe général sous Gnu/Linux...). Le fichier de chaque
broche est de la forme gpioX où X est le numéro de la broche.
◦ les fichiers fixant le mode entrée ou sortie sont placés dans le répertoire :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 7 / 27

sys/devices/virtual/misc/gpio/mode/
◦ les fichiers contenant/définissant l'état des broches sont placés dans le répertoire :
/sys/devices/virtual/misc/gpio/pin/
• Ceci est facile à vérifier : ouvrir un terminal sur le pcDuino et saisir :
$ cd /sys/devices/virtual/misc/gpio/mode/
$ ls
ce qui donne :
• de la même façon, on peut vérifier l'existence des fichiers d'état des broches :
$ cd /sys/devices/virtual/misc/gpio/pin/
$ ls
ce qui donne :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 8 / 27

Fixer le sens d'une broche :
La version « brute »
Ouvrir l'éditeur Geany et copier/coller ce code d'entête :
#!/usr/bin/python
# -*- coding: utf-8 -*-
On commence par définir le chemin utile dans une variable texte :
pathMode= "/sys/devices/virtual/misc/gpio/mode/"
Pour fixer le sens d'une broche, c'est simple : il suffit d'ouvrir le fichier et d'écrire dedans la valeur voulue :
• ‘0’ pour la broche en entrée = INPUT
• ‘1’ pour la broche en sortie = OUTPUT
• ‘8’ pour la broche en entrée avec rappel au plus activé (pour les boutons poussoirs)
On pourra ainsi définir les variables correspondantes sous forme de chaînes :
INPUT="0"
OUTPUT="1"
PULLUP="8"
Ensuite, il suffit d'écrire dans le fichier gpio2 pour fixer le sens de la broche 2 selon :
# fixe l'état de la broche
file=open(pathMode+"gpio2",'w') # ouvre le fichier en écriture
file.write(OUTPUT)
file.close()
Voici le code complet à copier/coller dans Geany côté pcDuino :
#!/usr/bin/python
# -*- coding: utf-8 -*-
# -- déclarations --
pathMode="/sys/devices/virtual/misc/gpio/mode/"
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 9 / 27

pathState="/sys/devices/virtual/misc/gpio/pin/"
INPUT="0"
OUTPUT="1"
PULLUP="8"
# fixe l'état de la broche
file=open(pathMode+"gpio2",'w') # ouvre le fichier en écriture
file.write(OUTPUT)
file.close()
Lancer l'exécution :
On obtient une fenêtre de console vide : il ne se passe rien, mais votre programme ne produit pas d'erreur.
La version « Arduino-like »
• OK, là je vous vois faire de grands yeux... A ce jeu là, çà va vite devenir compliqué... envie de simplement coder pinMode(broche, sens) ? J'ai la solution...
J'ai écrit la librairie Python qui va bien et qui fait le job...
Installer la librairie Pyduino
• La librairie, qui est en fait un simple fichier, est ici : https://github.com/sensor56/pyDuino/blob/master/pcduino/arduino.py
En tant que module Python : la meilleure solution
• Première solution, la meilleure : installer la librairie en tant que module Python, ce qui se fait en 2 lignes de commandes simples :
$ cd /usr/lib/python2.7/dist-packages
$ sudo wget -N https://raw.github.com/sensor56/pyDuino/master/pcduino/pyduino.py
Ou copier la librairie Pyduino dans le répertoire de vos scripts Python
• Seconde solution : Copier/coller simplement ce fichier dans le répertoire de vos scripts Python en l'enregistrant sous le nom arduino.py. En ligne de
commande, dans un terminal sur le pcduino, çà donne :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 10 /
27

$ mkdir scripts_python
$ cd scripts_python
$ wget https://raw.github.com/sensor56/pyDuino/master/pcduino/arduino.py
• Le fichier doit être présent de la sorte :
En savoir plus
• Plus de détails sur la procédure d'installation ici : http://www.mon-club-elec.fr/pmwiki_reference_pyduino/pmwiki.php?n=Main.DebuterInstallation
Le code minimum
• Voilà, une fois fait, vous allez retomber sur vos pieds : commencer par saisir le code minimum suivant :
#!/usr/bin/python
# -*- coding: utf-8 -*-
# exemple pyDuino - par X. HINAULT
# code minimal
from arduino import * # importe les fonctions Arduino pour Python
# entete declarative
#--- setup ---
def setup():
return
# -- fin setup --
# -- loop --
def loop():
return
# -- fin loop --
#--- obligatoire pour lancement du code --
if __name__=="__main__": # pour rendre le code executable
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 11 /
27

setup() # appelle la fonction setup
while(1): loop() # appelle fonction loop sans fin
• Remarquer la structure du code :
Code final
◦ une entête obligatoire dans un code Python
◦ la ligne d'importation du fichier arduino.py
◦ la fonction setup et la fonction loop : noter ici la présence de l'instruction return qui sert uniquement à ne pas laisser la fonction vide...
◦ une section finale obligatoire dans tout code Python exécutable et ici complétée pour l'exécution des fonctions setup() et loop() à la façon Arduino.
Gardez ce code sous le coude : vous pourrez démarrer tous vos nouveaux codes avec. Il est ici :
https://github.com/sensor56/pyDuino/blob/master/pcduino/exemples/1.Basics/BareMinimum.py
• Du coup, notre programme devient assez semblable à ce que vous feriez dans l'IDE Arduino (avec la syntaxe Python cependant... plus simple en fait... ) :
#!/usr/bin/python
# -*- coding: utf-8 -*-
# exemple pyDuino - par X. HINAULT - www.mon-club-elec.fr
# voir : https://github.com/sensor56/pyDuino
# test pinMode
from pyduino import * # importe les fonctions Arduino pour Python
# entete declarative
#--- setup ---
def setup():
pinMode(2,OUTPUT) # met la broche en sortie
Serial.println("La broche 2 est en sortie !")
# -- fin setup --
# -- loop --
def loop():
return
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 12 /
27

# -- fin loop --
#--- obligatoire pour lancement du code --
if __name__=="__main__": # pour rendre le code executable
setup() # appelle la fonction setup
while(1): loop() # appelle fonction loop sans fin
Lancer l'exécution :
On obtient :
• Cool non ? Bon ben le plus dur est fait... Les bases sont posées ! Allez, on continue.
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 13 /
27

Allumer une LED
Version « brute »
Pour allumer une LED il faut écrire la valeur voulue dans le fichier gpioX du répertoire /../pin/ présenté ci-dessus :
• « 0 » pour mettre au niveau bas = LOW
• « 1 » pour mettre au niveau haut = HIGH
Pour allumer la LED sur la broche 2 , il suffit alors, une fois la broche en sortie, d'écrire la valeur 1 dans le fichier gpio2 :
# allume la LED
file=open(pathState+"gpio2",'w') # ouvre le fichier en lecture
file.write(HIGH)
file.close()
On obtient le code complet suivant :
#!/usr/bin/python
# -*- coding: utf-8 -*-
import time
# -- déclarations --
pathMode="/sys/devices/virtual/misc/gpio/mode/"
pathState="/sys/devices/virtual/misc/gpio/pin/"
INPUT="0"
OUTPUT="1"
PULLUP="8"
HIGH = "1"
LOW = "0"
# fixe l'état de la broche
file=open(pathMode+"gpio2",'w') # ouvre le fichier en écriture
file.write(OUTPUT)
file.close()
# allume la LED
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 14 /
27

file=open(pathState+"gpio2",'w') # ouvre le fichier en écriture
file.write(HIGH)
file.close()
Lancer l'exécution :
On obtient la LED allumée. Cool.
Version « Arduino-like »
Vous risquez de préférer une nouvelle fois l'utilisation de la version « Arduino-like » : je suppose ici que vous avez enregistré une copie de ma librairie des
instructions pour Python, arduino.py, que j'ai présenté précédemment, dans le répertoire de vos scripts Python. La librairie, qui est en fait un simple fichier, est ici :
https://github.com/sensor56/pyDuino/blob/master/pcduino/arduino.py
La procédure d'installation complète de la librairie Pyduino est décrite ci-dessus et ici : http://www.mon-club-elec.fr/pmwiki_reference_pyduino/pmwiki.php?
n=Main.DebuterInstallation
Pour allumer la LED, on va faire tout ce qu'il y a de plus classique en langage Arduino :
#!/usr/bin/python
# -*- coding: utf-8 -*-
# exemple Pyduino - par X. HINAULT - www.mon-club-elec.fr
# voir : https://github.com/sensor56/pyDuino
# test digitalWrite
from pyduino import * # importe les fonctions Arduino pour Python
# entete declarative
LED=2 # declare la broche a utiliser
#--- setup ---
def setup():
pinMode(LED,OUTPUT) # met la broche en sortie
Serial.println("La broche 2 est en sortie !")
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 15 /
27

digitalWrite(LED,HIGH) # allume la LED
Serial.println("La LED est allumée !")
# -- fin setup --
# -- loop --
def loop():
return
# -- fin loop --
#--- obligatoire pour lancement du code --
if __name__=="__main__": # pour rendre le code executable
setup() # appelle la fonction setup
while(1): loop() # appelle fonction loop sans fin
Lancer l'exécution :
On obtient :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 16 /
27

Capture VNC du bureau du pcDuino qui « voit » la LED grâce à une webcam... Cool non ?
• On a le message dans le Terminal comme on l'aurait avec le terminal Série d'Arduino (ici c'est une émulation de Terminal série en fait, car tout se passe du
côté du pcDuino...) et surtout notre LED s'allume...
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 17 /
27

Faire clignoter une LED
Version « brute »
A présent, nous allons successivement mettre la LED au niveau HAUT, patienter 1 seconde, la mettre au niveau BAS, patienter un seconde et ainsi de suite.
Pour réaliser une boucle sans fin, il suffit d'utiliser l'instruction while(1). Pour réaliser une pause, il suffit d'utiliser la fonction sleep() du module time.
On obtient donc le code Python suivant :
#!/usr/bin/python
# -*- coding: utf-8 -*-
import time
# -- déclarations --
pathMode="/sys/devices/virtual/misc/gpio/mode/"
pathState="/sys/devices/virtual/misc/gpio/pin/"
INPUT="0"
OUTPUT="1"
PULLUP="8"
HIGH = "1"
LOW = "0"
#--- setup ---
# fixe l'état de la broche
file=open(pathMode+"gpio2",'w') # ouvre le fichier en écriture
file.write(OUTPUT)
file.close()
# -- loop --
while(1): # boucle sans fin
# allume la LED
file=open(pathState+"gpio2",'w') # ouvre le fichier en écriture
file.write(HIGH)
file.close()
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 18 /
27

time.sleep(1) # pause en secondes
# allume la LED
file=open(pathState+"gpio2",'w') # ouvre le fichier en lecture
file.write(LOW)
file.close()
time.sleep(1) # pause en secondes
# fin while
Version « Arduino-like »
Bien, bien... comme çà vous voyez comment on fait en Python « brut »... Mais encore une fois, voici la version « Arduino-like » avec instruction delay() et tout et
tout... Je suppose toujours ici que vous avez le fichier de ma lib' Python dans le même répertoire que votre script... Je le redis, au cas où...
La procédure d'installation complète de la librairie Pyduino est décrite ci-dessus et ici : http://www.mon-club-elec.fr/pmwiki_reference_pyduino/pmwiki.php?
n=Main.DebuterInstallation
Côté code, encore une fois, tout ce qu'il y a de plus classique : digitalWrite.. delay... digitalWrite... delay... ce qui nous donne :
#!/usr/bin/python
# -*- coding: utf-8 -*-
# exemple pyDuino - par X. HINAULT - www.mon-club-elec.fr
# voir : https://github.com/sensor56/pyDuino
# LED clignote
from pyduino import * # importe les fonctions Arduino pour Python
# entete declarative
LED=2 # declare la broche a utiliser
#--- setup ---
def setup():
pinMode(LED,OUTPUT) # met la broche en sortie
Serial.println("La broche " +str(LED)+ " est en sortie !")
# -- fin setup --
# -- loop --
def loop():
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 19 /
27

digitalWrite(LED,HIGH) # allume la LED
Serial.println("La LED est allumée !")
delay(1000) # pause en millisecondes
digitalWrite(LED,LOW) # eteint la LED
Serial.println("La LED est éteinte !")
delay(1000) # pause en millisecondes
# -- fin loop --
#--- obligatoire pour lancement du code --
if __name__=="__main__": # pour rendre le code executable
setup() # appelle la fonction setup
while(1): loop() # appelle fonction loop sans fin
Ce code est ici : https://github.com/sensor56/pyDuino/blob/master/pcduino/exemples/1.Basics/Blink.py
En ligne de commande faire sur le pcduino :
$ cd scripts_python
$ wget https://raw.github.com/sensor56/pyDuino/master/pcduino/exemples/1.Basics/Blink.py
Lancer l'exécution :
On obtient :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 20 /
27

• Je sais pas pour vous, mais moi çà m'éclate ce truc : je code sur un PC en Python et j'ai l'impression de faire du « vrai » Arduino... Là, je suis content de
mon coup ! Pas mal ma petite lib'... bon, faut encore que je l'enrichisse , mais les bases sont posées...
• Tiens, un petit test pour la forme : à quelle vitesse maximum il peut le faire le pcDuino (clignoter la LED...) ?? Allez, j'enlève les delay et je branche
l'oscillo :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 21 /
27

• Je trouve 90µs pour chaque « écriture » en mémoire NAND soit donc 180µs de période minimale (écriture x2 ) soit 5555 Hz et des poussières...
Donc on va dire que c'est correct pour un système Gnu/Linux qui fait de l'accès « hardware »... en tout cas largement satisfaisant pour la plupart des besoins
usuels...
Comment exécuter un programme de façon autonome ?
• Problème : quand je stoppe ferme la fenêtre Terminal de Geany, mon programme arrêt de fonctionner ! Comment faire pour l'exécuter de façon autonome ?
Les choses sont assez simple comme vous allez le voir.
• Une fois que vous avez enregistrer votre fichier, il faut le rendre exécutable :
◦ ouvrez le répertoire où il se trouve et faîtes un clic droit dessus et sélectionner l'option propriétés ou Properties :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 22 /
27

◦ dans la fenêtre qui s'ouvre, aller dans l'onglet « permissions » et cocher la case « Rendre le fichier exécutable » ou « make the file executable » :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 23 /
27

• Ensuite validez. A présent pour exécuter votre code, vous pouvez simplement double cliquer dessus : vous obtenez alors cette fenêtre :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 24 /
27

• Cliquer sur Executer : votre code est lancé et ne ne s'arrêtera plus jusqu'à nouvel ordre ou extinction du mini-PC.
• Pour stopper le programme, saisir la commande dans un Terminal :
$ killall nomCode.py
soit dans mon cas :
$ killall Blink.py
• Il est également possible de lancer un programme en ligne de commande :
$ cd chemin/repertoire
$ ./nomprog
ce qui dans mon cas donne :
$ cd scripts_python
$ ./Blink.py
Cette façon de faire est intéressante car vous obtenez les messages dans le Terminal :
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 25 /
27

Remarque : il est possible de cette façon d'exécuter plusieurs codes Python en même temps contrôlant les broches E/S, indépendants les uns des
autres !! Il faut simplement qu'il n'utilisent pas les mêmes ressources pour éviter les problèmes.
• Il est également possible de créer un lanceur sur le bureau pour lancer directement l'application...
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 26 /
27

Comment lancer un programme Pyduino ou Python automatiquement au démarrage ?
• Il est enfin possible de lancer le programme voulu automatiquement au lancement du mini-PC : imaginons que l'on veuille lancer au démarrage notre script
Blink.py... On commencer par éditer le fichier d'autostart de Lubuntu, à savoir :
$ sudo geany /etc/xdg/lxsession/Lubuntu/autostart
Pour info :
$ sudo geany /etc/xdg/lxsession/LXDE/autostart (sur le RaspbderryPi sous Raspbian)
• Ensuite, on ajoute la ligne à ce fichier :
@python /home/user/scripts_python/Blink.py
• Redémarrer : la LED doit clignoter au démarrage suivant !
Conclusion
• Voilà, vous savez utiliser les broches du pcDuino à la façon Arduino... tout en codant en Python ! Cool non ? Allez, on continue : les broches numériques en
entrée et l'utilisation du bouton poussoir avec le pcDuino, c'est dans le prochain tuto...
Liens utiles
• https://learn.sparkfun.com/tutorials/programming-the-pcduino/your-first-program
Le pcDuino : Programmer les broches E/S du pcDuino en sortie avec Python tout en utilisant les instructions Arduino ! - Par X. HINAULT – Juin 2013 – www.mon-club-elec.fr – p. 27 /
27