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.



domingo, 29 de mayo de 2016

Objetivo:

Enviar una solicitud http mediante un modem gprs serial

Actividades:

1. Instalar una version reciente de python.

Url: https://www.python.org/downloads/


D
Descargamos e instalamos la version 3.5.1

Personalizamos la instalacion para incluir el modulo pip

Verificamos que esté instalado el modulo serial:



En caso que no se encuentre instalado, usar pip para instalarlo usando:



Copiar el siguiente script de python, que habilita una sencilla consola para enviar comandos al puerto serial:


# configure the serial connections (the parameters differs on the device you are connecting to)
ser = serial.Serial(
    port='com22',
    baudrate=38400,
    
)

ser.isOpen()

print('Enter your commands below.\r\nInsert "exit" to leave the application.')

car=""
while 1 :
    # get keyboard input
    # input = raw_input(">> ")
        # Python 3 users
    car = input(">> ")

    if car == 'zzz':
        car = '\r\n\x1a\r\n'  
        ser.write(car.encode())
    
    if car == 'exit':
        ser.close()
        exit()
    else:
        # send the character to the device
        # (note that I happend a \r\n carriage return and line feed to the characters - this is requested by my device)
        car = car + '\r\n'
        ser.write(car.encode())

        out = ''
        # let's wait one second before reading output (let's give device time to answer)
        time.sleep(1)
        while ser.inWaiting() > 0:
            out += str(ser.read(1),"utf-8")
    
        if out:  # If it isn't a blank line
            print('<< '+out)


Mediante el uso de la terminal que nos proporciona el script ingresamos los comandos:


Comando Significado Respuesta esperada Posibles errores
AT+CPIN? Verifica estatus del SIM +CPIN: READY
OK
AT+CREG? Verifica si el SIM está registrado en la red +CREG: 0,1
OK
AT+CGATT? Verifica estatus de la red GPRS +CGATT:1
OK
AT+CIPSHUT Reestablece la sesión en la red SHUT OK
AT+CIPSTATUS Verifica estatus de la sesión OK
STATE: IP INITIAL
AT+CIPMUX=0 Establece el modo de conexión a 1 OK
AT+CSTT= “APN”, “UNAME”, “PWD” Abre una conexión GPRS al APN indicado, las dobles comillas son requeridas OK
AT+CIICR Habilita la conexión OK
AT+CIFSR Verifica la dirección IP que nos asignó la red (Debemos ver nuestra dirección IP) xxx.xxx.xxx.xxx
AT+CIPSTART="TCP","MIDOMINIO.COM","80" Establece conexión con nuestro servidor, indicar tipo de servidos, url y puerto OK
AT+CIPSEND Envía los parámetros de la solicitud al servidor, en este ejemplo usaré una solicitud HTTP/Get CONNECT OK
Teclear los siguientes parámetros de la solicitud, ajustar de acuerdo a nuestras necesidades específicas
GET http://url.de.mi.pagina HTTP/1.1
User-Agent: mozilla
Host: midominio.com
Connection: keep-alive
Dar enter para enviar una línea en blanco, a continuacion enviar Ctrl-Z para indicar que la solicitud esta completa, si usamos el script de python esto se hace tecleando zzz y damos enter. SEND OK
Debemos ver en la consola la respuesta del servidor HTTP/1.1 200 OK
AT+CIPSHUT Cerramos la conexión SHUT OK