Ex 4 – Communiquer avec Processing

1 - Matériel

Un interrupteur
Une résistance 10kOhms (Marron/Noir/Orange/Or)
Le montage précédent

2 - Réaliser le montage suivant:

3 -Lire le nouvel interrupteur :

int potVal = 0;
int redVal = 0;
void setup() {
 // On démarre la communication série
 Serial.begin(9600);
 // on déclare la PIN 6 comme OUTPUT pour le potentiomètre
 pinMode(6, OUTPUT);
 // on déclare la PIN 2 comme INPUT pour l'interrupteur
 pinMode(2,INPUT);
}
void loop() {
 // On lit l'état du switch
 int sensorValue = digitalRead(2);
 Serial.print("Switch :");
 Serial.println(sensorValue);

 //On lit la valeur du potentiomètre
 potVal = analogRead(5);
 // On l'affiche dans la console série
 //Serial.print("Potentiometre :");
 //Serial.println(potVal, DEC);
 redVal = potVal / 4; // On normalise la valeur de 0 à 255
// on envoie la valeur de luminosité à la PIN 6
 analogWrite(6, redVal);
}

4 -Connexion à Processing

Pour utiliser les valeurs de l’Arduino, nous disposons de deux solutions:

  1. Soit nous initialisons une communication Série entre Arduino et Processing, et nous récupérons les valeurs que nous affichons dans la console (à l’aide de Serial.print). (Voir Démo « Serial » dans les librairies de Processing)
  2. Soit nous utilisons la bibliothèque externe à Processing écrite pour communiquer directement avec Arduino.

A

Pour le cas de figure A, le sketch Arduino ne change pratiquement pas, nous allons remplacer les mots « Switch » et « Potentiomètre » par des caractères (S et R). Cela fait moins de bytes à envoyer à Processing, et c’est plus facile à discriminer. Cela donnerait cela du côté d’Arduino:

int potVal = 0;
int redVal = 0;
void setup() {
 // On démarre la communication série
 Serial.begin(9600);
 // on déclare la PIN 6 comme OUTPUT pour le potentiomètre
 pinMode(6, OUTPUT);
 // on déclare la PIN 2 comme INPUT pour l'interrupteur
 pinMode(2,INPUT);
}
void loop() {
 // On lit l'état du switch
 int sensorValue = digitalRead(2);
 //On l'envoie à Processing 
 Serial.print("S");
 Serial.print(",");
 Serial.print(sensorValue);
 Serial.print(",");
 Serial.println();
 //On lit la valeur du potentiomètre
 potVal = analogRead(5);
 //On l'envoie à Processing
  Serial.print("P"); Serial.print(",");
  Serial.print(potVal, DEC);
  Serial.print(",");
  Serial.println();
 redVal = potVal / 4; // On normalise la valeur de 0 à 255
// on envoie la valeur de luminosité à la PIN 6
 analogWrite(6, redVal);
}

Le code Processing :

// On importe la librairie qui permet de communiquer en série
import processing.serial.*;
Serial myPort; // On créé une instance de la classe Serial
short LF = 10; // "Fin de ligne"
char HEADERSWITCH = 'S'; // C'est le caractère que l'on a inséré avant la valeur du switch
char HEADERPOT = 'P'; // C'est le caractère que l'on a inséré avant la valeur du potentiomètre
int switchValue; // Une variable pour stocker la valeur du switch
int potentiometreValue; // Une variable pour stocker la valeur du potentiomètre
void setup() 
{
 size(400, 400);
 // A vous de trouver quel port série est utilisé à l'aide de print(Serial.list())
 String portName = Serial.list()[4];
 // On initialise la communication série, à la même vitesse qu'Arduino
 myPort = new Serial(this, portName, 9600);
}
// Un message est reçu depuis l'Arduino
void serialEvent(Serial p) {
 String message = myPort.readStringUntil(LF); // On lit le message reçu, jusqu'au saut de ligne
 if (message != null)
 {
 print("Message" + message);
 // On découpe le message à chaque virgule, on le stocke dans un tableau
 String [] data = message.split(",");
//Message reçu du switch
 if (data[0].charAt(0) == HEADERSWITCH)
 {
 // On convertit la valeur (String -> Int)
 int switchRaw = Integer.parseInt(data[1]);
 switchValue = switchRaw;
 }
//Message reçu du potentiomètre
 else if (data[0].charAt(0) == HEADERPOT)
 {
 // On convertit la valeur (String -> Int)
 int potRaw = Integer.parseInt(data[1]);
 // On normalise la valeur de 0 à 255
 potentiometreValue = potRaw/4;
 }
 }
}
void draw() {
background(potentiometreValue);
// Si le switch est appuyé, on affiche un rectangle
 if (switchValue == 1)
 {
 fill (255, 0, 0);
 rect(100, 100, 200, 200);
 }
}

 

B

Pour le cas de figure B, nous aurons besoin d’injecter un code « générique » dans l’Arduino, pour que la bibliothèque Processing puisse fonctionner, le « Standard Firmata ». Vous le trouverez dans Examples>Firmata>StandardFirmata. Téléchargez la bibliothèque Arduino et installez là. Ensuite, le code Processing ressemblera à ceci:

import processing.serial.*; 
import cc.arduino.*;
Arduino arduino;
int potVal = 0; 
int switchValue = 0;
void setup() { 
 size(510, 300); 
 // On initialise la communication avec l'arduino
 println(Arduino.list());
 arduino = new Arduino(this, Arduino.list()[4], 57600); 
 // Ensuite, la syntaxe est la même que dans l'IDE Arduino
 arduino.pinMode(6, Arduino.OUTPUT); 
 arduino.pinMode(2, Arduino.INPUT); 
 background(0); 
 fill(255); 
 smooth();
} 
void draw() { 
 //Controller l’arrière plan avec le switch
 switchValue = arduino.digitalRead(2); 
 println(" Switch : " + switchValue); 
 if (switchValue==0) { 
 background(0);
 } 
 else { 
 background(255, 0, 0);
 }

 //Controller une ellipse avec le potentiomètre 
 potVal = arduino.analogRead(0)/4; 
 println(" Potentiometre : " + potVal); 
 ellipse(255, 150, potVal, potVal); 

 //Controler la LED avec la souris 
 arduino.analogWrite(6, mouseX/2);

}

C

Petit détail: voilà à quoi ressemblerait le code si l’on voulait, comme on vient juste de le faire (si facilement avec le Firmata ) envoyer une information depuis Processing vers Arduino pour contrôler la LED

Pour Arduino :

char val; //l'info reçue depuis Processing
int ledPin = 6; // la PIN de la LED...
void setup() {
 pinMode(ledPin, OUTPUT); // ... que l'on définit en OUTPUT
 Serial.begin(9600); // On lance la communication
}
void loop() {
 if (Serial.available()) { // Si les données sont pr^tes à etre lues,
 val = Serial.read(); // on les stocke
 }
 if (val == 'H') { // Si c'est un 'H' qui est reçu
 digitalWrite(ledPin, HIGH); // On allume la LED
 } 
 else {
 digitalWrite(ledPin, LOW); 
 }
 delay(5); // On attends la prochaine lecture
}

Et pour Processing:

import processing.serial.*;
Serial myPort; 
int val;
void setup() 
{
 size(200, 200);
 String portName = Serial.list()[4];
 myPort = new Serial(this, portName, 9600);
}
void draw() {
 background(255);
 if (mouseOverRect() == true) { // Si la souris est sur le rectangle
 fill(204); // on change sa couleur
 myPort.write('H'); // et on envoie un H à l'arduino
 } 
 else { // Sinon, 
 fill(0); //
 myPort.write('L'); // on envoie un L à la place
 }
 rect(50, 50, 100, 100); 
}
boolean mouseOverRect() { // Teste si la souris est sur le rectangle
 return ((mouseX >= 50) && (mouseX <= 150) && (mouseY >= 50) && (mouseY <= 150));
}