Processing
Arduino
Arduino est une plate-forme libre de création d'objets électroniques à des fins artistiques, éducatives ou de recherche via la conception de prototypes. Elle repose sur l'utilisation d'un circuit électronique (un mini-ordinateur, appelé également microcontrôleur) comportant des entrées et sorties (des ports) sur lesquelles on peut brancher différents appareils :
- côté entrées, des capteurs, appareils qui collectent des informations sur leur environnement comme la variation de température via une sonde thermique, le mouvement via un détecteur de présence, le contact via un bouton poussoir, etc.,
- côté sorti, des actuateurs, des appareils qui agissent sur le monde physique, telle une petite lampe qui produit de la lumière, un moteur qui actionne un bras articulé, etc.
Arduino comporte également un environnement de développement logiciel calqué sur celui-ci de Processing, qui permet de programmer le circuit électronique. Arduino étant un projet dérivé de Processing, il apparaît donc comme une ouverture logique à la création interactive. Une fois que vous maîtrisez Processing, Arduino vous sera déjà familier.
L'appareil Arduino
L'appareil Arduino est une plaquette électronique que l'on peut connecter par USB à un ordinateur afin de téléverser du code sur le microcontrôleur qui s'y trouve. Un microcontrôleur, c'est un processeur (un mini-ordinateur) de petite taille qui fournit des entrées et sorties analogiques et qui fonctionne selon le programme que l'on aura enregistré dessus.
Cet appareil est autonome. Après avoir reçu le programme que vous aurez conçu, vous pouvez le déconnecter de votre ordinateur et il fonctionnera tout seul (sous réserve de l'alimenter en énergie électrique avec une pile ou mieux une cellule photovoltaïque). Comme le logiciel Arduino, ce circuit électronique est libre. On peut donc étudier ses plans, et créer des dérivés. Plusieurs constructeurs proposent ainsi différent modèle de circuits électroniques programmables utilisables avec le logiciel Arduino.
Le logiciel Arduino
L'environnement de programmation vous est certainement familier. On y retrouve les éléments de la fenêtre de travail de Processing : intitulés des menus, boutons, zone d'édition, console, etc.
Comme dans Processing, le programme est constitué d'une série d'instructions saisie dans la fenêtre du logiciel. La spécificité d'Arduino se situe au niveau de la sauvegarde du code qui s'enregistre et s'exécute habituellement depuis le microcontrôleur et non pas sur votre ordinateur. Le programme se lance dès que l'appareil Arduino est mis sous tension.
Une fois que vous maîtrisez la programmation Arduino, vous pouvez aller plus loin en connectant le microcontrôleur à d'autres logiciels, notamment à un sketch Processing que vous aurez conçu pour interagir avec cet appareil électronique.
Un dialogue entre le virtuel et le physique
Le circuit électronique Arduino comporte des entrées et sorties sur lesquelles on peut brancher différents appareils. Les capteurs servent à mesurer des informations sur le monde, alors que les actuateurs permettent d'agir sur celui-ci. On peut utiliser des capteurs afin d'influencer ce qui se passe dans un sketch Processing. À l'inverse, on peut utiliser des actuateurs pour que les instructions qui s'exécutent dans le sketch influencent le monde extérieur.
Par exemple, notre programme pourrait lire les informations obtenues de capteurs météorologiques, de capteurs de mouvement ou de simples boutons de contrôle. Ensuite, à partir de ces informations et du traitement qu'en ferait notre sketch, on pourrait contrôler des lumières, des moteurs, ou même des radiateurs ou des ventilateurs. Les applications sont multiples. Tout dépend de l'objectif visé et de l'expérience interactive recherchée.
La communication sérielle
Les ordinateurs communiquent entre eux à l'aide d'impulsions électriques à travers des fils. Les impulsions sont envoyées les unes après les autres, dans une série de bits. Un bit peut être soit vrai, soit faux. C'est le chiffre un ou zéro. Les bits sont souvent groupés en paquets de huit. On appelle ces paquets des octets. Un caractère de texte utilisant le jeu de caractères ASCII est exprimé sur huit bits.
Pour pouvoir échanger ces informations sous forme de bits avec l'extérieur, votre ordinateur utilise une ou plusieurs entrées physiques (des ports en jargon informatique) lui permettant de se connecter à des appareils périphériques (imprimante, souris, clavier, modem, etc.).
Tout cela pour vous dire que les impulsions électriques et les instructions informatiques ne sont pas si éloignées que cela dans un ordinateur et qu'il est possible de communiquer facilement avec un Arduino à l'aide de simples caractères textuels.
Exemple de communication au moyen de lettres
Voici un exemple très simple d'envoi et de réception de caractères avec un Arduino : en appuyant sur la barre d'espace de votre clavier d'ordinateur, vous allumez une diode électroluminescente (led) connectée à la sortie numérique 13 de l'Arduino. Pour leur part, les variations électriques captées au niveau de l'entrée analogique 0 d'Arduino font varier la taille du rectangle affichée par votre sketch dans la fenêtre de l'espace de dessin de Processing.
Cet exemple suppose notamment d'avoir appris à connecter votre Arduino à votre ordinateur, procédure qui n'est pas présentée ici. L'objectif de ce chapitre est davantage de vous faire comprendre les potentialités offertes par cet appareil électronique et les capacités d'interaction avec Processing. Pour en savoir plus, nous vous invitons par la suite à consulter les sources d'information disponibles notamment sur Internet.
Le code pour Processing
Envoyer et recevoir du sériel avec Processing est assez facile avec la librairie processing.serial. Il faut spécifier le bon numéro de port série (le numéro de ce port, peut être 0, 1, 2, 3...) , ainsi que la bonne vitesse. Ici, notre vitesse est de 9600 bits par seconde.
/**
* Code Processing pour communiquer avec l'Arduino simplement.
*/
import processing.serial.*;
// Attention: Changez ce numéro pour le bon port au besoin
int numero_du_port = 0; // ...ou 1, 2, 3...
Serial mon_port; // L'objet qui gère le port série
char dernier_envoye = ' '; // Dernier octet envoyé
char dernier_recu = ' '; // Dernier octet reçu
void setup() {
size(200, 150);
println("Liste des ports: \n" + Serial.list());
String nom_du_port = Serial.list()[numero_du_port];
mon_port = new Serial(this, nom_du_port, 9600);
}
void draw() {
if (mon_port.available() != 0) {
// Conversion du int en char
dernier_recu = char(mon_port.read());
}
background(231);
fill(0);
text("Dernier octet reçu: " + dernier_recu, 10, 50);
text("Dernier octet envoyé: " + dernier_envoye, 10, 70);
int largeur = int(dernier_recu - 'a');
int multiplicateur = 5;
stroke(0);
noFill();
rect(10, 90, 26 * multiplicateur, 10);
noStroke();
fill(0);
rect(10, 90, largeur * multiplicateur, 10);
}
void keyPressed() {
if (key == ' ') {
mon_port.write('1');
dernier_envoye = '1';
}
}
void keyReleased() {
if (key == ' ') {
mon_port.write('0');
dernier_envoye = '0';
}
}
Les données sont envoyées sous la forme d'une seule lettre. En effet, la valeur lue de l'entrée analogique zéro du Arduino est convertie en une lettre alphabétique comprise entre a et z. En utilisant une échelle de 25 lettres, on perd un peu de précision par rapport à la valeur chiffrée d'origine, mais cela permet également de démontrer comment les lettres sont en fait encodées avec des chiffres.
Le code pour Arduino
Côté Arduino, on exprime donc la valeur lue au niveau de son entrée analogique zéro au moyen d'une lettre comprise entre a et z. On allume également la diode (Led) associée à la sortie 13. Cette petite lumière est intégrée directement à l'Arduino, aussi nul besoin de souder ou de monter un circuit sur une planche de prototypage.
Cet exemple fonctionnera donc avec un Arduino sans aucun montage particulier. Vous pouvez toutefois connecter un potentiomètre à l'entrée analogique zéro si vous souhaitez afficher autre chose que des données aléatoires issues du « bruit » environnant. Notez que par bruit, nous désignons non pas des sons, mais les variations électrostatiques de l'environnement dans lequel se trouve votre Arduino. Même si l'entrée analogique zéro n'est connectée à aucun fil, des phénomènes électriques se produisent à travers l'air entre ce port et le port « Gnd » de l'Arduino. Idéalement sur une carte Arduino, tous les ports analogiques inutilisés devraient être connectés directement à la borne « Gnd » (Terre) pour éviter ce type d'effets.
Pour téléverser le code qui suit sur un Arduino, il faut installer le dernier logiciel Arduino, et se munir d'une carte (Duemillanove, Uno, etc.). Pour explorer le potentiel de cette interface, il est utile d'en apprendre le fonctionnement, ainsi que ses caractéristiques techniques sur le site officiel : http://www.arduino.cc.
/**
* Ce code doit être téléversé sur le Arduino.
*
* Communique avec l'ordinateur pour lui envoyer la valeur
* de l'entrée analogique 0 et permettre de contrôler la
* sortie numérique 13, qui a une petite lumière.
*/
const int entree_analogique = 0;
const int sortie_numerique = 13;
int valeur_captee = 0;
void setup() {
// Vitesse de la communication = 9600 bauds
Serial.begin(9600);
pinMode(sortie_numerique, OUTPUT);
}
void loop() {
char octet_recu;
if (Serial.available() > 0) {
// Lisons ce que l'on reçoit via le sériel
octet_recu = Serial.read();
if (octet_recu == '1') {
digitalWrite(sortie_numerique, HIGH);
} else {
digitalWrite(sortie_numerique, LOW);
}
}
// Lecture de l'entrée analogique 0:
valeur_captee = analogRead(entree_analogique);
char envoyer = 'a' + map(valeur_captee, 0, 1023, 0, 25);
Serial.print(envoyer);
// On attend un peu pour laisser le temps au ADC de respirer
delay(10);
}
Une fois que le code pour l'Arduino est installé sur l'appareil, branchez-le en USB sur votre ordinateur, si ce n'est déjà fait, et démarrez le sketch Processing. Vérifier dans le menu Arduino > Tools que les configurations de « Board » et « Serial Port » sont correctes. Lorsque la fenêtre du sketch est ouverte dans Processing et que vous appuyez sur la barre d'espacement, la LED associée à la sortie 13 (intégrée à la plaquette Arduino) devrait s'allumer comme suit :
En rajoutant :
println(dernier_recu);
...dans le void draw() du sketch de Processing, et avant de refermer l'accolade :
... rect(10, 90, largeur * multiplicateur, 10); println(dernier_recu); }
... on peut visualiser dans la console de Processing le défilement des lettres qui correspondent aux variations électrostatiques captées entre les bornes « 0 » et « Gnd » de la carte Artuino.
En examinant le code destiné au logiciel Arduino, vous pouvez constater qu'il s'apparente à Processing. Ce n'est toutefois pas le même langage de programmation, il s'agit en fait de C++ et non pas de Java. La volonté de simplifier le processus de programmation se retrouve toutefois dans les deux environnements : Arduino offre aux créateurs la possibilité d'expérimenter relativement facilement la conception d'objets électroniques.
Dans notre exemple, nous avons créé un petit protocole de communication entre l'ordinateur et le microcontrôleur, entre Processing et Arduino. Relativement simple à réaliser et à comprendre, il n'est ni très flexible ni très optimal. Si vous avez besoin d'un protocole plus robuste, nous vous invitons à visiter le site de Arduino pour trouver plusieurs propositions intéressantes de librairies et d'exemples. Le protocole Messenger (http://www.arduino.cc/playground/Code/Messenger), assez simple, pourra sans doute répondre à vos besoins.
En savoir plus
Pour en savoir plus sur Arduino, nous vous invitons à consulter le manuel en français consultable librement sur la plateforme Flossmanuals : http://fr.flossmanuals.net/arduino/