Paso 4: Conectar el Lilypad con procesamiento
Antes de avanzar a la parte inalámbrica, es necesario conectar el Arduino con el proceso. Se proporciona el código de procesamiento hacia el final de esta sección. Siga los pasos siguientes para hacer Arduino comunicarse con el proceso.
[Prueba]
Comenzar con las pruebas iniciales mediante el envío de números de Arduino para procesamiento.
1. [Arduino] enviar ASCII 0 ~ 255 de serie.
void setup() {}
Serial.Begin(9600);
}
byte me;
void loop() {}
Serial.Write(i++);
Delay(500);
}
2. Abra al monitor de la serie y comprobar si los números aparecen en el monitor de puerto serie. Asegúrese de que cerrar al monitor serie. Es muy importante cerrar el post de la serie monitor el cheque número para asegurarse de que no aparecen errores.
3. [proceso] recibe este número forma de procesar y mostrar en la consola.
Import processing.serial.*;
Serie myPort;
int val;
void setup() {}
tamaño (200, 200);
String portName = Serial.list() [2];
myPort = serie nueva (este, portName, 9600); }
void draw() {}
Si (myPort.available() > 0) {}
Val = myPort.read();
println(Val);
}}
r. es importante identificar el número de puerto para el procesamiento de inicio así que marcando el número de puerto.
b. usted recibirá el error cuando el número de puerto es incorrecto. Uso proceso bramido de código para comprobar el número de puerto.
Import processing.serial.*;
Serie myPort;
int val;
void setup() {}
println(serial.List());
}
void draw() {}
c. ejemplo de resultado de:
/ dev/cu. Bluetooth-Incoming-Port/dev/cu.usbmodem1421/dev/TTY. Bluetooth-entrante-puerto /dev/tty.usbmodem1421
d. también, asegúrese de que usted cerrado a serie monitor. Funciona uno a la vez.
Cuando usted recibe el número de proceso, es tiempo para agregar el código.
Resultado previsto:
El código siguiente es un código de procesamiento remezclado que interactivamente dibuja una pintura que varían con el valor luz que recibe tratamiento. Para controlar el dibujo con el sensor de luz, debe haber cierta cantidad de luz. Si hay demasiado o también menos luz no va a funcionar.
Código original: http://www.openprocessing.org/sketch/132225
[Código de procesamiento]
Import processing.serial.*;
Serie p;
int a;
Float x = al azar (50, 650);
Float y = aleatorio (50, 650);
Float r = random(700);
Float b = random(700);
flotador de t = 0;
flotador xspeed = 2;
flotador yspeed = 2;
Float xspeed2 = 2;
Float yspeed2 = -2;
Float xspeed3 = -2;
Float yspeed3 = -2;
Float xspeed4 = -2;
Float yspeed4 = 2;
void setup() {}
p = serie nueva (este, Serial.list() [1], 9600); leer serie
tamaño (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); tales grandes
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); medio tales
XSpeed = xspeed2 + m1 * aleatorio (-4, 4);
yspeed = yspeed2 + m2 * aleatorio (-4, 4);
Rect (x + xspeed2, y + yspeed2, 5, 5);
xspeed2 = xspeed3 + m1 * aleatorio (-4, 4);
yspeed2 = yspeed3 + m2 * aleatorio (-4, 4);
Rect (x + xspeed3, y + yspeed3, 5, 5);
xspeed3 = xspeed4 + m1 * aleatorio (-4, 4);
yspeed3 = yspeed4 + m2 * aleatorio (-4, 4);
Rect (x + xspeed4, y + yspeed4, 5, 5);
xspeed4 = xspeed + m1 * aleatorio (-4, 4);
yspeed4 = yspeed + m2 * aleatorio (-4, 4);
Rect (x xspeed, y + yspeed, 5, 5);
relleno (x / aleatoria al azar de 4-100, 255-80, y/3-80); tales pequeñas
XSpeed = xspeed2 + m1 * aleatorio (-4, 4);
yspeed = yspeed2 + m2 * aleatorio (-4, 4);
Rect (x xspeed, y + yspeed, 2, 2);
xspeed2 = xspeed3 + m1 * aleatorio (-4, 4);
yspeed2 = yspeed3 + m2 * aleatorio (-4, 4);
Rect (x + xspeed2, y + yspeed2, 2, 2);
xspeed3 = xspeed4 + m1 * aleatorio (-4, 4);
yspeed3 = yspeed4 + m2 * aleatorio (-4, 4);
Rect (x + xspeed3, y + yspeed3, 2, 2);
xspeed4 = xspeed + m1 * aleatorio (-4, 4);
yspeed4 = yspeed + m2 * aleatorio (-4, 4);
Rect (x + xspeed4, y + yspeed4, 2, 2);
XSpeed = xspeed4 + m1 * aleatorio (-4, 4);
yspeed = yspeed4 + m2 * aleatorio (-4, 4);
Rect (x + xspeed3, y + yspeed3, 2, 2);
xspeed2 = xspeed2 + m1 * aleatorio (-4, 4);
yspeed2 = yspeed2 + m2 * aleatorio (-4, 4);
Rect (x xspeed, y + yspeed, 2, 2);
xspeed3 = xspeed + m1 * aleatorio (-4, 4);
yspeed3 = yspeed + m2 * aleatorio (-4, 4);
Rect (x + xspeed4, y + yspeed4, 2, 2);
xspeed4 = xspeed3 + m1 * aleatorio (-4, 4);
yspeed4 = yspeed3 + m2 * aleatorio (-4, 4);
Rect (x + xspeed2, y + yspeed2, 2, 2);
relleno (aleatorio r 4-80, al azar 255-80, b/3-80); tales pequeños de 2 º G
XSpeed = xspeed2 + m1 * aleatorio (-7, 7);
yspeed = yspeed2 + m2 * aleatorio (-7, 7);
Rect (x xspeed, y + yspeed, 2, 2);
xspeed2 = xspeed3 + m1 * aleatorio (-7, 7);
yspeed2 = yspeed3 + m2 * aleatorio (-7, 7);
Rect (x + xspeed2, y + yspeed2, 2, 2);
xspeed3 = xspeed4 + m1 * aleatorio (-7, 7);
yspeed3 = yspeed4 + m2 * aleatorio (-7, 7);
Rect (x + xspeed3, y + yspeed3, 2, 2);
xspeed4 = xspeed + m1 * aleatorio (-7, 7);
yspeed4 = yspeed + m2 * aleatorio (-7, 7);
Rect (x + xspeed4, y + yspeed4, 2, 2);
XSpeed = xspeed4 + m1 * aleatorio (-7, 7);
yspeed = yspeed4 + m2 * aleatorio (-7, 7);
Rect (x + xspeed3, y + yspeed3, 2, 2);
xspeed2 = xspeed2 + m1 * aleatorio (-7, 7);
yspeed2 = yspeed2 + m2 * aleatorio (-7, 7);
Rect (x xspeed, y + yspeed, 2, 2);
xspeed3 = xspeed + m1 * aleatorio (-7, 7);
yspeed3 = yspeed + m2 * aleatorio (-7, 7);
Rect (x + xspeed4, y + yspeed4, 2, 2);
xspeed4 = xspeed3 + m1 * aleatorio (-7, 7);
yspeed4 = yspeed3 + m2 * aleatorio (-7, 7);
Rect (x + xspeed2, y + yspeed2, 2, 2);
}
Si (t > 140) {}
t = 0;
x = al azar (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;
}
}
int th1 = 8 + 20;
int th2 = 180-20;
int lightValue;
void draw() {}
if(p.Available() > 0) {}
lightValue=p.read();
println(lightValue);
}
Si (lightValue > th1 & & lightValue
Si (mousePressed & & (botón del ratón == izquierda)) {}
backround(255);
}
}
[Código de Arduino]
int myLed [] = {A2, A3, A4};
int [] sonido = {523, 539, 587}; C, D, E
int lightScope [] = {30,120,200,280};
int i = 0;
sensor int = A5;
int vuelta = 9;
byte val; guardar variables
int buzzerPin = 9;
int a = Serial.read();
void setup() {}
Serial.Begin(9600);
para (i = 0; i < 3; i ++) {}
pinMode (myLed [i], salida);
}
}
void loop() {}
int sensorValue = analogRead(sensor/4);
Serial.Write(sensorValue/4);
Delay(100);
Si (sensorValue < 20) {/ / Tur todos el LED apagado, si el valor es superior a 40
digitalWrite (myLed [i], LOW);
}
else if (sensorValue > lightScope [0], sensorValue < lightScope [1]) {}
Apagado (myLed [0], 100);
tono (buzzerPin, 523, 1000);
Delay(100);
Serial.println('0');
}
else if (sensorValue > lightScope [1], sensorValue < lightScope[2]) {}
Apagado (myLed [1], 100);
tono (buzzerPin, 587, 1000);
Delay(100);
Serial.println('1');
}
else if (sensorValue > lightScope [2], sensorValue < lightScope[3]) {}
Apagado (myLed [2], 100);
tono (buzzerPin, 659, 1000);
Delay(100);
Serial.println('2');
}
otra cosa
{
Light();
}
}
void light() {}
para (i = 0; i < 3; i ++) {}
digitalWrite (myLed [i], LOW);
Delay(100);
}
}
{} void apagado (int ledPin, int ledDelay)
digitalWrite (ledPin, HIGH);
Delay(ledDelay);
digitalWrite (ledPin, LOW);
Delay(ledDelay);
}
