Etape 4: Connexion Lilypad avec traitement
Avant de passer à la partie sans fil, il est nécessaire connecter l’Arduino avec traitement. Le code de traitement est fourni vers la fin de cette section. Suivez les étapes ci-dessous afin d’éffectuer les Arduino à communiquer avec le traitement.
[Test]
Commencez par un test initial en envoyant des numéros de Arduino au traitement.
1. [Arduino] envoi ASCII 0 ~ 255 à serial.
void setup() {}
Serial.Begin(9600) ;
}
octet i ;
void loop() {}
Serial.Write(i++) ;
Delay(500) ;
}
2. Ouvrez le moniteur série et vérifier si les numéros font leur apparition sur le moniteur de port série. Assurez-vous que vous fermez le moniteur de la série. Il est très important de fermer le poste de moniteur série le numéro chèque pour s’assurer que les erreurs ne surgissent.
3. [traitement] réception ce numéro forment le traitement et d’affichage sur la console.
Import processing.serial.* ;
Serial myPort ;
int val ;
void setup() {}
taille (200, 200) ;
String portName = Serial.list() [2] ;
myPort = nouvelle série (ce, portName, 9600) ; }
{} void draw()
Si (myPort.available() > 0) {}
Val = myPort.read() ;
println(Val) ;
}}
a. il est important d’identifier le numéro de port pour le traitement de départ tant en vérifiant le numéro de port.
b. vous recevrez erreur quand le numéro de port est incorrect. Soufflet de code de traitement permet de vérifier votre numéro de port.
Import processing.serial.* ;
Serial myPort ;
int val ;
void setup() {}
println(Serial.List()) ;
}
{} void draw()
c. exemple de résultat de :
/ dev/cu. Bluetooth-Incoming-Port/dev/cu.usbmodem1421/dev/tty. Bluetooth-Incoming-Port /dev/tty.usbmodem1421
d. en outre, assurez-vous que vous avez fermé serial monitor. Elle exploite un à la fois.
Lorsque vous recevez le nombre de traitement, il est temps pour vous d’ajouter du code.
Résultat escompté :
Le code ci-dessous est un code de traitement remixé qui dessine interactivement une peinture variant avec la valeur léger que traitement reçoit. Pour maîtriser dessin avec le capteur de luminosité, il doit être certaine quantité de lumière. Si il y a trop ou trop peu de lumière, il ne fonctionnera pas.
Code d’origine : http://www.openprocessing.org/sketch/132225
[Code de traitement]
Import processing.serial.* ;
Série p ;
int a ;
float x = random (50, 650) ;
float y = random (50, 650) ;
flotteur r = random(700) ;
float b = random(700) ;
flotter à t = 0 ;
flotteur xspeed = 2 ;
float yspeed = 2 ;
float xspeed2 = 2 ;
float yspeed2 = -2 ;
float xspeed3 = -2 ;
float yspeed3 = -2 ;
float xspeed4 = -2 ;
float yspeed4 = 2 ;
void setup() {}
p = nouvelle série (ce, Serial.list() [1], 9600) ; lire la série
taille (700, 700) ;
Background(255) ;
frameRate(60) ;
}
void randomImgDraw() {}
t = t + 1 ;
float m1=random(3) ;
float m2=random(3) ;
Fill(x/Random(4),Random(255), y/3) ;
strokeWeight(0.2) ;
storke(200) ;
Si (t < = 140) {}
XSpeed = xspeed + m1*random(2) ; grands rectangles
yspeed = yspeed + m2*random(2) ;
Rect (x + xspeed, y + yspeed, 10, 10) ;
xspeed2 = xspeed2 + m1*random(2) ;
yspeed2 = yspeed2 + m2*random(-2) ;
Rect (x + xspeed2, y + yspeed2, 10, 10) ;
xspeed3 = xspeed3 + m1*random(-2) ;
yspeed3 = yspeed3 + m2*random(-2) ;
Rect (x + xspeed3, y + yspeed3, 10, 10) ;
xspeed4 = xspeed4 + m1*random(-2) ;
yspeed4 = yspeed4 + m2*random(2) ;
Rect (x + xspeed4, y + yspeed4, 10, 10) ;
Fill(r/Random(4), random(255), b/3) ; rects moyen
XSpeed = xspeed2 + m1 * aléatoire (-4, 4) ;
yspeed = yspeed2 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed2, y + yspeed2, 5, 5) ;
xspeed2 = xspeed3 + m1 * aléatoire (-4, 4) ;
yspeed2 = yspeed3 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed3, y + yspeed3, 5, 5) ;
xspeed3 = xspeed4 + m1 * aléatoire (-4, 4) ;
yspeed3 = yspeed4 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed4, y + yspeed4, 5, 5) ;
xspeed4 = xspeed + m1 * aléatoire (-4, 4) ;
yspeed4 = yspeed + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed, y + yspeed, 5, 5) ;
remplissage (x / aléatoire aléatoire de 4-100, 255-80, y/3-80) ; petits rectangles
XSpeed = xspeed2 + m1 * aléatoire (-4, 4) ;
yspeed = yspeed2 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed, y + yspeed, 2, 2) ;
xspeed2 = xspeed3 + m1 * aléatoire (-4, 4) ;
yspeed2 = yspeed3 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed2, y + yspeed2, 2, 2) ;
xspeed3 = xspeed4 + m1 * aléatoire (-4, 4) ;
yspeed3 = yspeed4 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed3, y + yspeed3, 2, 2) ;
xspeed4 = xspeed + m1 * aléatoire (-4, 4) ;
yspeed4 = yspeed + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed4, y + yspeed4, 2, 2) ;
XSpeed = xspeed4 + m1 * aléatoire (-4, 4) ;
yspeed = yspeed4 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed3, y + yspeed3, 2, 2) ;
xspeed2 = xspeed2 + m1 * aléatoire (-4, 4) ;
yspeed2 = yspeed2 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed, y + yspeed, 2, 2) ;
xspeed3 = xspeed + m1 * aléatoire (-4, 4) ;
yspeed3 = yspeed + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed4, y + yspeed4, 2, 2) ;
xspeed4 = xspeed3 + m1 * aléatoire (-4, 4) ;
yspeed4 = yspeed3 + m2 * aléatoire (-4, 4) ;
Rect (x + xspeed2, y + yspeed2, 2, 2) ;
remplissage (r/aléatoire 4-80, au hasard 255-80, b/3-80) ; 2ème G petits rectangles
XSpeed = xspeed2 + m1 * aléatoire (-7, 7) ;
yspeed = yspeed2 + m2 * aléatoire (-7, 7) ;
Rect (x + xspeed, y + yspeed, 2, 2) ;
xspeed2 = xspeed3 + m1 * aléatoire (-7, 7) ;
yspeed2 = yspeed3 + m2 * aléatoire (-7, 7) ;
Rect (x + xspeed2, y + yspeed2, 2, 2) ;
xspeed3 = xspeed4 + m1 * aléatoire (-7, 7) ;
yspeed3 = yspeed4 + m2 * aléatoire (-7, 7) ;
Rect (x + xspeed3, y + yspeed3, 2, 2) ;
xspeed4 = xspeed + m1 * aléatoire (-7, 7) ;
yspeed4 = yspeed + m2 * aléatoire (-7, 7) ;
Rect (x + xspeed4, y + yspeed4, 2, 2) ;
XSpeed = xspeed4 + m1 * aléatoire (-7, 7) ;
yspeed = yspeed4 + m2 * aléatoire (-7, 7) ;
Rect (x + xspeed3, y + yspeed3, 2, 2) ;
xspeed2 = xspeed2 + m1 * aléatoire (-7, 7) ;
yspeed2 = yspeed2 + m2 * aléatoire (-7, 7) ;
Rect (x + xspeed, y + yspeed, 2, 2) ;
xspeed3 = xspeed + m1 * aléatoire (-7, 7) ;
yspeed3 = yspeed + m2 * aléatoire (-7, 7) ;
Rect (x + xspeed4, y + yspeed4, 2, 2) ;
xspeed4 = xspeed3 + m1 * aléatoire (-7, 7) ;
yspeed4 = yspeed3 + m2 * aléatoire (-7, 7) ;
Rect (x + xspeed2, y + yspeed2, 2, 2) ;
}
Si {(t > 140)
t = 0 ;
x = random (50, 650) ;
y = random (50, 650) ;
XSpeed = 0 ;
yspeed = 0 ;
xspeed2 = 0 ;
yspeed2 = 0 ;
xspeed3 = 0 ;
yspeed3 = 0 ;
xspeed4 = 0 ;
yspeed4 = 0 ;
}
Si ((x > width) || (x<0)) {
t = 0 ;
}
Si ((y > height) || (y<0)) {
t = 0 ;
}
}
th1 int = 8 + 20 ;
th2 int = 180-20 ;
int lightValue ;
{} void draw()
if(p.available() > 0) {}
lightValue=p.read() ;
println(lightValue) ;
}
Si (lightValue > th1 & & lightValue
Si (mousePressed & & (mouseButton == gauche)) {}
backround(255) ;
}
}
[Arduino Code]
int mohamed [] = {A2, A3, A4} ;
int [son] = {523, 539, 587} ; C, D, E
int lightScope [] = {30,120,200,280} ;
int i = 0 ;
capteur int = A5 ;
int sPin = 9 ;
octet val ; sauver la variable
int buzzerPin = 9 ;
int a = Serial.read() ;
void setup() {}
Serial.Begin(9600) ;
pour (i = 0; i < 3; i ++) {}
pinMode (mohamed [i], sortie) ;
}
}
void loop() {}
int sensorValue = analogRead(sensor/4) ;
Serial.Write(sensorValue/4) ;
Delay(100) ;
Si (sensorValue < 20) {/ / Tur tous le LED off, si la valeur est supérieure à 40
digitalWrite (mohamed [i], faible) ;
}
ElseIf (sensorValue > lightScope [0], sensorValue < lightScope [1]) {}
lightPin (mohamed [0], 100) ;
ton (buzzerPin, 523, 1000) ;
Delay(100) ;
Serial.println('0') ;
}
ElseIf (sensorValue > lightScope [1], sensorValue < lightScope[2]) {}
lightPin (mohamed [1], 100) ;
ton (buzzerPin, 587, 1000) ;
Delay(100) ;
Serial.println('1') ;
}
ElseIf (sensorValue > lightScope [2], sensorValue < lightScope[3]) {}
lightPin (mohamed [2], 100) ;
ton (buzzerPin, 659, 1000) ;
Delay(100) ;
Serial.println('2') ;
}
d’autre
{
Light() ;
}
}
void light() {}
pour (i = 0; i < 3; i ++) {}
digitalWrite (mohamed [i], faible) ;
Delay(100) ;
}
}
void lightPin (int ledPin, int ledDelay) {}
digitalWrite (ledPin, HIGH) ;
Delay(ledDelay) ;
digitalWrite (ledPin, basse) ;
Delay(ledDelay) ;
}
