sábado, 25 de junio de 2016

Graficando valores de arduino en Processing 2a. parte

Que tal amigos, en esta ocación quisiera compartir la continuación del minitutorial para graficar valores del arduino en processing, la primera parte esta aqui, y esta segunda parte trata de visualizar mas de un valor, el código que les comparto permite 2 valores pero se puede adaptar facilmente para 3 o más.

En primer lugar el código del arduino debe enviar al puerto serie los valores que queremos desplegar separados por comas, en este pequeño ejemplo genero los valores de forma aleatoria ya que no tengo un sensor a la mano, algo importante es el retardo (delay(300);) este retardo se debe sincronizar con el código del processing para visualizar correctamente la gráfica.


void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
  // Genero valores aleatorios, o los recupero de un sensor
  float humedad = random(10,450);
  float temperatura = random(10,450);

  // Envio los valores al serial separados por coma
  Serial.print(humedad/10);
  Serial.print(",");
  Serial.print(temperatura/10);
  Serial.println();

  delay(300);
}

Aquí vemos como se envían los valores al monitor serial del arduino:


A continuación el código de processing que nos permite visualizar una gráfica de cada uno de los valores recibidos, cada gráfica se muestra en un color distinto, el código se modificó para ejecutarse correctamente en Processing 3.1 y no se probó para ninguna otra versión.



import processing.serial.*;

Serial myPort;    // The serial port
String inString;  // Input string from serial port
int lf = 10;      // ASCII linefeed
float x1 = 0;
float x2;
float y1;
float y2 = height / 2;
int xPos = 1; 

void setup() {
  size(800,600);
  // List all the available serial ports:
  printArray(Serial.list());
  // Open the port you are using at the rate you want:
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil(lf);
  background(0);
  // Tamaño del texto
  textSize(30);
}

   String[] lista;
   float[] listaY = new float[10];
   // Agregar color si se grafican mas de 3 valores
   int[] colores = { #CCFFAA , #CC00AA , #00FFAA };

void draw() {

  if (inString != null) {
   // trim off any whitespace:
   inString = trim(inString);
   
   // Pinta un rectangulo en la esquina superior izquierda con fondo negro
   fill(0);
   rect(0, 0, 220, 100);
   // Imprime la lista de valores recibidos ( Ampliar el rectangulo si se reciben mas de 2 valores )
   fill(204, 102, 0);
   text(inString, 10, 80); 
   
   // Separa los valores recibidos ( la coma es el separador estandar )
   lista = split(inString, ',');
   // Mostrar lista 
   printArray(lista);
   // Recorre la lista de valores
   for (int i=0; i < lista.length; i++) {      
     // Convierte el valor en su representacion numerica ( Float )
     float inByte = float(lista[i]); 
     // Recupera el valor guardado de la iteracion anterior para usarlo como coordenada
     y1 = listaY[i];
     
     // convert to an int and map to the screen height:
     inByte = map(inByte, 0, 70, 0, height);
  
     // draw the line:
     stroke(colores[i]);
     
     y2 = height - inByte;
     
     line(xPos - 5, y1, xPos, y2);
      
     // Guarda la coordenada y actual (valor enviado por serial)
     listaY[i] = y2;
  
     // at the edge of the screen, go back to the beginning:
     if (xPos >= width) {
       xPos = 0;
       background(0); 

     } 
     else {
       // increment the horizontal position:
       xPos+=3;
     }
   }
   // Sincronizar el retardo con el programa que envia los valores al puerto serial
   delay(300);
    }

}

void serialEvent(Serial p) {
  inString = p.readString();
}

A continuación vemos la gráfica que se genera:


Bien, como podemos observar las graficas se generan simultaneamente y dentro del código podemos determinar los colores de cada una, algo importante es que los retardos en ambos programas deben ser exactamente iguales para que la gráfica se dibuje correctamente, si omitimos o alteramos los retardos se pueden mostrar resultados no deseados en la gráfica, bien espero que esta pequeña contribución sea de utilidad, y si es así dejame un comentario que me dará mucho gusto saber que así fué, un saludo.

lunes, 6 de junio de 2016

Comunicación inalámbrica con módulos ZigBee CC2530.

The CC2530 is a IEEE 802.15.4 SoC. It enables robust network nodes to be built with very low total cost. The CC2530 combines an enhanced 8051 MCU, in-system programmable flash memory, 8-KB RAM, and many other powerful features. The CC2530 comes in four different flash versions: CC2530F32/64/128/256, with 32/64/128/256 KB of flash memory, respectively. The CC2530 has various operating modes, making it highly suited for systems where ultralow power consumption is required such as Contiki based system Short transition times between operating modes further ensure low energy consumption.

CC2530 Eval Kit is a ZigBee development/evaluation kit designed for CC2530F256, consists of the mother board ZB502 and the ZigBee moduleCore2530.
Basically this kit can be used in two aspects :
  • Develop application with the provided firmware
    Combined with our provided firmware, you can use this kit to set up a minimal ready-to-run ZigBee system for testing or evaluating, and requires NO knowledge about the complicate ZigBee Specification
  • Develop your own firmware
    In this case, you should start from the very underlying to create your solution, what's more, debuggers (like CC Debugger) and knowledge about ZigBee Specification are also required



Primeros pasos con los dispositivos CC2530 de WaveShare

1) Configuracion: Una red minima de cc2530 consta de un coordinador y varios clientes que pueden ser ruteadores o terminales, usando los módulos de desarrollo ZB502 podemos configurar los transmisores para otorgarles cualquiera de estas funciones, para una red mínima (1 coordinador - 1 ruteador) procedemos a cargar los firmwares correspondientes en cada módulo:


  • Usar serialboottool_1_3_2
  • Configurar nuestro puerto serial a 115200 bps
  • Cargar coordinator.bin <- master de la red en un dispositivo y router.bin en el otro
Abrir SerialPort utility y acceder a los puertos correspondientes al módulo usb

  • Por default la velocidad de operacion del módulo es de 38400
  • Todo lo que enviamos al puerto uart es transmitido a la red y le llega a todos los dispositivos conectados.
  • La direccion la asigna automaticamente, unicamente podemos configurar el ID de la red.
Como se trata de dispositivos con interface UART, es sencillo conectarlos a un arduino y poder hacer transmitir mensajes mediante simples comandos al puerto serial.