LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

mardi 21 novembre 2017

3 visiteurs en ce moment

Démarrer en Processing (1)

Installation et interface IDE

. Par : DDEFF

Vous avez déjà vu des programmes en Processing sur le site Locoduino :
Des articles de Pierre59 sur la programmation :
Un gestionnaire en C++ pour votre réseau (1)
Un gestionnaire en C++ pour votre réseau (2)
Un gestionnaire en C++ pour votre réseau (3)
et mon fil sur le forum :
http://forum.locoduino.org/index.ph...

C’est essentiellement un logiciel de dessin sur ordinateur (ou assimilé) qui peut nous aider pour nos petits trains, en particulier pour faire un TCO qu’on pourra associer à un gestionnaire basé sur un Arduino DUE.

Comme tout logiciel, il faut d’abord l’installer sur votre ordinateur.
Voici le lien de téléchargement :
https://processing.org/download/

PNG - 213 ko

Première constatation :
Il fonctionne avec toutes les plateformes.

Le problème est qu’il ne fonctionne pas exactement de la même façon suivant les plateformes… Mais on expliquera ce qui peut changer d’une version à l’autre. Merci à Dominique et à Pierre pour les compléments sur Mac   et Linux dans cet article.

Je note toutefois qu’il fonctionne avec Linux, ce qui pourrait paraître anecdotique, mais qui ne l’est pas pour nous :
Mon TCO sera sur un grand écran (ancienne télé ou écran 27" dans mon cas) et je ne veux pas mobiliser mon ordi pour ça. J’utiliserai donc un pcDuino (environ 70€) qui gère une prise HDMI pour l’écran. Et pcDuino peut recevoir une version Linux (Ubuntu). D’où l’intérêt que Processing marche aussi avec Linux. Comme ça, pour un prix modique, j’aurais une machine autonome dans la pièce de mon train.

Je note aussi que depuis la version 3.0, Processing marche aussi avec Android. Mais je n’ai pas testé.

Deuxième constatation :
Cela ne saute pas aux yeux sur la copie d’écran que je vous ai fournie, mais il y a un changement de version environ tous les mois. La plupart des changements sont mineurs (correction de bugs, essentiellement), mais pas tous.

Je parlerai plus tard de la version 3.3.4 qui a besoin d’une adaptation spécifique.

Dernière constatation :
Il y a sur le côté gauche une colonne qui recèle des trésors :

"Reference" qui explique par le détail comment utiliser chaque "mot" du vocabulaire Processing. C’est, bien sûr, extrêmement proche du langage Java, mais il y a quelques nuances.
"Tutorial" et "Examples" donnent une idée de ce que l’on peut faire avec Processing en général.

Téléchargeons :

Version Windows (dans mon cas Windows 10 / 64 bits) :
Vous téléchargez un fichier .zip assez volumineux (118 811 Ko pour la 3.3.4)

Il n’y a pas de programme d’installation de Processing. Vous pourriez l’utiliser à partir d’une clé USB, mais je ne vous le conseille pas.

Étant donné les quelques bugs qui subsistent lors des changements de version, je ne supprime pas tout de suite l’ancienne version. On peut alors très facilement revenir en arrière.

Étant donné la façon dont fonctionne Windows, je vous incite à déplacer ce fichier.zip dans le répertoire "C :\Programmes\Processing\" que je vous conseille donc de créer. Je précise bien : "Programmes" et pas "Program Files (x86)" qui est réservé aux applications 32 bits, ce qui n’est pas le cas de Processing.

Avec un clic droit sur le .zip, vous choisissez "Extraire tout" et validez la proposition d’emplacement qu’il vous propose. Windows étant ce qu’il est, il va vous proposer :
"C :\Program Files\Processing\processing-3.3.4-windows64" qui, vous vous en doutez, est bien le répertoire "C :\Programmes\Processing" que vous voyez dans l’explorateur !
C’est Windows, on ne se refait pas …

Processing est maintenant prêt à fonctionner.

Version Mac  

Vous téléchargez un fichier processing-3.3.4-macosx.zip de 114,2 Mo qui va dans le dossier de téléchargement (sur mon bureau, c’est plus facile à retrouver). Le fichier se décompresse automatiquement :

PNG - 19.6 ko

Il ne reste plus qu’à le déplacer dans votre dossier Applications.

Version Linux

Vous téléchargez un fichier processing-3.3.4-linux-armv6hf.tgz de 114,2 Mo, dans le cas d’un Linux Ubuntu pour pcDuino, par exemple.

JPEG - 7.6 ko

Vous le décompressez et vous avez maintenant le dossier processing-3.3.4 :

JPEG - 29.2 ko

Il ne reste plus qu’à double-cliquer sur install.sh pour que l’icône de l’application Processing apparaisse sur le bureau :

JPEG - 7.2 ko

Installation d’une mise à jour :

Votre programme fonctionne parfaitement. Mais vous avez eu un message de Processing, "Une nouvelle version existe" au moment de l’ouverture. Et il vous donne le lien pour aller jusqu’à la page "Download".

Le début est rigoureusement le même. Télécharger le .zip, "Extraire tout" dans le même répertoire. Vous avez à ce moment deux versions (par exemple 3.3.4 et 3.3.5).

Dans le cas de Windows :

Renommez le répertoire de la 3.3.4 en "processing-3.3.4-windows64.old".
A ce moment, vous avez cassé le lien avec tous vos programmes en Processing !
Rassurez-vous, on va établir un nouveau lien…

Allez à présent dans le répertoire où se trouvait le programme que vous vouliez ouvrir. Cliquez droit dessus et choisissez "Ouvrir avec", puis "choisir une autre application".

PNG - 35.1 ko

Cochez bien la case "Toujours utiliser cette application pour ouvrir les fichiers .pde"

PNG - 12.6 ko

Tapez sur "Plus d’applications". Allez en bas de la fenêtre qui s’ouvre :

PNG - 22.4 ko

Puis, "Rechercher une autre application sur ce PC". Et, là, s’ouvre justement la fenêtre de C :\Programmes. D’où ce choix au départ. Vous recherchez "Processing" puis dans ce répertoire la bonne version de Processing. Vous avez ainsi un Processing qui fonctionne avec la bonne version.

Dans le cas du Mac et de Linux :

Je prends l’habitude de renommer tout de suite les applications en ajoutant le numéro de version (par exemple Processing334). Comme cela, la nouvelle version, qui n’a pas de numéro de version, ne viendra pas écraser l’ancienne.

Passons à l’IDE de Processing :

Malgré un air de famille, son fonctionnement n’est pas du tout le même que celui de l’Arduino. C’est même déroutant au début, mais après on regrette que celui de l’Arduino ne fonctionne pas de la même manière !

Pour y accéder :
"C :\Program Files\Processing\processing-3.3.4-windows64\processing-3.3.4\processing.exe"
Facile à reconnaître : son icône est un rond noir avec P3 dedans. Oui, c’est un P3 !

PNG - 17.5 ko

Comme pour Arduino, il y a un sketch par défaut qui sera dans un répertoire qui devra porter le même nom.
Il suffit de faire" Fichier\Enregistrer sous" et tout se crée automatiquement avec le nom que vous aurez choisi (sans blancs, comme d’habitude).

Vous pouvez mettre ce répertoire où vous voulez, mais sous Windows probablement dans "Mes documents\Processing". Personnellement, il est sur un NAS (Network Attached Storage) à l’abri. En tout cas, pas sur le disque C :\.

Dans le bandeau en haut à gauche de la fenêtre, le nom de votre programme et la version de Processing utilisée. Vous verrez, c’est pratique quand vous ferez la mise à jour de votre programme.

Trois fenêtres :
- > La fenêtre de votre programme (la plus grande) :
Vous noterez que les lignes sont numérotées à gauche.

- > La console, sur fond noir, en bas.
Gros changement par rapport à l’IDE d’Arduino : si vous voulez vérifier le contenu d’une variable x, vous faites un "print(x) ;" et le résultat s’affichera là.

- > La fenêtre des erreurs, sur fond blanc.
Et là, gros changement ! On y accède en appuyant sur le bouton "Erreurs". On peut revenir à la console en appuyant sur le bouton "Console".

Entre la fenêtre de votre programme et les fenêtres du bas, une ligne, grise pour l’instant. Très vite, elle va devenir rouge parce que dès que vous taperez quelque chose, il va chercher des erreurs en temps réel. C’est une révolution par rapport à l’IDE Arduino.

Non seulement il signale des erreurs, mais il sait aussi faire des propositions, souvent pertinentes. Et ça ne se limite pas à ’ Missing a semicolon " ;" ’ qu’évidemment vous mettez en dernier. Non, il analyse votre programme et vous signale que vous n’avez pas créé la variable que vous êtes en train d’utiliser, par exemple.
Et d’autres choses nettement plus complexes.

Je me sers de cette fenêtre d’erreurs pour changer le nom d’une variable, par exemple :
1°) je change le nom de la variable dans la ligne de sa définition
2°) Évidemment, Processing se plaint, mais en me donnant la liste exhaustive des endroits où elle apparaît.
3°) Mieux : en cliquant sur la ligne dans les erreurs, Processing va à la ligne indiquée !
4°) S’il y en a beaucoup, je vais dans "Modifier/Rechercher" (ou CRTL+F) et je mets l’ancien nom dans la première ligne et le nouveau nom dans la deuxième ligne.
5°) Et je modifie partout où c’est nécessaire, sans en oublier une seule parce qu’au fur et à mesure, le nombre d’erreurs diminue.
Essayez de faire la même chose avec l’IDE Arduino !…

Il y a même un niveau d’erreur intermédiaire, sur fond orange :
’ The value of the local variable "x" is not used ’, par exemple.
C’est une indication (warning en anglais), et ce n’est pas, à proprement parler, une erreur. Votre programme marchera quand même. D’où le fond orange.

En tous cas, c’est très pratique d’avoir l’info en temps réel. Et ainsi, aucune erreur n’en cache une autre. On les a toutes.

Les boutons :

La touche "play" (Exécuter) lance le programme.
Le programme se lance dans une fenêtre séparée. Là encore, nettement plus simple que pour l’Arduino : il n’y a bien sûr pas de téléversement. Et vous n’avez pas besoin de sauvegarder avant de lancer.
Sympa pour tester des choses.

La touche "stop" stoppe…
Elle arrête le programme et ferme sa fenêtre.

Le dernier bouton, à droite, est un débogueur.
Très utile aussi et d’autant plus utile que vous avez beaucoup de variables. En appuyant dessus, il passe en bleu et découvre deux boutons supplémentaires et une fenêtre déplaçable.
1°) Le bouton "play" reste visible et lance le programme comme d’habitude.
2°) Le bouton "stop" s’est déplacé en 4ème position et garde sa fonction.
3°) Est apparu un bouton "step" qui fait avancer pas à pas.
4°) Est apparu aussi un bouton "continue" qui continue à partir du point où on s’est arrêté.
Parce qu’évidemment, l’intérêt d’un débogueur c’est qu’on puisse arrêter le programme là où on veut. Et quand on s’arrête, on voit où en sont toutes les variables dans la fenêtre à cet instant précis. Un régal ! Pour choisir le point d’arrêt, il suffit de pointer un numéro de ligne qui devient un losange.
Et quand le programme s’arrête, le losange devient un triangle ("play").

Exemple de mon programme de TCO (arrêt ligne 213) :

PNG - 80.7 ko

J’ai ainsi accès à toutes les variables de mon programme, juste à ce moment.
Dans la ligne grise, vous notez que le débuggeur est arrêté et, donc, que les variables correspondent bien à ce que je voulais. Je dis ça parce que vous pourriez avoir un programme planté et les anciennes variables affichées… Donc : bien vérifier que l’arrêt du programme est bien dû au débogueur !

Dernière remarque sur les fenêtres :
La barre grise est mobile et permet d’agrandir la zone de la console/erreurs. Il suffit de la décaler vers le haut. Je traiterai de la fenêtre des programmes lors du prochain article "votre premier programme".

La barre des menus :

Fichier :

PNG - 9.1 ko

Rien que du très classique.
Deux menus atypiques :
"Exporter…"

PNG - 9.2 ko

Comme c’est clairement indiqué, on peut créer un exécutable. Vous noterez qu’étant sous Windows, je ne peux pas faire un exécutable vers Mac OS X (ce qui est bien dommage), alors que sous Mac OS X, je peux le faire pour les 3 plateformes :

JPEG - 80.8 ko

Si vous choisissez le mode "présentation", option intéressante, vous pouvez choisir de ne pas afficher le bouton "stop". L’intérêt, c’est, qu’ainsi, on ne peut pas accéder au programme lui-même. Et, en particulier, il n’est plus modifiable.

Dernier choix : vous embarquez Java en même temps que votre programme.
Vu, d’une part les évolutions de Processing et, d’autre part, les évolutions de Java, il peut être très intéressant d’avoir la bonne version Java associée à la bonne version Processing !
Évidemment, comme indiqué (en anglais), le programme final est plus volumineux…

Complément sur Java (version Windows) :

Je profite de l’occasion pour vous inciter fortement à mettre à jour votre version de Java pour Windows. Deux raisons :
1°) Windows équipe 93% des ordinateurs (5% Mac et 2% Linux)
2°) Oracle, le développeur de Java, revendique 3 milliards d’installations

Il s’ensuit que vous avez -presque- forcément déjà Java sur votre ordinateur, que vous ayez installé Processing ou pas. Même si vous n’aurez jamais Processing sur votre ordinateur, mettez Java à jour !

Suivez ce lien :
https://www.java.com/fr/download/he...

Notez, comme c’est indiqué, que depuis la version 3.0 de Processing, vous devez avoir la version 8 de Java. En ce moment, la 8_131.

Complément sur Java (versions Mac ou Linux) :
La remarque ci-dessus est valable également sauf si d’autres applications dans votre environnement nécessitent des versions de Java différentes.

C’est d’ailleurs ce qui a incité Apple à ne plus installer Java par défaut et les applications comme Processing et Arduino IDE à l’embarquer dans l’application.

Vous voilà prévenu, vous pouvez donc faire ce que vous voulez !

Menu "Préférences" :

PNG - 23.6 ko

Normalement, vous n’aurez pas à intervenir dans ce menu, sauf la première ligne "Emplacement du sketchbook".
Appuyez sur "Naviguer" et choisissez où vous rangerez vos programmes. Il est par défaut sous "Mes Documents/Processing". Evitez qu’il soit sur le disque C :\, pour des raisons de sécurité.
Le reste n’a pas besoin d’être modifié.

Menu "Modifier" :

PNG - 7.5 ko

Là encore, du très classique. Mais une ligne sort un peu de l’ordinaire : Mise en forme automatique (CTRL+T) ! Quand les développeurs d’Arduino ont développé leur logiciel, ils auraient dû copier ça aussi…
- > Une indentation parfaite (avec 2 blancs = une tabulation).
- > La première accolade au bout de la première ligne.
- > La deuxième accolade, seule, bien alignée avec le début de la première ligne.

Personnellement, je préfère 2 tabulations de décalage, mais, là, ça se fait tout seul.

Je n’utilise pas leur raccourci pour l’indentation, mais simplement la tabulation :
1°) Je sélectionne les lignes à décaler qui passent en jaune.
2°) J’appuie deux fois sur "tabulation" et toutes les lignes sont décalées de deux tabulations vers la droite.
3°) Sur "Majuscule"+"Tabulation", on décale cette fois vers la gauche.

Disons que CTRL+T fait tout ça tout seul, mais avec une seule tabulation.

Menu "Sketch" :

PNG - 4.3 ko

"Exécuter" = bouton "play"
"Presenter" : J’avoue ne pas avoir compris la différence avec le précédent…
"Tweak"  : Utilisation très spéciale en association avec la librairie ocsP5.
Vidéo d’exemple :
http://artandtech.aalto.fi/?page_id=1084
"Arrêter" = bouton "stop"

"Importer une librairie" :
Je ne développerai pas ici. Certaines sont vraiment puissantes.

Les autres menus sont clairs.

Honnêtement, mis à part "importer une librairie", je ne me suis pas encore servi du menu "Sketch"

Menu "Dépanner" :

Là non plus, je ne m’en suis pas servi car il correspond exactement aux boutons du débogueur.

Menu "Outils" :

PNG - 2.5 ko

"Générateur de polices" : permet, comme son nom l’indique, de choisir une police d’affichage.
"Sélecteur de couleurs" : formidable outil qui mérite un article particulier. Sert évidemment à choisir la couleur que vous allez afficher.
"Archiver le sketch" : pas besoin d’avoir un programme particulier pour générer un fichier ".zip"
"Movie Maker" : pour créer un fichier QuickTime ! Sort du cadre de cet article.
"Ajouter un outil" = "Importer une librairie" du menu précédent.

Menu "Aide" :

PNG - 5.5 ko

Je ne développerai pas ici.
Énormément d’informations, en anglais.
En particulier "Documentation" dont j’ai déjà parlé lors du téléchargement.

Prochain article : "Mon premier programme"
Je développerai un programme très simple (un curseur)
Il y a de nombreuses choses à dire sur ce simple sujet. Et son lien avec un Arduino.

11 Messages

Réagissez à « Démarrer en Processing (1) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Programmation »

Comment gérer le temps dans un programme ?

La programmation, qu’est ce que c’est

Types, constantes et variables

Installation de l’IDE Arduino

Répéter des instructions : les boucles

Les interruptions (1)

Instructions conditionnelles : le if … else

Instructions conditionnelles : le switch … case

Comment gérer l’aléatoire ?

Calculer avec l’Arduino (1)

Calculer avec l’Arduino (2)

Les structures

Systèmes de numération

Les fonctions

Trois façons de déclarer des constantes

Transcription d’un programme simple en programmation objet

Ces tableaux qui peuvent nous simplifier le développement Arduino

Les chaînes de caractères

Trucs, astuces et choses à ne pas faire !

Processing pour nos trains

Arduino : toute première fois !

Démarrer en Processing (1)

Le monde des objets (1)

Le monde des objets (2)

Le monde des objets (3)

Le monde des objets (4)

Les pointeurs (1)

Les pointeurs (2)

Les Timers (I)

Les Timers (II)

Les Timers (III)

Les Timers (IV)

Les Timers (V)

Bien utiliser l’IDE d’Arduino (1)

Bien utiliser l’IDE d’Arduino (2)

Piloter son Arduino avec son navigateur web et Node.js (1)

Piloter son Arduino avec son navigateur web et Node.js (2)

Piloter son Arduino avec son navigateur web et Node.js (3)

Les derniers articles

Ces tableaux qui peuvent nous simplifier le développement Arduino


bobyAndCo

Processing pour nos trains


Pierre59

Piloter son Arduino avec son navigateur web et Node.js (3)


bobyAndCo

Piloter son Arduino avec son navigateur web et Node.js (2)


bobyAndCo

Démarrer en Processing (1)


DDEFF

Piloter son Arduino avec son navigateur web et Node.js (1)


bobyAndCo

Arduino : toute première fois !


Christian

Bien utiliser l’IDE d’Arduino (2)


Thierry

Bien utiliser l’IDE d’Arduino (1)


Christian, Dominique, Jean-Luc, Thierry

Les Timers (V)


Christian

Les articles les plus lus

Les Timers (I)

Les interruptions (1)

Comment gérer le temps dans un programme ?

Les Timers (III)

Calculer avec l’Arduino (1)

Répéter des instructions : les boucles

Les chaînes de caractères

Piloter son Arduino avec son navigateur web et Node.js (1)

Ces tableaux qui peuvent nous simplifier le développement Arduino

Installation de l’IDE Arduino