PyDev, un IDE pour Python, sous Eclipse et pour le Raspberry Pi 3

Comme je l’ai dit, en décembre 2018, dans une interview pour le magazine Programmez, « Je ne suis pas allé à Python, c’est Python qui est venu à moi ». Je suis tout d’abord un fan et un passionné de Java, mais si, suivant les situations, je dois utiliser du C, du Perl, du C++, du PHP, du Python, voire du Ruby (adoré pour la génération de base de données), je le ferai. C’est pareil avec les outils. Netbeans a été mon outil favori pendant des années, surtout pour les applications Swing, avant de ne plus quitter Eclipse pour des applications embarquées.

En mars 2018, quand je me suis lancé dans mon livre consacré à Java pour le Raspberry Pi 3, Eclipse a été une nécessité pour moi et est donc présent dans les deux premiers chapitres de mon livre. Les exemples et nombreux exercices en Java de cet ouvrage, inclus dans des projets Eclipse, sont avant tout consacrés au port GPIO du Raspberry Pi et aux composants s’y attachant. Ces derniers sont souvent des capteurs qu’il faudra brancher correctement et vérifier. Nous les définirons avec des schémas Fritzing.

Connecter un capteur sur le port GPIO nécessite quelques connaissances et un peu de matériel. Mais avant de passer trop de temps et de se casser la tête avec un programme Java, il est pratique et d'une simplicité déroutante, d'utiliser un script Python pour vérifier notre capteur, et cela en utilisant les bibliothèques Python du Raspberry Pi dédiées au port GPIO.

Ayant découvert l’existence de PyDev, c'est devenu un exercice intéressant de rester avec Eclipse, aussi pour Python.

Cet article est destiné au programmeur Python développant des application pour le Raspberry Pi 3 et peut être considéré comme une extension de mon livre. Je ne suis moi-même pas un véritable programmeur Python et j'utilise ce dernier comme outil avant tout.

Une installation de Python sur le PC n’est pourtant pas vraiment nécessaire, car des scripts Python simples, juste pour vérifier les composants, peuvent être simplement préparés ou téléchargés sur le Raspberry Pi pour vérifier les composants montés sur nos planches à pain.

Cet article nous montre comment installer cet extension PyDev, un IDE Python pour Eclipse, sur un PC Windows, et y écrire une bibliothèque de simulation RPi.GPIO pour que le script Python blink2leds.py, montré ci-dessous, puisse être exécuté sur le PC qui n'a pas le GPIO hardware du Pi et avant le déploiement sur le Raspberry Pi.

Cet article ne décrira pas, par exemple, comment installer Eclipse, comment définir des schémas Fritzing, comment déterminer les broches du GPIO du Raspberry Pi, comment ajouter d’éventuelles résistances aux LED, comment télécharger les scripts sur le Pi ou simplement comment installer ou utiliser Raspbian, le Linux du Pi, et travailler avec les outils de ce dernier. Il y a suffisamment de références sur le Web (tous ces outils ou fonctions sont d’ailleurs décrits et expliqué dans mon livre) !

Nous commencerons par un script Python capable de faire clignoter deux LED.

Ce script est repris de mon livre et destiné à vérifier le circuit avant de passer à l'implémentation en Java de la même fonction.

Lorsque nous déposons des composants sur une platine d'expérimentation (breadboards) attachée au Raspberry Pi, il est souvent plus facile de commencer par définir quelles broches seront utilisées, voire même par utiliser un script Python bien documenté. Notepad++ (https://notepad-plus-plus.org/fr) est l'outil à favoriser pour l'écriture de tels scripts en dehors d'Eclipse. Il nous apporte aussi une jolie présentation colorée qui va nous plaire immédiatement. Dans ce cas, il faudra évidemment installer le binaire de l’interpréteur Python, version 2 ou 3.

Voici donc le code présenté suivi d’une description rapide, mais suffisante.

# coding: utf-8

import RPi.GPIO as GPIO
import time

LedPin1 = 12   # pin12 (Pi4J GPIO_01)
LedPin2 = 15   # pin15 (Pi4J GPIO_03)
               # pin3 la terre 

def setup():
  print("Les deux leds vont clignoter")
  
  GPIO.setmode(GPIO.BOARD)       # Numéro GPIO par location physique
  GPIO.setup(LedPin1, GPIO.OUT)  # LedPin1 en mode output
  GPIO.setup(LedPin2, GPIO.OUT)  # LedPin2 en mode output
  
def blink():
  i = 0
  while i < 15:  # Pour 15 sec
    GPIO.output(LedPin1, GPIO.HIGH) # Allume la led 1
    GPIO.output(LedPin2, GPIO.HIGH) # Allume la led 2
    time.sleep(.5)
    GPIO.output(LedPin1, GPIO.LOW)  # Eteint la led 1
    GPIO.output(LedPin2, GPIO.LOW)  # Eteint la led 2
    time.sleep(.5)
    i += 1
    
  print("Une seule led va clignoter plus lentement")

  while True: # Pour une boucle sans fin
    GPIO.output(LedPin2, GPIO.HIGH) # Allume la led
    time.sleep(1)
    GPIO.output(LedPin2, GPIO.LOW)  # Eteint la led
    time.sleep(1)
    
def destroy():
  GPIO.output(LedPin1, GPIO.LOW)   # Led éteinte
  GPIO.output(LedPin2, GPIO.LOW)   # Led éteinte
  GPIO.cleanup()                   # Ressources liberées
  
if __name__ == '__main__':   # Démarrage en Python
  setup()
  try:
    blink()
  except KeyboardInterrupt:  # Interruption avec 'Ctrl+C'
    destroy()

Le nom du script est tout de même plus simple en anglais qu'un "clignote_deux_leds". Les instructions du langage sont d'ailleurs en anglais de toute manière.

Pour les lecteurs qui n'ont jamais programmé en Python, ils s'en sortiront rapidement :

• tout d'abord deux imports sont nécessaires pour les fonctions GPIO du Raspberry Pi et la fonction sleep(), pause en secondes ;
• nous comprendrons rapidement la définition des broches (pins) avec le schéma Fritzing qui va suivre et le mode GPIO.BOARD utilisé avec la fonction setmode() ;
• le démarrage du script se fait en fin de script en commençant par setup() qui va nous définir nos deux broches en sortie (GPIO.OUT) ;
• la fonction blink(), un clignotement, va commencer par une boucle où les deux LED seront allumées (GPIO.HIGH) et éteintes (GPIO.LOW) chaque demi-seconde et 15 fois de suite.
  La dernière boucle sera éternelle, mais uniquement pour la seconde LED ;
• un Ctrl-C va pouvoir interrompre cette boucle infinie en éteignant les deux LED dans la fonction destroy(). Sinon nous pourrions avoir une ou deux LED qui restent allumées en fin d'exécution.

Pour comprendre la définition des pins, nous utiliserons le diagramme "Pin Numbering - Raspberry Pi Model B+" qui se trouve sur le site http://pi4j.com/pins/model-b-plus.html et qui présente à la fois la définition des broches physiques utilisées ici (mode GPIO.BOARD) et celle du Pi4J, une bibliothèque pour la programmation en Java. Le schéma qui suit montre un Raspberry Pi Zero WH :

Les broches et la compatibilité du logiciel sont aussi équivalentes pour le Raspberry Pi 3B, le Raspberry Pi 3B+, ou encore le tout dernier Raspberry Pi 3A+.

Les broches physiques sont numérotées de gauche à droite. La lignée du bas est numérotée 1, 2, 3… et celle du haut 2, 4, 6… Les deux fils noirs conduisant aux résistances viennent donc sur la troisième en haut, la broche numéro 6, la terre. Les LED rouges et vertes sont connectées aux broches physiques digitales 12 et 15.

Il faut protéger les diodes avec des résistances, par exemple 330 Ohm communément utilisée, car cela pourrait endommager l'Arduino. Suivant les sources sur Internet, il est parfois mentionné d'utiliser 1 kOhm. Un calcul précis qui dépendra du type de LED, de l'impédance interne de l'Arduino, que nous pourrions remplacer par une carte similaire d'un autre vendeur, n’a pas de sens ici. Nous indiquerons que les diodes ici doivent être positionnées correctement avec la jambe longue côté positif.

Ce script est vraiment simple et ne nécessite donc pas une vérification sur un PC Windows où il serait nécessaire d'installer un interpréteur Python, voire Eclipse et un PyDev, évidemment.

Je ne décrirai pas ici l’installation d’Eclipse ni son utilisation. Je présume que le lecteur connaît déjà cet environnement type des programmeurs Java ou C++. Pour vérifier cet article, je l’ai installé sur une de mes anciennes versions d'Eclipse, Neon.2, ainsi qu’un workspace dédié (D:\EclipseWorkspaceNeon).

Pour les débutants dans tous ces domaines, il existe de nombreux sites pour répondre à ces questions :

• installation d'Eclipse ;
• utilisation du Workspace d'Eclipse ;
• transfert et exécution de fichiers depuis le PC sur un Raspberry Pi ;
• exécution de scripts Python au démarrage du Pi ou depuis Java.

J’ai installé la version Eclipse IDE for Java Developers, mais une version Eclipse IDE for C/C++ Developers devrait fonctionner. Le même espace de travail que Java peut aussi être utilisé : nous pourrons alors développer aussi bien nos classes Java que des scripts Python, dédiés ou non au Raspberry Pi.

Nous trouverons une description de l'installation de PyDev sur le site http://www.pydev.org.

Avec le menu Help > Install New Software nous déposerons dans la fenêtre du bouton Add la sélection http://www.pydev.org/updates :

Nous ne cocherons que le premier, PyDev  (Mylyn n'est pas nécessaire ici), avant de cliquer sur le bouton Next, deux fois, et d’accepter la "licence agreement" et un OK final pour le logiciel non signé. Il faudra redémarrer Eclipse.

Au prochain démarrage nous irons avec le menu Windows / Preferences dans PyDev / Editor / Tabs pour spécifier Tab Length = 2, (c'est peu, mais pratique pour des articles ou présentations), Replaces tabs with space, mais sans Assume tab spacing et sans Allow tab stop. Cela nous permettra d'avoir un minimum de warnings de la part de l'éditeur Python sous Eclipse.

Le script précédemment décrit, blink2leds.py fonctionne sur le Raspberry Pi sous la version 2 de Python, c'est implicite. Moi-même j'utilise aussi Python 3 parfois et dans ce cas j'emploie l'extension .py3.

Sur le Raspberry Pi une commande python3 blink2leds.py va aussi montrer correctement nos deux LED clignotent, avec la version 3. Nous allons donc installer la version 3.5.3, celle retournée par la commande Python3 version sur le Raspberry Pi (l'image Raspbian utilisée 2018-06-27-raspbian-stretch.img).

Nous devrons télécharger Python, si pas encore installé depuis https://www.python.org/downloads/. Avec le nom « Windows x86 executable installer », nous recevrons un fichier Python-3.5.3.exe que nous exécuterons :

Nous adopterons « Customize installation » afin de choisir un répertoire d'installation, comme par exemple D:\Python\Python35-32. Nous aimons bien ne pas saturer le disque C:, souvent un SSD de nos jours.

Nous installerons aussi la version 2 de Python, qui elle sera cette fois-ci disponible avec l’extension .msi: python-2.7.13.msi. Les scripts Python pour le Raspberry Pi sont en général écrits pour la version 2.

Il est conseillé d’utiliser un répertoire D:\Python\Python27_13 ou similaire, plus facile à retrouver : il sera plus aisé de passer d’un à l’autre par un changement de configuration dans Eclipse, par exemple.

La première chose est de spécifier l’interpréteur Python d’Eclipse. Sans passer par cette configuration, nous ne pourrons pas créer un projet dédié à Python. Pour cette configuration nous irons sous le menu « Window / Preferences / PyDev / Interpreters »  et finalement « Python Interpreter ». Le bouton en haut à droite New nous permettra d'entrer l'information :

et deviendra :

Le bouton « Browse » précédant nous permettra de naviguer entre les deux versions de Python, si nous les avons installées toutes les deux. À tout moment nous pourrons en activer une autre, en installant la nouvelle (Add), voire en effaçant l'ancienne (Remove).

Ensuite nous installerons notre premier projet dédié à Python : c'est similaire à des projets Java.

Pour obtenir cette fenêtre. il nous suffira d'utiliser le menu « File / New / Projet et PyDev Project ».

Nous créerons un projet PythonPremierPas avec le menu « File / New / Projet » et « PyDev Project ». Eclipse nous demandera d'accepter la perspective PyDev qui est plus que judicieuse.

De la même manière que les projets Java dédiés au Raspberry Pi, en sectionnant le projet PythonPremierPas, nous pourrons créer, préparer et exécuter nos scripts Python sous Eclipse. Toutes les procédures nécessaires avant d'exécuter notre premier script Python sont similaires à Java.

Préparation de notre premier script Python :

# coding: utf-8
# Ce script nous montrera Salut dans une console du Raspberry Pi
# Ce message sera suivi de Bravo sur une seconde ligne
# La variable nombre est juste là pour montrer le débogage

nombre = 1
print('Salut au Raspberry Pi')
nombre += 1
print('Bravo')

L'instruction Python coding est nécessaire pour les caractères accentués, voire du japonais ou autres (en utf-8). La variable nombre est inutile, mais sera utilisée pour le débogage. Et voici à présent l'exécution sous Eclipse, avec le bouton « Run » du

menu, qui peut aussi contenir d'autres sélections que hello.py, et le résultat viendra dans la console d'Eclipse :

À gauche en haut, nous retrouvons notre projet Eclipse : il a déjà quelques scripts Python, dont hello.py et sa variable nombre indiquée en dessous.

Dans la partie de droite, avec la loupe, nous avons déjà sélectionné dans la marge de l'éditeur un point d'arrêt utilisable sur la ligne print('Bravo'). Avec un Debug (bestiole à gauche du bouton « Run »), nous aurons :

Nous avons stoppé après l'incrémentation de la variable nombre et nous voyons sa valeur dans la fenêtre des variables en haut à droite. Lorsque nous aurons terminé, il faudra stopper le « Run » d'Eclipse avec le petit carré rouge sur la barre en bas et remettre une perspective correcte en haut à droite, et une dernière icône pour celle de Python. Nous voyons ci-dessus les trois Perspectives Java d'Eclipse. Pour un débutant avec Eclipse : il reste du travail !

Le script Python ci-dessus, blink2leds.py, sera déposé dans le projet PythonPremierPas avec « New / File » comme pour hello.py.

Comme pour Java, nous pouvons copier un fichier, ici blink2leds.py, directement dans le répertoire du projet, c'est-à-dire ici D:\EclipseWorkspaceNeon\PythonPremiersPas de l'explorateur de Windows, et d'exécuter ensuite un F5 (refresh) sur ce projet dans Eclipse.

Il est clair que nous verrons tout de suite le problème : nous n'avons pas de bibliothèque RPi.GPIO sur le PC. Il n'y a pas de port GPIO sur un PC !

Cette partie n'est pas vraiment sérieuse, mais plus pour montrer que c'est possible. C'est plus un exercice de style. Dans mon livre consacré à Java et au Raspberry Pi, Eclipse et Java sont le cœur du développement… donc j'y reste. Je n'utilise Python pour que tester mes circuits et du débogage n'est pas vraiment nécessaire. Les programmeurs Python avec des scripts complexes, et j'espère des classes Python, devraient mettre en place un environnement plus judicieux sous Windows et sur le Pi (avec un débogueur). La bibliothèque GPIO du Raspberry Pi est relativement simple. J'ai moi-même travaillé avec Python pour l'EV3 de Lego. Dans ce cas une bibliothèque de simulation sous PC et Eclipse, et pour celle de l'EV3, serait sans doute un casse-tête.

Si nous ne sommes pas trop familier avec Eclipse, il est plus facile d'utiliser l'explorateur de Windows dans le répertoire de l'espace de travail de notre projet Eclipse : D:\EclipseWorkspaceNeon\PythonPremiersPas et ensuite d'exécuter un Refresh ou F5 sur le projet en question.

Les actions suivantes sont requises :

• création d'un répertoire RPi ;
• création dans le répertoire RPi  d'un fichier __init__.py, mais VIDE. C'est le fichier d'initialisation d'une bibliothèque Python ;
• création dans le répertoire RPi d'un fichier GPIO.py comme ceci :

import time

BOARD = 1
OUT = 1
IN = 1
HIGH=1
LOW=0
PUD_DOWN=0

def setmode(arg):
  print (arg)
   
def setup(pin, state, initial=-1, pull_up_down=-1):
  print "setup:", pin, "with", state
   
def output(arg1, arg2):
  print "output: " ,arg1, "-" ,arg2 
   
def input(arg1):
  print " input: " ,arg1
  time.sleep(0.1)
  return (1)

def cleanup():
  print " cleanup "
   
def setwarnings(flag):
  print " setwarning:  " + flag

Pour les utilisateurs de Notepad++, je conseillerais d’employer une indentation à deux espaces comme installée ci-dessus avec Eclipse.

Toutes les fonctions de la bibliothèque GPIO utilisées par blink2leds.py seront donc simulées par des print en Python. GPIO.py est écrit en Python 2, mais fonctionnera ou pourra être converti en Python 3. Nous avons introduit l'instruction input qui est un peu différente : je l'ai utilisée dans un script pour un capteur à ultrasons, qui en avait besoin et pour mesurer une distance. Un bouton pressoir aurait aussi besoin d'une instruction input comme if GPIO.input(lepin) == GPIO.HIGH:.

En particulier pour un capteur à ultrasons, c'est clair que du code de simulation devrait être introduit sur le PC, car ce script doit recevoir différentes valeurs d'entrée, suivant le retour du signal ultrasonique, après détection sur un objet se déplaçant. Pour un capteur de température Dallas DS18B20, ou de lumière, des valeurs aléatoires entre deux limites seraient intéressantes. Pour un capteur de mouvement, ce serait aussi plus compliqué.

L'auteur préfère la solution Java pour ce genre de travaux de simulation avec du code comme :

if (System.getProperty("os.name").startsWith("Windows")) {
  //Code de simulation
}

dont l'équivalent Python serait :

import platform
if platform.system() == 'Windows':
  #Code de simulation

L'instruction setup est aussi plus complète. Des arguments supplémentaires sont requis, par exemple, dans le cas d'un bouton pressoir.

PyDev fonctionnant comme un charme, nous avons passé directement au débogueur. Dans cette exemple nous avons avons stoppé sur la ligne 26 (c'est à dire i += 1) pour limiter les print sur la console d’Eclipse :

pydev debugger: starting (pid: 11780)

Les deux LED vont clignoter :

1
setup: 12 with 1
setup: 15 with 1
output:  12 - 1
output:  15 - 1
output:  12 - 0
output:  15 - 0

Nous pouvons consulter la variable i, qui aura la valeur de 0, visible dans la fenêtre en haut à droite d'Eclipse. Avec un F5 (Step Into) nous ferons passer notre variable i à 2 et le débogueur alors positionner sur l'instruction while i < 15:.

Nous voyons bien les 12 et 15 des broches physiques GPIO du Raspberry Pi correspondant à nos LED qui s’allument et s’éteignent (voir l'exercice ci-dessous).

Pour ce projet et cette configuration, nos fichiers Python seront dans le répertoire
D:\EclipseWorkspaceNeon\PythonPremiersPas.

Un outil de transfert comme WinScp (ou FileZilla sous Linux Ubuntu, par exemple) nous permettra de copier facilement nos fichiers Python dans le répertoire créé à cet effet sur le Raspberry Pi : /home/pi/python.

PuTTY, qui est un outil ssh sous Windows, nous permettra d'exécuter ces scripts avec python ou python3 dans une console de Raspbian du Raspberry Pi.

Apprendre un langage, une technologie ou un outil, est quelque chose qui nécessite des exercices. Dans mon entreprise, il m'est arrivé de distribuer un ensemble d'exercices en Java pour la semaine suivante. À mon avis cet article aurait besoin de quelques exercices pour les programmeurs désirant utiliser ce mode de travail et non un vrai débogueur sur le Raspberry Pi :

• convertir GPIO.py en Python 3 et configurer Eclipse pour interpréter le code en Python 3 (si nous sommes sous Python 2). Améliorer les print de GPIO.py pour montrer les informations plus proprement pour chaque fonction. Un GPIO.OUT, par exemple, pourrait être affiché ;
• modifier le script blink2led.py pour que la LED rouge clignote chaque demi-seconde pendant 15 secondes, et la deuxième chaque seconde en permanence. S'assurer que notre nouveau GPIO.py est bien écrit.

Ayant terminé cet article, j'ai rapidement installé PyCharm (https://www.jetbrains.com/pycharm/), créé un projet, copié mes exemples Python pour le Raspberry Pi, en particulier blink2leds.py, copié le répertoire RPi, modifié GPIO.py en Python 3… et joué avec ! Ce charmant PyCharm a fonctionné comme un charme.