image1.jpg

Cómo enviar múltiples señales desde Arduino al procesamiento

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.

image0.jpg

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.

image1.jpg

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.

LEER  Generador de patrones de cubos LED

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.

LEER  11 grandes recursos de Arduino

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *