Cours
- Processing - leçon 1
-Processing est un environnement de développement. C'est un environnement de développement intégré (IDE) open-source, multi-plateforme et libre. Il utilise du java simplifié.
- I) Les fonctions void setup() et void draw()
void setup(){
}
void draw(){
}
- Le setup est une fonction qui ne s'exécute qu'une seule fois au lancement du programme. Le draw est une fonction qui s'exécute en boucle, environ 30 fois par seconde.
- Void signifie vide. Ne renvoie rien au reste du programme. La parenthèse ouvrante et puis fermante signifie que la fonction ne prend aucun paramètre.
- size(largeur, hauteur) est une fonction prenant deux paramètres, la hauteur et la largeur de la fenêtre en pixels.
- Le point-virgule " ; " correspond à la fin d'une instruction
- ellipse est une fonction créant une ellipse ayant pour coordonnées : (positions(x), positions(y), largeur(a), hauteur(b))
- background() : les couleurs sont notées en hexadécimales ou en RVB (rouge vert bleu), chaque valeur étant comprise entre 0 et 255
- int : type de variable entière. / Orange : type de variable
- int x = 5 ; => affectation de la valeur entière 5 à la variable x
- les deux barres verticales "||" signifient « ou »
- if(x>=480||x<=20) sont des booléennes qui peuvent ne prendre que deux valeurs TRUE ou FALSE
- II) Les rebonds d'une balle
int x=50; //variables globales utilisables dans tout le sketch
int y=250;
int vitesseX = 5;
int vitesseY = 3;
void setup(){
size(500,500);
}
void draw(){
background(#FACCF2);
ellipse(x,y,20,20);
if(x>=480||x<=20){vitesseX=-vitesseX;
}
if(y>=480 || y <= 20){vitesseY = - vitesseY;}
x=x+vitesseX ;
y = y + vitesseY ;
}
- III) Les tableaux d'entiers
-Les tableaux (array) permettent de stocker des grandes quantités de données sous un seul nom. Ils permettent en peu de lignes de code de faire rebondir un grand nombre de balles.
- Leçon 2 : décrypter un programme complexe
Le programme que nous allons étudiercombine l'utilisation d'un mirco contrôleur arduino. L'arduino peut communiquer par un port série avec l'ordinateur.
I- Le code
/**
* This sketch demonstrates how to monitor the currently active audio input
* of the computer using an <code>AudioInput</code>. What you will actually
* be monitoring depends on the current settings of the machine the sketch is running on.
* Typically, you will be monitoring the built-in microphone, but if running on a desktop
* its feasible that the user may have the actual audio output of the computer
* as the active audio input, or something else entirely.
* <p>
* When you run your sketch as an applet you will need to sign it in order to get an input.
*/
import ddf.minim.*; Importation de toutes les fonctionnalités de la bibliotheques audio menue
float stockage=250; Déclaration et Affectation.Affectation de la valeur 250 a la valeur décimale nommé stockage
float stockageC=255;
Minim minim; création de l'objet Minim de la classe minim
AudioInput in;
float input = 0;
import processing.serial.*; Importation de la librairie permettant la communication série avec l'Arduino
Serial myPort; // Create object from Serial class
int val; // Data received from the serial port Déclaration de la valeur entière
float var1;
void setup()
{
// size(712, 500, P3D);
size(712, 600);
minim = new Minim(this);
// use the getLineIn method of the Minim object to get an AudioInput
in = minim.getLineIn();
// uncomment this line to *hear* what is being monitored, in addition to seeing it
in.enableMonitoring();
serialinitilisation();
}
void draw()
{
background(0);
//serialread();
textSize(20); Fonction qui prends pour paramètre 20.
text("canal gauche", 20, 20); Fonction qui prends trois paramètre et qui affiche canal gauche en position 20,20 pour l'angle supérieur gauche
text("canal droit", 20, 120);
text("Energie stockée depuis le début de l'enregistrement", 20, 200);
text("Max", 20, 250);
text("sur carte", 3, 375);
text("son", 20, 400);
text("Micro", 20, 350);
text("Min", 20, 500);
text("Condensateur ", 300, 350);
text("par Arduino ", 300, 400);
fill(#F50707); Fonction qui prends pour paramètre une couleur en héxadécimal. Elle va remplir les recatangles suivants.
Rect(100, 250, 20,250); Fonction rect qui prends quatre paramètres : x et y de l'angle superieur gauche puis largeur et longueur
rect(450, 250, 20,250);
fill(255);
rect(100, 250, 20,stockage);
rect(450, 250, 20,stockageC);
//println(input);
if(stockage<=0){text("Batterie pleine", 300,300);}else{stockage= stockage-input;} Si le test est vrai, on affiche batterie pleine, si il est faux, on exécute un calcul.
if(stockageC<=0){text("Condensateur plein", 500,300);}else{stockageC= stockageC-var1/500;}
//println(stockage);
stroke(255);
fill(#F50707);
//println(in.bufferSize());
// draw the waveforms so we can see what we are monitoring
for (int i = 0; i < in.bufferSize() - 1; i++)
{
line( i, 50 + in.left.get(i)*50, i+1, 50 + in.left.get(i+1)*50 );
line( i, 150 + in.right.get(i)*50, i+1, 150 + in.right.get(i+1)*50 );
input = (abs(in.left.get(i)) + abs(in.right.get(i)))/2;
}
}
Arduino code
/*const int Voie_R=1;
int mesure_bruteR=0;
void setup() {
Serial.begin(9600); ouverture de port série avec une vitesse d'échanges de bits de 9600 Bauds
}
void loop(){
mesure_bruteR=analogRead(Voie_R); écriture sur le port série de la valeur mesure brutR lu par
Serial.print(mesure_bruteR);l'Arduino
Serial.println(",");
delay(50); 50 milisecondes d'attentes
} */
serial
void serialinitilisation() { Appel de la fonction serialinitialisation écrite dans le dernière onglet
//String portName = Serial.list()[0];
// myPort = new Serial(this, portName, 9600);
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil('\n');
}
void serialread() {
if ( myPort.available() > 0) { // If data is available,
val = myPort.read();
println(val); // read it and store it in val
}
}
void serialEvent (Serial myPort) {
String inString = myPort.readStringUntil('\n'); string : des objets, Chaine de caractères
if (inString != null) {
println("OK");
inString = trim(inString);
int inputs[] = int(split(inString, ',')); // on élude les virgules
println(inputs.length);
// on affecte nos 3 valeurs
if (inputs.length == 2) {
var1 = inputs[0];
println(inputs.length);
// On ré-échelonne la valeur analogique en valeur RGB
//var1 = map(var1, 0, 1023, 0, 255);
println(var1);
}
}
}
II-Librairie
Au lancement de processing il ne charge que les fonction java minimale. Si on veut rajouter d'autres possibiliutées comme la gestion du son, il faut importer (menu / sketch / importer une librairie) qui rajoute des fonctionnalités.
Dans : fichier / exemple / librairie, on trouve des exemples de code de librairies.
Il faut prendre des exemples et les modifier pour nous.
Le programme ne fonctionne pas si il n'y a pas de micros (entrée in) et si il n'y pas d'Arduino (entrée série) Donc pour l'exécuter quand mémé sans Arduino, il est possible de mettre en commentaire //serialinitilisation
III-L'arduino
L'environnement de programmation Arduino est sur le model de Processing. Il permet de téléverser des applications dans la plaque Arduino.
La fonction loop d'Arduino s'exécute en boucle comme le draw de Processing.
Lecture de la valeur analogique de la voie 1
un concencateur sera relié a cette voie et l'Arduino transmettra par le port série une valeur image de la tension, la virgule separe les valeurs envoyé tous les 50 metres
/*const int Voie_R=1; déclaration de constante entière de valeur 1
int mesure_bruteR=0;
void setup() {
Serial.begin(9600);
}
void loop(){
mesure_bruteR=analogRead(Voie_R);
Serial.print(mesure_bruteR);
Serial.println(",");
delay(50);
} */
serial read lis les donnés envoyé par l'Arduino
les données lus vont permettre de dessiner a l'écran un rectangle proportionnel à la charge du condensateur
- Leçon 3
PImage img; // Déclarationd'un objet image img
PImage img2;
int x = 40; position de l'angle supérieur gauche de TUX
int y = 40;
void setup() {
img = loadImage("labyrinthe.png"); chargement de l'image toujours dans le setup
img2 = loadImage("tux.png");
//size(img.width, img.height);
//Première partie
size(550, 485);
// img = loadImage("campagne.jpg"); // Load the image into the program
image(img, 0, 0, img.width/2, img.height/2);
loadPixels();
for(int i=0; i<230300;i=i+1){
pixels[i]=color(#F50C2B);}
updatePixels();
}
void draw() {
image(img, 0, 0); fonction image qui affiche img angle supérieur gauche en position 0,0
bougerTux();
image(img2, x, y, 40, 40);
if (y == 0 && x>100) { condition d'affichage du texte gagné
fill (#F50C2B);
textSize(64);
text("GAGNE", 200,200);
}
}
void bougerTux() {
if (keyPressed) {
if (key == CODED) { Processing crée trois tableaux contenant chacun les valeurs rouge verte
if (keyCode == UP) { oubleue des pixels de l'écran
if (red(get(x, y-1))==0) { L'assesseur get permet d'obtenir la couleur du pixel situé au dessus
y=y; du Tux,si il est noir tux ne peut pas monter, si non il monte.
} else {
y = y-1;
}
}
}
}
if (keyPressed) {
if (key == CODED) {
if (keyCode == LEFT) {
if (red(get(x-1, y))==0) {
x=x;
} else {
x = x-1;
}
}
}
}
if (keyPressed) {
if (key == CODED) {
if (keyCode == RIGHT) {
if (red(get(x+41, y))==0) {
x=x;
} else {
x = x+1;
}
}
}
}
if (keyPressed) {
if (key == CODED) {
if (keyCode == DOWN) {
if (red(get(x, y+41))==0) {
y=y;
} else {
y = y+1;
}
}
}
}
}