Introducción

Los módulos XBee/XBee-PRO ZNet 2.5 OEM fueron diseñados para operar dentro del protocolo ZigBee soportando las necesidades particulares de las redes de sensores de bajo costo y consumo, requiriendo alimentación mínima y a la vez permitiendo el transporte confiable de datos entre dispositivos remotos.

El módulo opera dentro de la banda ISM (Industrial, Scientific and Medical) utilizando una frecuencia de 2.4 GHz.

Los requerimientos mínimos de conexionado consisten en proveer alimentación mediantes dos terminales (VCC y GND) y dos de datos (Vin y Vout). Para la actualización de firmwares es necesario agregar las conexiones de los pines RTS y DTR.

Los módulos XBee fueron diseñados para ser montados en un zócalo, no requiriendo ningún soldado. Para ello disponen dos hileras de 10 pines separadas entre ellas por 22 mm La separación entre pines es de 2mm (ver figura).

Características Eléctricas

En el resto del documento se hace una presentación de los diagramas de conexionado y montaje de los distintos dispositivos de hardware utilizados en el presente trabajo. Para cada uno se hace un breve resumen de las características del mismo, se presenta el esquemático y las consideraciones para el montaje.

Alimentación

Materiales:

• Regulador de voltaje LM317L
• Resistencia 240 Ohms
• Resistencia variable 5KOhm
• 3 pilas AA recargables
• 2 porta-pilas AA de dos elementos

El regulador de voltaje utilizado requiere que la diferencia entre tensión de entrada y salida sea de al menos 3 V. Como la salida es de 3,3V, la tensión de entrada debe ser de al menos 6,3 V. Una opción es utilizar baterias de 9 V.

El circuito no incluye capacitores de filtro porque supone que la tensión de entrada de las baterias es muy estable. De ser necesario se pueden incluir a la entrada y la salida del LM317L (ver datasheet).

Esquemático de conexiones

Módulo XBee con conexión a PC

Materiales:

• 1 protoboard
• 1 XBee ZNet 2.5 OEM (WRL-08691)
• 1 XBee Breakout Board (BOB-08276)
• 2 sockets de 10 pines para XBee
• 1 pinera para el módulo USB-SERIE y la placa adaptadora de XBee (2,5 mm de separación)
• 1 FT232RL Breakout Board (módulo USB-SERIE)
• 2 Leds
• Cables
• Cable USB miniB

Algunos ítems difíciles de conseguir se compraron en Sparkfun.com (www.sparkfun.com). Los códigos de las partes son los indicados entre paréntesis.

Características

Este es módulo es el encargado de conectar la red ZigBee a la computadora y por lo tanto incluye una interfaz para conectarse a la misma. Las opciones de comunicación que se presentaron durante la etapa de diseño fueron la de utilizar una comunicación serie estándar (RS-232) o mediante puertos USB. La segunda opción, que fue la elegida, tiene la ventaja de que prácticamente todas las computadoras actuales disponen de varios puertos USB para conectar dispositivos, mientras que muy pocas disponen de puertos de comunicación en serie. Esta diferencia es aún más marcadas si nos referimos estrictamente a las computadoras portátiles, cuyos diseños rara vez incluyen puertos seriales.

La placa “FT232RL Breakout Board “ es una interfaz entre la comunicación en serie utilizada por el módulo XBee y la implementada de acuerdo a la norma USB.

Esquemático de conexiones

Montaje

La XBee Breakout Board es una placa necesaria para adaptar los pines de 2 mm de separación del módulo XBee a los 2,5 mm de separación del protoboard. Se deben montar los zócalos y las pineras correspondientes a los puntos de conexión de esta placa. El montaje debería quedar como el de la figura.

Ambos Breakout Boards pueden se pueden colocar en un protoboard cómo el de la figura, agregando las conexiones necesarias de acuerdo al diagrama esquemático.

Módulo XBee independiente (baliza)

Materiales:

• 1 XBee ZNet 2.5 OEM (WRL-08691)
• Fuente de alimentación de 3.3V

Características

Para que el módulo XBee funcione alcanza con proveerle una alimentación dentro del rango y conectar los pines de entrada y salida de la comunicación serie. Como nuestros módulos independientes sólo necesitan reenviar la información recibida se instrumenta un loopback por hardware, uniendo la salida de datos con la entrada (en el módulo, los pines 2 y 3 respectivamente).

Esquemático

Montaje

Como única indicación para el montaje, cuidar que la antena del módulo XBee quede visible y libre de obstáculos para tener una línea de vista directa con los demás dispositivos.

Comprobación de funcionamiento

Para comprobar el funcionamiento de los módulos es necesario utilizar el módulo XBee con conexión USB descripto anteriormente. Mediante el software X-CTU, provisto por Digi es posible programar los módulos XBee, actualizar sus firmwares y realizar todas las pruebas necesarias para verificar el buen funcionamiento de los mismos.

El software X-CTU (http://www.digi.com/support/productdetl.jsp?pid=3352&osvid=57&tp=4&s=316).

La comunicación USB está basada en el circuito integrado FT232R. El fabricante del chip provee un driver que instala un puerto serie virtual en Windows (http://www.ftdichip.com/Drivers/VCP.htm). Una vez está instalado el driver, se debe conectar el módulo XBee utilizando el cable USB MiniB e iniciar X-CTU (Nota: si X-CTU se inicia con anterioridad a la conexión, el puerto virtual podría no aparecer). Con el botón “Test / Query” se puede verificar la conexión; si esta es correcta, debe aparecer el nombre del modem del dispostivo XBee y la versión del firmware instalado. Para el módulo XBee utlizado el nombre del modem es X24-B.

Seguidamente se debe programar el firmware en cada uno de los dispositivos XBee que se van a utilizar. Es importante tener actualizadas las versiones de los firmwares; para esto se debe presionar el botón “Download new versions…”. Una vez finalizada la actualización, se debe seleccionar el firmware a grabar y presionar el botón “Write”. Las versiones utilizadas en este trabajo son “ZNET 2.5 COORDINATOR AT” y “ZNET 2.5 ROUTER/END DEVICE AT”, que permiten la comunicación mediante comandos AT a través del puerto serie.

Es necesario configurar un nodo como coordinador y dejar los demás como routers o end devices para que la red funcione apropiadamente.

Por default los nodos vienen configurados para enviar la información al coordinador por lo que es muy fácil probar los dos dispositivos usando la solapa terminal de X-CTU. Si uno de los dispositivos se lo conecta como módulo XBee independiente (con loopback por hardware), todo mensaje enviado por la terminal debería ser repetido por el receptor.

VideoLectures: Videos de clases universitarias ONLINE!!! Casi todas en inglés… pero bueno, así es el mundo.

RapidSafe: Sitio muy útil para evitar esperar 1 hora o más al bajar el próximo link de RapidShare.

Neuroevolution: Blog especializado en redes neuronales

Choose a license: Para elegir correctamente una licencia Open Source

Dr. Dobb’s CUDA Tutorial: Muy bueno para dar los primeros pasos en CUDA. Cuda es un entorno en lenguaje C que permite programar sobre placas gráficas de NVIDIA (Serie 8 en adelante).

Introduccion a Redes Neuronales: Buenos apuntes.

Introducción 

Este documento muestra como construir un Hello World usando JNI.

JNI es la sigla de «Java Native Interface» y como su nombre lo indica, es una interfaz que permite llamar a funciones compiladas en el código nativo de la máquina en que se está ejecutando el programa.

Para esto, primero debemos escribir la función en algún lenguaje y compilarla como una librería del entorno en el que vamos a llamarla. (Por ejemplo en Windows, podemos compilar una DLL en Visual C++ con las funciones que queremos llamar desde Java).

Hello JNI World

Antes que nada, si queremos usar JNI tenemos que poder compilar un ejemplo simple y verificar como funciona:

Mundo Java

Se empieza por crear la clase Java definiendo la interfaz de comunicación con la futura DLL.

import java.util.*;

class HelloWorld {

//Native method declaration

  native void sayHello(String name);

//Load the library

  static {

    System.loadLibrary(«helloworld»);

  }

  public static void main(String args[]) {

//Create class instance

    HelloWorld hello =new HelloWorld();

//Call native method

    hello.sayHello(«Nerdy»);

  }

}

Compilar la clase con el comando «javac HelloWorld.java»

Luego ejecutar el comando «javah HelloWorld». Se generará un header HelloWorld.h que contiene la descripción de los métodos que debería implementar la libería dll:

/* DO NOT EDIT THIS FILE – it is machine generated */

#include <jni.h>

/* Header for class HelloWorld */

#ifndef _Included_HelloWorld

#define _Included_HelloWorld

#ifdef __cplusplus

extern «C» {

#endif

/*

 * Class:     HelloWorld

 * Method:    sayHello

 * Signature: (Ljava/lang/String;)V

 */

JNIEXPORT void JNICALL Java_HelloWorld_sayHello

  (JNIEnv *, jobject, jstring);

#ifdef __cplusplus

}

#endif

#endif

Mundo C

Cómo paso siguiente vamos a implementar la función en C++ (en realidad en C, porque no vamos a crear ninguna clase) para Visual C++ de esta manera:

#include <jni.h>

#include «HelloWorld.h»

#include <stdio.h>

JNIEXPORT void JNICALL 

Java_HelloWorld_sayHello(JNIEnv *env, jobject obj, jstring name)

{

  jboolean iscopy;

  const char *charsname = (*env)->GetStringUTFChars(

                env, name, &iscopy);

  printf(«Hello «);

  printf(charsname);

  printf(«, this is your first JNI library\n»);

  return;

}

Algunas observaciones:

 * #include <jni.h>: Esta línea es necesaria para poder usar las funciones de JNI dentro de la DLL. JNI implementa «métodos» y constantes para comunicarse con Java, por ejemplo para convertir tipos de datos. 

 * JNIEXPORT void JNICALL: Esta línea es un ejemplo del uso de definiciones JNI para código C, indica como se exporta la función en la dll y el método de llamada a la misma. Lo único que nos importa es que tiene que ir así.

 * JNIEnv *env: Este es un puntero al objeto environment de JNI. Con los métodos de este objeto hacemos por ejemplo transformaciones de formato de los parámetros. Además es un handler al thread actual de la máquina virtual de java.

 * jobject obj : Esta es la referencia al método de Java que llama a la función. Supongo que sirve para hacer recursión. Si el método que hace la llamada es estático viene un jclass.

 * jstring: La clase String de Java no existe en C++, hay que hacer una conversión para poder usar los datos. Esto se hace en la línea const char *charsname = (*env)->GetStringUTFChars(env, name, &iscopy); donde *charsname es un puntero a un char que en realidad apunta a una cadena de caracteres (ver pointers en C) y el operador -> es como el punto «.» en Java pero para objetos referenciados por puntero (el tipo env de era JNIEnv* y por eso hay que usarlo).

Por último, una vez está escrito el código hay que compilar. La forma más fácil de hacer esto (si la DLL está compuesta de un único archivo .c) es compilarla directamente desde linea de comandos. Para eso hay que abrir «Simbolo de Sistema de Visual Studio». Esto despliega una nostálgica ventana de DOS donde se puede ejecutar el comando para generar la librería. No lo hacemos con la línea de comandos común y corriente (ejecutando cmd) porque haría falta setear muchas variables de entorno de Visual Studio.

Lo mejor para compilar es meter el comando dentro de un archivo .bat para poder usar la variable de entorno %JAVA_HOME% que apunta al directorio del JDK. Dentro de este la carpeta include contiene el archivo «jni.h» al que se hace referencia desde el código de la DLL. Luego desde la consola de Visual Studio llamamos a nuestro script (por ejemplo makeDLL.bat).

El comando dentro del archivo makeDLL.bat es:

cl -I%JAVA_HOME%/include -I%JAVA_HOME%/include/win32 -LD HelloWorld.c -Fehelloworld.dll

La opción -I incluye al directorio para buscar los includes, -LD indica el archivo fuente con el que creará una DLL y por último -Fe indica el nombre del archivo de salida.

Esto generará el archivo HelloWorld.dll y sus correspondientes HelloWorld.obj y HelloWorld.lib que no nos sirven para nada y se pueden borrar.

Finalmente, para probar el programa ejecutamos «java HelloWorld» y obtenemos la siguiente salida:

Hello Nerdy, this is your first JNI library

Conclusión

A esta altura creo que se habrán dado cuenta de que JNI no es fácil. No es algo trivial (sobre todo si piensan en objetos complejos y threads). 

Este fue uno de los HelloWorld más complicados que ví en mi vida. Por suerte hay bastante buena documentación en Internet:

 * Introductoria: http://java.sun.com/developer/onlineTraining/Programming/JDCBook/jni.html de acá saqué en parte las cosas para hacer el HelloWorld

 * Más completo: Java Native Interface: Programmer’s Guide and Specification. Se puede bajar el libro en html o pdf o verlo en línea.

 * Especificación completa: http://java.sun.com/javase/6/docs/technotes/guides/jni/index.html.

Tests Vocacionales Online: Entrada en un blog de Blogger con links a varios tests vocacionales online. Algunos links rotos, otros apuntan a tests muy buenos. Ya estoy grande para estas cosas pero tenía que pasárselos a un conocido…

XOM XML Parser: Parser y modelo de objetos de XML. Lo pienso utilizar para levantar documentos KML de Google Earth en el contexto de un trabajo de investigación sobre Sistemas de Información Geográfica(GIS).

The Java Native Inteface Guide and Specification: Sitio oficial de sun con la guía de desarrollo JNI. Muy completo. Lo voy a utilizar en un proyecto para crear una interfaz entre dispositivos USB y Java desde Windows.

MPUSBAPI Library: Especificación (no oficial) del api (DLL en windows) para comunicar con dispositivos USB de Microchip.

La información en internet no es tan buena como uno debería esperar. Despues de buscar mucho pude encontrar estos tres recursos, que son los que más me sirvieron:

Especificaciones del controlador HD44780

Muy bueno, incluye todos los comandos y un ejemplo para controlar el display desde un micro PIC.

Revista UCONTROL1 UCONTROL3

Tiene un artículo sobre displays LCD alfanuméricos. Ayuda mucho a entender como funcionan. Cambiando los números en la dirección URL podemos acceder a las demás revistas. (ojo!!! cambiar los dos números de la dirección si no no anda).

Termostato electrónico con PIC y LCD

Un proyecto del archiconocido sitio www.pablin.com.ar, para controlar temperatura y mostrarla en un display. También útil para el conexionado.

Mi proyecto

En mi proyecto conecté un diplay Winstar WH1601A a un PIC16F873A por el puerto D, utilizando BUS de 8 bits. Las señales de control EN, RS y R/W las conecté a patas del puerto A (A5, A2 y A4 respectivamente). El código necesario para manejar el display es el siguiente:

Archivo driver.h:

#ifndef Driver
#define Driver

void initDisplay();
void drive(int16);
void writeString(char*);
void writeChar(char);
void writeControl(int8);
void clearLCD();

//reemplazar por la función que envía datos al display
#define OUTPUTBUS output_c
//reemplazar por la función que espera a que el display tome el comando
#define DISPLAY_DELAY delay_ms(2)
//Manejo de las líneas de control, reemplazar con lo que corresponda
#define SETRS output_high(PIN_A2)
#define CLEARRS output_low(PIN_A2)
#define SETEN output_high(PIN_A5)
#define CLEAREN output_low(PIN_A5)
#define SETRW output_high(PIN_A4)
#define CLEARRW output_low(PIN_A4)

#define DISPLAY_DB_SIZE 0x38
#define TURN_ON 0x0E
#define DISPLAY_CONF 0x06
#define CLEAR_LCD 0x01

#endif

Archivo driver.c:

#include «Driver.h»
#include «Descongelador.h»
#include <string.h>

char buf[8]; //En este lugar vamos a ubicar los datos a mostrar en el display

void initDisplay(){
CLEARRS;
CLEARRW;
CLEAREN;
delay_ms(15);

//Configuro el display
writeControl(DISPLAY_DB_SIZE);
//Lo encendemos
writeControl(TURN_ON);
//Configuraciones adicionales
writeControl(DISPLAY_CONF);
//Escribe el mensaje de inicialización
clearLCD();
drive(127);
}

//Esta función se encarga de enviar al display la temperatura indicada en las unidades definidas en el termostato.
void drive(int16 t){
int16 temperatura;
temperatura = (t * 10) / UNIDADES_POR_GRADO;
sprintf(buf,» %2.1w*C»,temperatura);
writeString(buf);
}

void writeString(char* str){
int i;
int n;
n = strlen(str);
for (i = 0; i < n; i++){
writeChar(str[i]);
}
}

void writeChar(char c){
CLEARRW;
SETRS;
OUTPUTBUS(c);
SETEN;
delay_us(2);
CLEAREN;
DISPLAY_DELAY;
}

void writeControl(int8 data){
CLEARRW;
CLEARRS;
OUTPUTBUS(data);
SETEN;
delay_us(2);
CLEAREN;
DISPLAY_DELAY;
}

void clearLCD(){
CLEARRW;
CLEARRS;
OUTPUTBUS(CLEAR_LCD);
SETEN;
delay_us(2);
CLEAREN;
DISPLAY_DELAY;
}

Todo funcionó perfectamente!!!

El curso es bastante completo, incluye lecturas, ejercicios y clases de repaso. Al terminarlo, te encuentras preparado para encarar uno de los problemas matemáticos por los que el Clay Mathematics Institute. ofrece 1.000.000 de dólares:el problema P vs NP.

Obviamente no persigo resolver el problema, pero la complejidad computacional es un campo de estudio que aún no está muy desarrollado y realmente me parece muy interesante.

Por último dejo, para los que quieran iniciarlo, el link de la mula para el libro en el cual se basa todo el curso: Sipser, Michael. Introduction to the Theory of Computation. 2nd ed. Boston, MA: Course Technology, 2005. ISBN: 0534950973.

Este integrado entrega una tensión lineal ante el cambio de temperatura, lo cual es ideal para leerlo con el módulo AD. Opera en un rango de voltaje bastante extendido(4V a 30V) y su precisión es aceptable(aprox. 0.5ºC).

Viene en toda una familia de presentaciones, variando los empaquetados, la precisión y los rangos de temperatura. El que utilizé es el LM35DZ que ven en las imágenes; se trata de un empaquetado TO-92 de tres patas, dos para la alimentación y la restante para la señal entregada. Su rango de temperaturas va de 0ºC a 100ºC.

Es muy fácil leer la salida de este sensor utilizando el ADC del PIC(16F873A o cualquier 16F87xA). El LM35 hace variar la tensión 10mV/ºC. Si colocamos en la pata A3 una tensión de referencia de 2.56V para el módulo ADC(configurado en 10 bits) tendremos un valor nuevo cada 2,5mV, es decir, cada 0,25ºC; suficiente como para mostrar temperatura en un display con la precisión que entrega el integrado. Luego conectamos la salida del sensor a A0 para tomar las lecturas.

El código utilizado para inicializar el módulo ADC y sensar la temperatura es el siguiente(para CCS PCWH C Compiler) :

int16 value;
int16 temp;

void inicializar(){
setup_adc(ADC_CLOCK_DIV_8);
setup_adc_ports(AN0_AN1_AN2_AN4_VSS_VREF);
set_adc_channel(0);
}

void leer_temperatura() {
delay_ms(100);
value = Read_ADC();
//calculo la temperatura en centesimas de grado
temp = value * 25;

//luego la puedo pasar a un display para su visualización
//o controlar algo de acuerdo a la temperatura o lo que sea.
}

Hola gente, hoy doy inicio a este blog para escribir sobre el lado mas nerd de mi personalidad… Prepárense.