ARDUINO + PROCESSING: PRIMEROS PASOS
(5/1/13)
En este tutorial veremos que es Processing, aprenderemos sus funciones más básicas y como comunicarse con Arduino.
Material
-Arduino Uno Rev 3
-Software Processing (descargar aquí)
-Sensor de temperatura LM35
-Led
-Resistencia 220 ohms
¿Qué es Processing?
Processing es un lenguaje de programación y entorno de desarrollo integrado de código abierto basado en Java. Fue iniciado por Ben Fry y Casey Reas a partir de reflexiones en el Aesthetics and Computation Group del MIT Media Lab dirigido por John Maeda.
Una vez instalado Processing en el PC, veréis que es muy similar al IDE de Arduino, ya que este está basado en Processing. Solo cambia el botón PLAY que sirve para arrancar el entorno creado con el programa, y el botón STOP que sirve para pararlo.
Es muy común usar Processing con Arduino para crear un entorno de visualización de datos mucho más atractivo visualmente y con más posibilidades que si usamos el Monitor Serial del IDE de Arduino.
Funciones y elementos básicos de Processing
Primero de todo hay que saber cómo se programa en Processing. Veréis que la estructura del programa es muy similar a un programa de Arduino. Como Processing es un entorno de desarrollo basado Java, existen muchas funciones para crear formas y figuras visuales.
Primero de todo hay que saber que la pantalla de visualización que creamos con Processing es un gráfico de píxeles, cada uno registrado con una coordenada (X, Y). El origen del gráfico está situado a la esquina izquierda arriba con las coordenadas (0, 0). Si sumamos a X, nos desplazamos a la derecha. Si sumamos a Y, nos desplazamos hacia abajo.
-setup() Función de arranque cuando el programa empieza. Igual que Arduino.
-draw() Bucle que se ejecuta cíclicamente siempre. Como el loop() de Arduino.
-size(x, y); Con esta función, Processing crea una ventana de X píxeles por Y píxeles. En esta ventana crearemos nuestro entorno gráfico.
-background(0,0,0); Determina el color del fondo de la ventana creada en modo RGB
-stroke(0,0,0); Función de trazo (bordes) que permite cambiar el color del dibujo actual en modo RGB. Cada función de dibujo llamada después de stroke tendrá el color de este.
-noStroke(); Sin bordes.
-point(x, y); Crea un punto en la posición x, y del gráfico.
-line(x1, y1, x2, y2); Crea una línea. Los dos primeros valores son la primera coordenada X, Y. Los dos últimos valores son la última coordenada X, Y.
-triangle(x1,y1,x2,y2,x3,y3); Dibuja un polígono de tres puntas. Tiene seis valores que son las tres coordenadas de las tres puntas.
-quad(x1,y1,x2,y2,x3,y3,x4,y4); Dibuja un polígono de cuatro puntas. Los ocho valores son las cuatro coordenadas de las cuatro puntas.
-rect(x, y, width, height); Dibuja un rectángulo. Los dos primeros valores es la posición X, Y en el gráfico. Los dos últimos valores son la anchura y la altura respectivamente.
-ellipse(x, y, width, height); Dibuja una circulo. Los valores funcionan de la misa manera que rect.
-fill(0,0,0); Llena del color indicado la figura.
-noFill(); Sin llenar de color.
-text(“texto”,x,y); Escribe un texto en la posición X, Y deseada.
-mousePressed(); Función llamada cada vez que se aprieta el botón del ratón.
-mouseReleased(); Función llamada cada vez que el botón del ratón no está apretado.
-KeyPressed(); Función llamada cada vez que se aprieta una tecla del teclado.
-year() Retorna el año actual del reloj del PC
-month() Retorna el mes actual del reloj del PC
-day() Retorna el día actual del reloj del PC
-hour() Retorna la hora actual del reloj del PC
-minute() Retorna el minuto actual del reloj del PC
-second() Retorna el segundo actual del reloj del PC
Arduino y Processing: Comunicación a través del puerto serie
Ahora que ya sabemos las funciones más básicas de Processing, vamos a hacer un pequeño proyecto donde comunicaremos Arduino y Processing con el puerto serie (en este enlace tenéis el tutorial que hicimos sobre el puerto serie de Arduino).
El proyecto tiene varias partes:
-Tenemos un sensor de temperatura LM35 conectado a Arduino que envía los datos de la temperatura para que Processing los visualice con un texto y con un circulo al lado que cambia de color según la temperatura (tonalidad azul-gris cuando la temperatura es baja y tonalidad roja cuando la temperatura es alta). Además, Processing guarda los valores de la temperatura en un archivo de texto.
-En el entorno de Processing creamos un botón que al pulsarlo cambio el estado de un led conectado a Arduino.
-El logo de DIYMakers situado arriba al centro del entorno de Processing, lo podemos mover usando las teclas del teclado: W (arriba), S (abajo), D (derecha), A (izquierda).
-Cuando pulsamos la tecla E del teclado, el entorno gráfico se cierra.
Preparar Arduino
Primero de todo, vamos a encargarnos del harware del Arduino conectando el sensor de temperatura LM35 y el Led.
Sensor temperatura LM35
Es un sensor analógico de temperatura, con un rango de de -55ºC a +150ºC y en su salida da 10mV por cada grado centígrado. Para hacer la lectura de la temperatura en grados centígrados, en el programa de Arduino tenemos que hacer una sencilla fórmula matemática. Primero de todo, tenemos el sensor conectado a una entrada analógica del Arduino (que recordemos son de 10 bits). El voltaje de salida del sensor es interpretado por el Arduino con valores (donde 0V es 0 y 5V es 1023). Para poder convertir estos valores nuevamente a voltios, hay que multiplicar el valor por 5 (que son los 5 Voltios máximos de señal que da el sensor) y dividirlo por 1023 que es el entero más grande en un rango de 10 bits. Luego tenemos que convertir este voltaje en grados centígrados. Ahora tenemos que 10mV son 1ºC. Si multiplicamos estos 10mV por 100, tendremos que 1V son 1ºC. La formula final sería la siguiente:
Programa Arduino
/*
www.diymakers.es
by A.García
Arduino + Processing: Primeros Pasos
Tutorial en: http://diymakers.es/arduino-processing-primeros-pasos/
*/
int led=9;
int temp;// Variable sensor de temperaura
boolean status=LOW; //Estado del led
void setup()
{
Serial.begin(9600);
pinMode(led,OUTPUT);
}
void loop()
{
temp = analogRead(A0); //Lee los datos del sensor LM35
temp = (5.0 * temp * 100)/1023.0;//Formula para convertir a ºC
Serial.write(temp); //Enviamos los datos en forma de byte
delay(100);
if(Serial.available()>0)//Si el Arduino recibe datos a través del puerto serie
{
byte dato = Serial.read(); //Los almacena en la variable "dato"
if(dato==65) //Si recibe una "A" (en ASCII "65")
{
status=!status; //Cambia el estatus del led
}
digitalWrite(led,status);
}
}
Programa Processing
/*
www.diymakers.es
by A.García
Arduino + Processing: Primeros Pasos
Tutorial en: http://diymakers.es/arduino-processing-primeros-pasos/
*/
import processing.serial.*; //Importamos la librería Serial
Serial port; //Nombre del puerto serie
PrintWriter output; //Para crear el archivo de texto donde guardar los datos
int rquad=40; //Radio del quadrado
int xquad=200; //Posición X de rect
int yquad=200; //Posición Y de rect
boolean overRect = false; //Estado del mouse si está encima de rect o no
//Colores del botón
int red=100;
int green=100;
int blue=100;
boolean status=false; //Estado del color de rect
String texto="LED OFF";//Texto del status inicial del LED
int xlogo=400;//Posición X de la imagen
int ylogo=50;//Posición Y de la imagen
int valor;//Valor de la temperatura
//Colores esfera temperatura
float rojo;
float verde;
float azul;
void setup()
{
println(Serial.list()); //Visualiza los puertos serie disponibles en la consola de abajo
port = new Serial(this, Serial.list()[1], 9600); //Abre el puerto serie COM3
output = createWriter("temeratura_datos.txt"); //Creamos el archivo de texto, que es guardado en la carpeta del programa
size(800, 400); //Creamos una ventana de 800 píxeles de anchura por 600 píxeles de altura
}
void draw()
{
background(255,255,255);//Fondo de color blanco
if(mouseX > xquad-rquad && mouseX < xquad+rquad && //Si el mouse se encuentra dentro de rect
mouseY > yquad-rquad && mouseY < yquad+rquad)
{
overRect=true; //Variable que demuestra que el mouse esta dentro de rect
stroke(255,0,0); //Contorno de rect rojo
}
else
{
overRect=false; //Si el mouse no está dentro de rect, la variable pasa a ser falsa
stroke(0,0,0); //Contorno de rect negro
}
//Dibujamos un rectangulo de color gris
fill(red,green,blue);
rectMode(RADIUS); //Esta función hace que Width y Height de rect sea el radio (distancia desde el centro hasta un costado).
rect(xquad,yquad,rquad,rquad);
//Creamos un texto de color negro con la palabra LED
fill(0,0,0);
PFont f = loadFont("Calibri-48.vlw");//Tipo de fuente
textFont(f, 20);
text(texto, 170, 270);
//Ponemos la imagen de nuestro logo
imageMode(CENTER);//Esta función hace que las coordenadas de la imagne sean el centro de esta y no la esquina izquierda arriba
PImage imagen=loadImage("logo.jpg");
image(imagen,xlogo,ylogo,200,100);
//Recibir datos temperatura del Arduino
if(port.available() > 0) // si hay algún dato disponible en el puerto
{
valor=port.read();//Lee el dato y lo almacena en la variable "valor"
}
//Visualizamos la temperatura con un texto
text("Temperatura =",390,200);
text(valor, 520, 200);
text("ºC",547,200);
//Escribimos los datos de la temperatura con el tiempo (h/m/s) en el archivo de texto
output.print(valor + " ºC ");
output.print(hour( )+":");
output.print(minute( )+":");
output.println(second( ));
output.println("");
//Esfera color visualización temperatura
float temp = map (valor, 15,32, 0, 255);//Escalamos la temperatura donde maximo sea 32ºC y mínimo 15ºC
rojo=temp;
verde=temp*-1 + 255;
azul=temp*-1 + 255;
//Dibujamos una esfera para colorear la temperatura
noStroke();
fill(rojo,verde,azul);
ellipseMode(CENTER);
ellipse(590,193,20,20);
}
void mousePressed() //Cuando el mouse está apretado
{
if (overRect==true) //Si el mouse está dentro de rect
{
status=!status; //El estado del color cambia
port.write("A"); //Envia una "A" para que el Arduino encienda el led
if(status==true)
{
//Color del botón rojo
red=255;
green=0;
blue=0;
texto="LED ON";
}
if(status==false)
{
//Color del botón negro
red=100;
green=100;
blue=100;
texto="LED OFF";
}
}
}
void keyPressed() //Cuando se pulsa una tecla
{
if(key=='w'||key=='W')
{
ylogo--; //El logo se deplaza hacia arriba
}
else if(key=='s'||key=='S')
{
ylogo++; //El logo se deplaza hacia abajo
}
else if(key=='a'||key=='A')
{
xlogo--; //El logo se desplaza hacia la izquierda
}
else if(key=='d'||key=='D')
{
xlogo++; //El logo se desplaca hacia la derecha
}
//Pulsar la tecla E para salir del programa
if(key=='e' || key=='E')
{
output.flush(); // Escribe los datos restantes en el archivo
output.close(); // Final del archivo
exit();//Salimos del programa
}
}
Partes más destacadas del programa de Processing
-Hay que cambiar el índice de Serial.list()[1] por el índice correspondiente al puerto serie que está conectado el Arduino. En la consola de abajo se pude ver el índice una vez iniciado el entorno gráfico.
–output=createWriter(“temperatura_datos.txt”); es el archivo de texto donde se guardan los datos de la temperatura. Se guarda dentro de la misma carpeta donde se guarda el código de Processing. El nombre entre comillas es el nombre del archivo y se puede poner cualquiera.
-Esta parte sirve para detectar cuando el mouse se encuentra dentro del botón para cambiar el estado del led. Se tiene que ajustar las coordenadas exactas de toda la superficie del rectángulo. Tenemos que el centro del rectángulo está en la posición (200,200), si le restamos el radio del rectángulo (que es 40 píxeles) tendremos el límite izquierdo y límite inferior del rectángulo. Y si le sumamos el radio, tendremos el límite derecho y límite superior.
–PFont f=loadFont(“Calibri-48.vlw”); Con esta función podemos poner el tipo de fuente para el texto. Tenemos que ir a Tools, Create Font…, seleccionar la fuente deseada, pulsar Ok, y Processing creará una carpeta llamada data dentro de la carpeta del código donde guardará el tipo de fuente. Luego tenemos que poner el nombre del tipo de fuente que hemos seleccionado dentro de las comillas de la función.
–PImage imagen=loadImage(“logo.jpg”); Sirve para cargar una imagen en el entorno gráfico. Dicha imagen tenemos que guardarla dentro de la carpeta data. Entre comillas hay que poner el nombre de la imagen. La siguiente línea sirve para determinar la posición de la imagen y las dimensiones.
-Esta parte sirve para calibrar el valor de la temperatura para visualizarla en forma de color con la figura ellipse. Primero de todo tenemos que establecer el rango de temperatura que queremos, en nuestro caso vamos desde 15ºC de mínima hasta 32ºC de máxima. Mapeamos estos valores en un rango de 0 a 255 que es el rango necesario para los valores del color RGB. Una vez esto, tenemos que hacer que el color pase de una tonalidad azul-gris cuando la temperatura es mínima, hasta una tonalidad roja cuando la temperatura es máxima. Si nos fijamos en los colores RGB, vemos que para pasar de una tonalidad a otra, el color Red va invertido respecto a los colores Green y Blue. Por esto, tenemos que invertir los valores de Green y Blue y restarlos con 255.
-Cuando finalizamos el entorno gráfico pulsando la tecla “E”, el archivo de texto donde se guardan los valores de temperatura del sensor finaliza. Si lo abrimos nos aparecerá lo siguiente.
pionner123
Muy bueno el tutorial. Muy completo. El único defecto que hay es que se cortan las palabras cuando se cambia de linea.
DIYMakers Post author
Gracias pionner123. El problema con las palabras que se cortan es por culpa del Firefox. En el Chrome no pasa.
Pingback: ARDUINO + PROCESSING: PRIMEROS PASOS | tecno4 |...
Pingback: ARDUINO + PROCESSING: PRIMEROS PASOS - DIYMaker...
Pingback: ARDUINO + PROCESSING: PRIMEROS PASOS - DIYMaker...
Pingback: ARDUINO + PROCESSING: PRIMEROS PASOS | Arduino ...
Víctor
hola buenas. Muy buen tutorial me ayudara bastante en un proyecto que tengo que hacer. hay una duda que tengo que no he podido aclarar. Cual es la acción (codigo) que se le indica a processing para decir que hemos precionado el botón. Lo que quiero hacer, es que al precionar el boton este cambie de color y al soltar el botón vuelva a su color original( independiente de si el curso aún esta dentro del botón). Espero que me haya explicado bien. Saludos estimado.
jose
Muy facil amigo.
No vi ninguna funcion que te devuelva si esta el raton presionado pero lo que si utiliza el codigo del ejemplo es la funcion …
void mousePressed() {
«Codigo que se ejecuta cuando presionas el raton»
}
que se activa y ejecuta durante el tiempo que presionas el raton. Así que usaremos eso para saber cuando está presionado y cuando no. Como? Pues sencillo, utilizando una variable booleana que se pondra en 1 cuando este presionado y se pondra en 0 cuando no.
m1=0; //Si no se presiona tomará el valor 0
void mousePressed(){
m1=1;
} // si se presiona tomará el valor 1
Cuidado con la posicion de la variable booleana ya que tiene que estar posicionada justo antes de la funcion void mousepressed y nunca despues ni un poco antes….justo antes.
Un saludo
jose
Muy facil amigo.
No vi ninguna funcion que te devuelva si esta el raton presionado pero lo que si utiliza el codigo del ejemplo es la funcion …
void mousePressed() {
«Codigo que se ejecuta cuando presionas el raton»
}
que se activa y ejecuta durante el tiempo que presionas el raton. Así que usaremos eso para saber cuando está presionado y cuando no. Como? Pues sencillo, utilizando una variable booleana que se pondra en 1 cuando este presionado y se pondra en 0 cuando no.
m1=0; //Si no se presiona tomará el valor 0
void mousePressed(){
m1=1;
} // si se presiona tomará el valor 1
Cuidado con la posicion de la variable booleana ya que tiene que estar posicionada justo antes de la funcion void mousepressed y nunca despues ni un poco antes….justo antes.
Un saludo
wilmer
Una consulta estoy realizando un proyecto de comunicación de processing con arduino y voy a verificar el funcionamiento de el código para orientarme en el proyecto que estoy planeando y a lo que lo cargo en processing me muestra un error. En la afirmación (port = new Serial(this, Serial.list()[1], 9600); //Abre el puerto serie COM3) no he podido dar que es.Agradezco su colaboración.
Pablo
Esta intrucción es para abrir el puerto en el que está conectado nuestro Arduino. El primer puerto es el [0], el segundo el [1], el tercero el [2]… el autor del proyeto tiene conectado el COM3 en el segundo puerto [1]. Tu caso puede ser diferente. p.e. en mi caso tengo la placa de arduino en el COM13 que es el primer puerto. Por lo tanto escribo: «port = new Serial(this, Serial.list()[0], 9600); //Abre el puerto serie COM13)»
Tienes dos opciones para solucionarlo, la primera es hacer que processing te de la lista de uso de puertos que lo puedes hacer con el siguiente sketch:
/*
* Test de Puertos utilizados
*/
import processing.serial.*;
import cc.arduino.*;
Arduino arduino;
void setup() {
size(200, 200);
noLoop(); // Fuerza a no realizar el bucle del programa
println(Arduino.list()); // Imprime la lista de puertos COM
}
void draw() {
}
Una vez ejecutado te dará los puertos. Por ejemplo [0] COM7 , [1] COM 11 y [2] COM 13. Metiéndote en el editor de arduino en la esquina inferiror izquierda verás en que puerto está conectada la placa y sabrás que escribir en el sketch de processing.
La otra opción es tantear.
Hay otro problema por el que puede que no logres la conexión. Es por no tener correctamente instalada la librería RXTX dentro de processing/java/bin, tanto rxtxParallel.dll como rxtxSerial.dll. Estas librerias las puedes descargar, si no lo has hecho todavía, desde http://rxtx.qbang.org/wiki/index.php/Download. En mi caso he instalado para processing 2.2.1 bajo Windows la rxtx 2.0-7pre2 (stable) -win32 (incomplete)-
Por último, para completar. No olvides instalar la librería de arduino para processing (y firmata). Se intala por supuesto como cualquier librería de arduino y está en http://playground.arduino.cc/interfacing/processing. Instala la de la versión de processing que tengas.
vihuesgo
yO LO CAMBIE COMO SIGUE: port = new Serial(this, «COM5», 9600); //Abre el puerto serie COM5
Antonio
Estoy con un proyecto donde necesito ver gráficamente dos señales analógicas de Arduino para compararlas, sabeis si existe algun ejemplo ya hecho.
Pablo
Para hacer esto te recomiendo lo siguiente:
En el sketch de arduino, dentro del void loop () tienes que escribir los valores en el puerto serie separados por comas y añadir un salto de línea al final de los valores. No utilices el primer valor porque da problemas. Un ejemplo sería el siguiente:
Serial.print (0); // Para dejar un cero en el primer valor y evitar problemas.
Serial.print («,»);
Serial.print (valor_1);
Serial.print («,»);
Serial.println (valor_2); // Ponemos un salto de línea en el último valor.
delay (20); // Retraso para no saturar el puerto serie.
En el sketch de processig, después de abrir el puerto como se ha indicado anteriormente ponemos lo siguiente en el void draw ():
puerto.bufferUntil(‘\n’); // No se leen los datos del puerto serie hasta que aparece un salto de línea.
String cadena_de_datos = puerto.readStringUntil(‘\n’); // Almacenamoe en «cadena_de_datos» los datos que manda arduino hasta el salto de línea.
if (cadena_de_datos != null){ // Si la «cadena_de_datos» no está vacía…
cadena_de_datos = trim(cadena_de_datos); //… borramos de la «cadena_de_datos» los espacios en blanco.
int [ ] valores = int(split (cadena_de_datos,»,»)); //… dividimos la «cadena_de_datos» en un array de número enteros.
if (valores.length >= 3) { // Después de verificar que hemos recibido los tres valores (como sabemos el primer valor [0] es cero para evitar problemas).
valor_1 = valores [1]; // Asignamos el segundo valor [1] a la variable valor_1 (no nos debemos de olvidar crearla antes en el sketch de processing).
valor_2 = valores [2]; // Asignamos el segundo valor [1] a la variable valor_1 (no nos debemos de olvidar crearla antes en el sketch de processing).
}
}
Raul Rojo
hola que tal al tratar de hacer esto me encuentro con el problema «unexpected char: ‘\'» al correr el codigo en esta linea puerto.bufferUntil(‘\n’); // No se leen los datos del puerto serie hasta que aparece un salto de línea., nose si esta mal declarado o que se debe de hacer para corregirlo ,actualemtne trabajo en un proyecto que involucra un giroscopio con un sensor de temperatura y humedad saludos
mario more
Hola, muy buen proyecto, podrás explicarme que es el tipo de fuente y el Logo esta hecho con programación o es un diseño gráfico guardado en ese archivo? con que función podría agregarle un beep o sonido en la PC como una alarma cuando pase de cierta temperatura. Gracias amigo.
Pablo
El tipo de fuente lo tienes en Processing: Tools/Create Font/Calibri (Size 48).
La fuente se crea en la carpeta del Sketch. La puedes localizar en Sketch/Show Sketch Folder. Está dentro de la carpeta «data».
El logo es un fichero .jgp (en este caso el logo de diymakers), pero podría ser cualquier fichero .jpg que también se tiene que insertar dentro de esta carpeta.
La alarma con un poco de ingenio la podrás poner.
Francisco Fernández
Felicidades por el tutorial: Un trabajo estupendo.
lucia
Buenas.
Quisiera saber como hacer para mostrar la misma hora del archivo txt en la interfaz de processing. es decir que muestre tanto en pantalla como en el archivo la hora en que se guarde la temperatura.
soldado99
que buena forma de aprender ojala sigan publicando proyectos como este
Alex Guerrero
ola buenas noche buen tutorial me podría por favor decir como podría mostrar dos valores de temperatura
miguel
Hola, gran trabajo, necesito hacer solo la lectura de la termocupla con el dibujor el circulo, pordrias resaltar esta parte, muy agradecido
Pingback: Arduino | Pearltrees
Mario
Te felicito por el tutorial, muy claro, me ha servido. Un abrazo.
Fernando
Hola. Excelente tutorial. Hace un par de semanas que espesé con arduino y ahora veo la posibilidad de interfaz gráfica con la PC. Buenísimo.
Saludos.
Ricardo
Hola. Estoy haciendo mi tesis sobre arte generativo en Processing y pienso usar sensores de movimiento y presión y mi duda es si tengo que usar la interfaz de Arduino para poder aplicarlos, aunque creo que lo obvio es que sí. Saludos
carlos
se puede hacer que desde la matricial de numero del arduino pueda escribir en word o en facebook en mi compu, algo asi como convertir mi arduino en un teclado para la compu
jose
Hola ricardo. Sobre usar sensores de movimiento y presión no te hace falta el hardware de Arduino ya que podrías simular esos movimientos (x,y, o incluso z) y la presión que es un solo valor. Cómo lo harías? ….bien simplemente usando variables aleatorias. Yo no he mirado si processing tiene ese tipo de variables que se suelen llamar random. A cada valor que quieras simular se le asignaría una variable de ese tipo que suele ser tan grande como la maxima capacidad de el tipo de datos que use esa variable. Ejemplo un bit (no un byte que es diferente) tiene dos posibilidades 0 y 1 ,,,true false etc… entonces esa variable random usando ese tipo de datos estaría variando su valor entre cero o uno aleatoriamente,,,,si le asignaras un tipo de datos por ejemplo de byte que son 10 bits creo pues tendrías 1024 posibilidades desde el numero 0 hasta el numero 1023 siempre y cuando sea positivo el tipo de datos, en caso de positivo y negativo se repartiría a partes iguales desde -512 hasta +511. Si la variable en cuestión es muy grande para tus valores lo que podrías hacer es mapearlo que es lo que se ha realizado aquí con la temperatura ( una simple regla de tres). Al valor máximo que tu quieras tener en tu coordenada X le asignarías 1023 y al mínimo 0.
Bueno lo importante es buscar si processing tiene esa variable random para utilizarla (99,99% si) y después aplicar la lógica sobre esa variable en función de lo que quieras simula. Evidentemente en el proyecto indicarías que se trata de una simulación para abaratar costes ya que tu objetivo no es el hardware sino el proceso gráfico.
Un Saludo
Said
La fórmula para calcular la temperatura tiene que ser:
temp = (5 * temp * 100)/1024;
Ya que la variable «temp» es un integer y no puede almacenar decimales.
andres
hola…
Estoy haciendo un proyecto que trata de mover un auto por vía de coordenadas dentro de una habitación, donde al auto le doy un punto y el auto se dirija al punto sin estar controlando. Mi duda es que si este programa me serviría como interfaz para el mapa de coordenadas y con la comunicación con arduino
yare
Hola, tengo una duda. Seguí tu tutorial y todo ha quedado de lujo, existe la posibilidad de que pulsando un botón en la placa de arduino mande señal a processing para realizar la acción de poner un cuadro y cada de pulse el botón cambie de color? estoy atorada en esta parte. te agradecería mucho tu ayuda. Saludos
Alejandra Hernández
HOLA.
Estoy haciendo un proyecto se trata de unir arduino y processing.
Es hacer sonar un buzzer con notas a la par que se activa un efecto de
GlitchP5 glitchP5 en Capture cam con el mouse, no he podido activar el buzzer con el mouse.
Me pudieran ayudar hoy entrego mi práctica y no he encontrado el problema.
Es urgente.
Les copio el código
Gracias
CÓDIGO PROCESSING
import processing.serial.*; //importar la libreria de serie
Serial myPort; //el objeto de puerto serie
String val;
String va;
// ya que estamos haciendo establecimiento de comunicación en serie,
// tenemos que comprobar si hemos oído desde el microcontrolador
boolean firstContact = false;
import processing.video.*;
import glitchP5.*;
Capture cam;
GlitchP5 glitchP5;
void setup() {
size(640, 480); //hacer su lienzo 200 x 200 píxeles grande
// inicializar el puerto serie y establecer la velocidad de transmisión de 9600
myPort = new Serial(this, Serial.list()[9], 9600);
myPort.bufferUntil(‘\n’);
frameRate (30);
cam= new Capture(this,width, height);
cam.start();
glitchP5 = new GlitchP5(this);
}
void draw() {
if(cam.available()){
cam.read();
}
image(cam,0,0);
glitchP5.run();
}
void serialEvent( Serial myPort) {
//poner los datos entrantes en una secuencia –
//el ‘\ n’ es nuestra delimitador de fin que indica el final de un paquete completo
val = myPort.readStringUntil(‘\n’);
//asegúrese de que sus datos no está vacía antes de continuar
if (val != null) {
//recortar espacios en blanco y caracteres de formato (como el retorno de carro)
val = trim(val);
println(val);
//buscar nuestra ‘A’ cadena para iniciar el apretón de manos
//si está allí, borrar el búfer, y enviar una solicitud de datos
if (firstContact == false) {
if (val.equals(«A»)) {
myPort.clear();
firstContact = true;
myPort.write(«A»);
println(«contact»);
}
}
else { //Si ya hemos establecido contacto, seguir recibiendo y analizar los datos
println(val);
if (mousePressed == true)
{ //si hicimos clic en la ventana
myPort.write(‘1’); //envia a 1
println(«1»);
}
// Una vez que supere los datos que tiene, pedir más:
myPort.write(«A»);
}
}
va = myPort.readStringUntil(‘\n’);
//asegúrese de que sus datos no está vacía antes de continuar
if (va != null) {
//recortar espacios en blanco y caracteres de formato (como el retorno de carro)
va = trim(va);
println(va);
//buscar nuestra ‘A’ cadena para iniciar el apretón de manos
//si está allí, borrar el búfer, y enviar una solicitud de datos
if (firstContact == false) {
if (val.equals(«A»)) {
myPort.clear();
firstContact = true;
myPort.write(«A»);
println(«contact»);
}
}
else { //Si ya hemos establecido contacto, seguir recibiendo y analizar los datos
println(va);
if (mousePressed == true)
{ //si hicimos clic en la ventana
myPort.write(‘1’); //envia a 1
println(«1»);
}
// Una vez que supere los datos que tiene, pedir más:
myPort.write(«A»);
}
}
}
void mousePressed(){
//posX, posY, posJitterX. porJitterY, sizeX, sizeY, numero de fallos, variación decimal,
// tiempo máximo en frames, el tiempo máximo hasta que el fallo desaparezca
glitchP5.glitch (mouseX, mouseY, 500,300, width, height, 5,1.0f,30,30);
if (mousePressed == true)
{ //si hicimos clic en la ventana
myPort.write(‘1’); //envia a 1
println(«1»);
}
}
CÓDIGO ARDUINO
char val; // Data received from the serial port
int ledPin = 13; // Set the pin to digital I/O 13
boolean ledState = LOW; //to toggle our LED
int LED1= 8;
int LED2= 9;
int LED3= 10;
int buzzerPin = 11;
// Definimos una variable con el número de tonos que va a reproducir
int numTonos = 7; //numero de datos contenidos en el arreglo
int tonos[] = {261, 294, 329, 349, 392, 440, 493, 523}; //arreglo con valores enteros (representan los tonos.)
// {Do Re Mi Fa Sol la Si do}
void setup() {
// inicializa variables LED como salidas digitales
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
pinMode(ledPin, OUTPUT); // Set pin as OUTPUT
//initialize serial communications at a 9600 baud rate
Serial.begin(9600);
for (int i = 0; i 0) { // If data is available to read,
val = Serial.read(); // read it and store it in val
if(val == ‘1’) //if we get a 1
{
ledState = !ledState; //flip the ledState
digitalWrite(ledPin, ledState);
}
delay(100);
}
else {
Serial.println(«Hello, world!»); //send back a hello world
delay(50);
}
}
void establishContact() {
while (Serial.available() <= 0) {
Serial.println("A"); // send a capital A
delay(300);
}
}
carolina vm
buenos dias mi nombre es carolina y actualmente estoy desarrollando un proyecto donde involucro estos dos componentes que son arduino + processing.. y lo que necesito es que en vez de prender el led lo que prende por medio del sensor de proximidad sea un video y que cuando la persona no este este video se detenga .. pero no se como seria el codigo .. si me podrian ayudar se los agradeceria ..
gustavo
excelente tutorial pero habria manera de que solo te diera el archivo de texto sin la pantalla ni lo demas solo el puro archivo con los valores del sensor
Gomez
Buenas tardes, en la parte esta del código println(Serial.list()); //Visualiza los puertos serie disponibles en la consola de abajo, me sale este error «type string of the last argument to method println» he buscado y no he dado para arreglarlo, agradezco si me pueden ayudar.
Natalia Urdiales
Hola, gracias por leerme, necesito AYUDA. Mi hijo debe hacer en processing los codigos para que avispas recorran la pantalla, no lo entiendo, pueden ayudarme URGENTE,rinde el lunes, asi puede estudiarlo, mas que agradecida.
Natalia
Elvis-e Esono
Hola estoy con un proyecto de arduino +processing donde debo visualizar grficamente los datos ke me da el sensor de temperatura variando los colores para caso y usando 3 leds…y un potenciometro.
Pingback: Ejemplo En Processing – Sobreviviendo a la materia Arquitectura de Computadoras
Marcos Alvarez
Hola muy buen tuto, como se podría exportar los datos de temp a un excel y no a un archivo de texto. gracias.
jessica velasquez
hola buenas tardes como uno arduino+ processing con un modulo ad8232 para visualizar la grafica
Jeriel alanis
Hola saludos,estoy haciendo un proyecto en proccesing y Arduino, para controlar la velocidad y cambio de giro de un motor a pasos, pero no logro hacer que funcione, ya hice que funcionara con un motor DC, tendrás un correo para enviarte los códigos que llevo?