ARDUINO + PROCESSING: PRIMEROS PASOS

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.


41 thoughts on “ARDUINO + PROCESSING: PRIMEROS PASOS

  • Pingback: ARDUINO + PROCESSING: PRIMEROS PASOS | tecno4 |...

  • Pingback: ARDUINO + PROCESSING: PRIMEROS PASOS - DIYMaker...

  • Pingback: ARDUINO + PROCESSING: PRIMEROS PASOS - DIYMaker...

  • Pingback: ARDUINO + PROCESSING: PRIMEROS PASOS | Arduino ...

  • Avatar

    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.

    Reply
    • Avatar

      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

      Reply
  • Avatar

    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

    Reply
  • Avatar

    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.

    Reply
    • Avatar

      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.

      Reply
  • Avatar

    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.

    Reply
    • Avatar

      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).
      }
      }

      Reply
      • Avatar

        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

        Reply
  • Avatar

    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.

    Reply
  • Avatar

    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.

    Reply
  • Avatar

    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.

    Reply
  • Avatar

    miguel

    Hola, gran trabajo, necesito hacer solo la lectura de la termocupla con el dibujor el circulo, pordrias resaltar esta parte, muy agradecido

    Reply
  • Pingback: Arduino | Pearltrees

  • Avatar

    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.

    Reply
  • Avatar

    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

    Reply
  • Avatar

    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

    Reply
  • Avatar

    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

    Reply
  • Avatar

    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.

    Reply
  • Avatar

    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

    Reply
  • Avatar

    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

    Reply
  • Avatar

    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);
    }
    }

    Reply
  • Avatar

    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 ..

    Reply
  • Avatar

    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

    Reply
  • Avatar

    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.

    Reply
  • Avatar

    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

    Reply
  • Avatar

    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.

    Reply
  • Pingback: Ejemplo En Processing – Sobreviviendo a la materia Arquitectura de Computadoras

  • Avatar

    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.

    Reply
  • Avatar

    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?

    Reply

Deja un comentario