Lo único mejor que enviar señales a Processing es enviar múltiples señales, ¿verdad? Sin embargo, enviar múltiples señales es a menudo un obstáculo, porque aunque enviar valores desde múltiples sensores es fácil, manejarlos en el orden correcto en el otro extremo a menudo puede ser difícil.
Necesitas:
-
Un Arduino Uno
-
Una placa de pruebas
-
Dos potenciómetros de 10k ohmios
-
Un pulsador
-
Una resistencia de 10k ohmios
-
Saltar cables
El circuito es una combinación de tres entradas separadas. Aunque todos usan la misma potencia y tierra, puede pensar en las entradas individualmente. Dos potenciómetros proporcionan dos valores. Estos están conectados de la misma manera que conectaría un sensor de temperatura, con un lado conectado a 5 V y el otro conectado al pin de entrada analógica que lo está leyendo, así como a GND a través de una resistencia.
En realidad, estos podrían reemplazarse con cualquier entrada analógica con las resistencias adecuadas. El botón también proporciona una entrada digital. Un lado del botón está conectado a 5V y el otro está conectado al pin digital que lo lee, así como a GND a través de una resistencia.
Cómo configurar el código Arduino
Después de ensamblar su circuito, necesita el software apropiado para usarlo. En el menú Arduino, elija Archivo → Ejemplos → 04.Comunicación → SerialCallResponse. Este boceto contiene tanto el código Arduino como el código de procesamiento relevante para que el boceto funcione. El código de procesamiento debajo del código de Arduino está comentado para evitar interferencias con el boceto de Arduino.
/ *
Llamada y respuesta en serie
Idioma: cableado / Arduino
Este programa envía un ASCII A (byte de valor 65) al inicio
y lo repite hasta que obtiene algunos datos.
Luego espera un byte en el puerto serie y
envía tres valores de sensor cada vez que recibe un byte.
Gracias a Greg Shakar y Scott Fitzgerald por las mejoras
El circuito:
* potenciómetros conectados a las entradas analógicas 0 y 1
* pulsador adjunto a E / S digital 2
Creado el 26 de septiembre de 2005
por Tom Igoe
modificado el 24 de abril de 2012
por Tom Igoe y Scott Fitzgerald
Este código de ejemplo es de dominio público.
http://www.arduino.cc/en/Tutorial/SerialCallResponse
* /
int firstSensor = 0; // primer sensor analógico
int secondSensor = 0; // segundo sensor analógico
int thirdSensor = 0; // sensor digital
int inByte = 0; // byte serial entrante
configuración vacía ()
{
// inicia el puerto serie a 9600 bps:
Serial.begin (9600);
while (! Serial) {
; // espera a que se conecte el puerto serie. Necesario solo para Leonardo
}
pinMode (2, ENTRADA ); // el sensor digital está en el pin digital 2
establecer contacto(); // envía un byte para establecer contacto hasta el receptor
// responde
}
bucle vacío ()
{
// si obtenemos un byte válido, leemos entradas analógicas:
if (Serial.available ()> 0) {
// obtener el byte entrante:
inByte = Serial.read ();
// leer la primera entrada analógica, dividir por 4 para hacer el rango 0-255:
firstSensor = analogRead (A0) / 4;
// demora 10 ms para que el ADC se recupere:
retraso (10);
// leer la segunda entrada analógica, dividir por 4 para hacer el rango 0-255:
secondSensor = analogRead (1) / 4;
// leer el interruptor, asignarlo a 0 o 255L
tercerSensor = mapa ( digitalRead (2), 0, 1, 0, 255);
// enviar valores de sensor:
Serial.write (primer sensor);
Serial.write (secondSensor);
Serial.write (tercer sensor);
}
}
void EstablishContact () {
while (Serial.available () <= 0) {
Serial.print ( 'A' ); // enviar un retraso A mayúscula
(300);
}
}
Sube este código a tu Arduino.
Cómo configurar el código de procesamiento
El código de procesamiento se encuentra dentro de marcadores de comentarios de varias líneas ( / * * / ) en la parte inferior del boceto de Arduino SerialCallResponse. Copie el código dentro de los marcadores de comentarios en un nuevo boceto de procesamiento y guárdelo con un nombre apropiado.
// Este código de ejemplo es de dominio público.
procesamiento de importación.serie . *;
int bgcolor; // Color de fondo
int fgcolor; // Color de relleno
Serial myPort; // El puerto serie
int [] serialInArray = new int [3]; // Dónde pondremos lo que recibamos
int serialCount = 0; // Un recuento de cuántos bytes recibimos
int xpos, ypos; // Posición inicial de la bola
booleana firstContact = false ; // Si hemos escuchado del
// microcontrolador
configuración vacía () {
tamaño (256, 256); // Tamaño de la etapa
noStroke (); // Sin borde en la siguiente cosa dibujada
// Establecer la posición inicial de la bola (en medio del escenario)
xpos = ancho / 2;
ypos = altura / 2;
// Imprime una lista de los puertos serie, con fines de depuración:
println (Serial. lista ());
// Sé que el primer puerto de la lista de serie en mi mac
// es siempre mi adaptador FTDI, entonces abro Serial.list () [0].
// En máquinas Windows, esto generalmente abre COM1.
// Abra el puerto que esté usando.
String portName = Serie. lista () [0];
myPort = new Serial ( this , portName, 9600);
}
vacío dibujar () {
fondo (bgcolor);
relleno (fgcolor);
// Dibuja la forma
elipse (xpos, ypos, 20, 20);
}
void serialEvent (Serial myPort) {
// lee un byte del puerto serie:
int inByte = myPort.read ();
// si este es el primer byte recibido y es una A,
// borra el búfer serial y observa que has
// Tuvo el primer contacto del microcontrolador.
// De lo contrario, agregue el byte entrante a la matriz:
if (firstContact == false ) {
if (inByte == 'A' ) {
myPort.clear (); // limpia el búfer del puerto serie
firstContact = true ; // has tenido el primer contacto del microcontrolador
myPort.write ( 'A' ); // Pregunta por más
}
}
demás {
// Agrega el último byte del puerto serie a la matriz:
serialInArray [serialCount] = inByte;
serialCount ++;
// Si tenemos 3 bytes:
if (serialCount> 2) {
xpos = serialInArray [0];
ypos = serialInArray [1];
fgcolor = serialInArray [2];
// imprime los valores (solo con fines de depuración):
println (xpos + "t" + ypos + "t" + fgcolor);
// Envíe una A mayúscula para solicitar nuevas lecturas del sensor:
myPort.write ( 'A' );
// Restablecer serialCount:
serialCount = 0;
}
}
}
Haga clic en el botón Ejecutar para ejecutar el boceto de procesamiento y aparecerá un subprograma. El subprograma tiene un fondo negro y cada vez que presiona el botón, aparece un punto blanco. Mueva los potenciómetros para mover el punto horizontal y verticalmente. Cuando suelta el botón, el punto desaparece.