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:
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)
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
}
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));
}
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 :
4 -Connexion à Processing
Pour utiliser les valeurs de l’Arduino, nous disposons de deux solutions:
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:
Le code Processing :
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:
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 :
Et pour Processing: