martes, 27 de septiembre de 2011

el secreto de la motivación

¿Por qué la gente se dedica a desarrollar productos tecnológicos en su tiempo libre (Linux, Hardware libre, ...), sin sacar ningun provecho en ello?, ¿solo por el placer de hacerlo?. Supongo que pueden haber diversas teorias, pero estos dos videos dan un explicación que me resulta convincente:


Hasta pronto.

martes, 13 de septiembre de 2011

Funciones ULP para Eagle

Después de batallar un poco con el editor de PCBs Eagle, me he hecho una lista de funciones ULP que utilizo con asiduidad. Recordad que para ejecutar estas funciones, la mayoría ya disponibles por defecto en el directorio ulp, tan sólo tenéis que ejecutar el comando
run nombre_de_la_funcion

Quizás alguna de estas funciones no estén por defecto en ese directorio, tendréis que "googlear" un poco para conseguirlas. Vale la pena el esfuerzo.

Voy a dividir las funciones según se utilicen para hacer el esquemático, o para diseñar el layout del PCB.

ESQUEMÁTICO

función: bom-ex
descripción: genera la lista de material del esquemático

función: bom-partno-mgr
descripción: edita la part list del esquema según una base de datos de componentes. Esta base de datos se determina con la variable global DATABASE. Para modificar esta variable global ir a Edit -> Global Attributes.
Si queremos tener una lista de material profesional, es conveniente mantener esta base de datos, donde podamos poner asignar los campos de valor que nosotros queramos a cada componentes. Es muy interesante tener siempre la misma descripción COMPLETA de un componente, es decir, que la descripción, por ejemplo, de un condensador de 100nF 0603, sea en todos los casos, C_100nF_X7R_SMD0603. O en el caso otros componentes que no sean "comodities" pongamos, no solo el fabricante del integrado, sino también una segunda fuente, e incluso, la referencia de algún distribuidor  tipo Farnell, con su referencia y precio.
La base de datos puede ser tan completa como se quiera, pero se buena idea crearla y mantenerla para tener al final del diseño una documentación de montaje completa y profesional.

función: statistic-sch
descripción: muestra estadística del esquemático

función: findfrst
descripción: busca componente, net, ... según selecciones. Vale la pena asignarle a esta función una tecla rápida, en mi caso F12

función findnext
descripción: busca la siguiente referencia del componente, net, ... que se haya seleccionado con findfrst. La tecla rápida que yo le asocio es CTRL+F12

PCB

función: drillinfo
descripción: te muestra el listado de drill, y lo que no cumplen con los estándares (y que acaban costando dinero)

función: exp-project-lbr
descripción: crea una librería de componentes con aquellos que hemos utilizado en nuestro proyecto. La librería coge el nombre del proyecto.

función: zoom-unrouted
descripción: a veces es complicado saber si hemos acabado de enrutar todas las pistas, o hay alguna pista no conectada escondida. Esta función te muestra en zoom las nets aún no conectadas.

función: unrouted2
descripción: te  crea un fichero txt donde están listadas las nets no conectadas. Este fichero se llama unrouted.txt y lo pone en el directorio principal del programa Eagle.

función: silk_gen
descripción: corrige la serigrafía


También recordad que si queréis ver una net, está el comando:
show nombre_net


El futuro pertenece a los datos

Tim O'Reilly hizo una muy interesante charla sobre su visión del futuro, y de cómo va a condicionar nuestra vida cotidiana una inmensa catidad de nuevos datos que vamos a poder adquirir y procesar con, sobretodo, nuestros teléfonos móviles:


miércoles, 7 de septiembre de 2011

Proyectos open hardware

El open hardware tiene ya un largo recorrido que no se acaba en absoluto en Arduino. Surgen a diario ambiciosos proyectos que siguen la filosofía del open hardware incluso con mayor rigor quenel famoso Arduino. Algunos ejemplos que he descubierto últimamente:
- la camara elphel:
http://wiki.elphel.com/index.php?title=Main_Page
- Mizar32project
http://www.simplemachines.it/index.php?option=com_content&view=article&id=13&Itemid=24

Hasta pronto

lunes, 5 de septiembre de 2011

Smart City

IBM está apostando fuertemente por el concepto de la Smart City. Las ciudades prometen crecer en el futuro más próximo, los recursos naturales son limitados, así que las ciudades, si quieren mantener los servicios al mismo nivel que en la actualidad, tendrán que hacer lo que supongo que todos tendremos que hacer a nuestro nivel, tendrán que hacer lo mismo con menos recursos.
La optimización del gasto energético, del uso de los servicios públicos, será un tema que sin duda, dará que hablar durantes los próximos años.

Para más información, aquí va la impresionante web de IBM:
http://www-03.ibm.com/innovation/us/thesmartercity/index_flash.html#/home/

Y algunos videos:



jueves, 2 de junio de 2011

Reprap

Me encanta la idea de una máquina capaz de reproducirse a sí misma. Reprap es un intento para conseguirlo. Aún le queda mucho, pero es el primer paso:

RepRap from Adrian Bowyer on Vimeo.

viernes, 18 de marzo de 2011

Arduino programación wireless con Xbee oficial. Sexta parte.

En el siguiente video vemos la implementación del programador wireless en acción:


La música es de Penguin Café Orchestra.

Hasta pronto.

lunes, 14 de marzo de 2011

Arduino programación wireless con Xbee oficial. Quinta parte.

8. Puesta en marcha

Una vez tenemos el sistema instalado. Es decir:
- Arduino Master con el Shield Xbee s1, conectado al PC a través del USB.
- La aplicación de sparkfun Screamer v20 corriendo en el PC
- Arduino Slave con el shield Xbee S1


Seguimos los siguientes pasos:
1. Quitamos el jumper "aereo" que habilita el reset por DTR en el Arduino Master
2. Seleccionamos el fichero a cargar en el Slave en la aplicacion Screamer y seleccionamos la opción de download. El programa entra en modo de espera.
3. Reseteamos el Arduino Master con el pulsador de reset del shield Xbee
4. El programa del Arduino Master corre hasta que se provoca el reset remoto y se inicia la transferencia del archivo al arrancar el bootloader remoto.

9. Posibles Mejoras
- Programa en Pynthon para la aplicación de programación de SparkFun, posibilidad de activarlo a través de un comando script.
- Completar la librería SoftSerial Xbee para comprobar la conformidad de la recepción de los mensajes
- Completar el sketch del Arduino Master de forma que inicie el proceso de grabación remota al recibir un comando o al conmutar un interruptor.
- ...

Este proyecto no pretende establecer la comunicación más fiable de la historia de las comunicaciones. Es  bastante mejorable. Pero os puede ser útil en proyectos con varios Arduinos donde os queréis ahorrar el tener que trastear constantemente con los cables. Un ejemplo de utilidad podría ser la programación remota de un robot, de forma que vayas debugando con nuevos programas sin necesidad de ni tan siquiera de tocarlo.


Hasta pronto.

domingo, 13 de marzo de 2011

Arduino programación wireless con Xbee oficial. Cuarta parte.

El código del sketch que debe correr en el Arduino Master para hacer la programación remota con el shield de Xbee es:


//MAKE AN ARDUINO WIRELESS PROGRAMMING WITH XBEE SHIELD LIBELIUM
//RemoteXbee v1.0
//RELYNXANDO Marz-11
//This example code is in the public domain.
#include <xbeefg.h>
#include <newsoftserial.h>
// SH + SL of your remote radio Slave Arduino XBeeAddress64(SH,SL)
// in my case SH=0x0013a200 and SL=0x4049CC62
XBeeAddress64 remoteAddress = XBeeAddress64(0x0013a200, 0x4049CC62);
// Define NewSoftSerial TX/RX pins
// Connect Arduino pin 6 to TX of usb-serial device
uint8_t ssRX = 6;
// Connect Arduino pin 7 to RX of usb-serial device
uint8_t ssTX = 7;
xBeeFG XBeeNSS = xBeeFG( ssRX, ssTX );
// Software UART to communicate with the Xbee module
NewSoftSerial nss(ssRX, ssTX);

// Configure remote Xbee to API Mode (AP=2)
uint8_t APIModeCmd[] = {  'A', 'P' };
uint8_t APIModeValue[] = {  0x2 };
uint8_t TransModeValue[] = {  0x0 };

AtCommandRequest atRequest = AtCommandRequest(APIModeCmd, APIModeValue, sizeof(APIModeValue));
AtCommandResponse atResponse = AtCommandResponse();

// Set DIO7 (pin 12) to OUT HIGH
uint8_t d7Cmd[] = {  'D', '7' };
uint8_t d7ONValue[] = {  0x5 };
uint8_t d7OFFValue[] = {  0x4 };

// Set DIO5 (pin 15) to OUT HIGH
uint8_t d5Cmd[] = {  'D', '5' };
uint8_t d5ONValue[] = {  0x5 };
uint8_t d5OFFValue[] = {  0x4 };
uint8_t ATModeRemote[] = {  '+', '+', '+'};
uint8_t APIModeRemote[] = {  'A', 'T', 'A', 'P', '2'};

char payload[20];   

// unless you have set DH/DL for 64 bit this will be received as a RX16 packet
Tx64Request tx64 = Tx64Request(remoteAddress, (uint8_t*)payload, sizeof(payload)); 

// This will contain the status responses of that the XBee receives
TxStatusResponse txStatus = TxStatusResponse();                            

// Create a remote AT request with the IR command
RemoteAtCommandRequest remoteAtRequest = RemoteAtCommandRequest(remoteAddress, APIModeCmd, APIModeValue, sizeof(APIModeValue));

// Create a Remote AT response object
RemoteAtCommandResponse remoteAtResponse = RemoteAtCommandResponse();

void setup()
{
  Serial.begin(19200);
  Serial.println("REMOTE PROGRAMMING"); 
  delay(10);
  XBeeNSS.begin( 19200, ssRX, ssTX );
  delay(100);
  nss.begin(19200);
  delay(100);
}

void loop()
{
  //CONFIGURE XBEE1 AND XBEE2 AS MODE API
  //Configure local XBEE1 in API mode again with AT AP 2 command
  delay(150); 
  nss.print("+++");
  delay(1500);
  nss.println("ATAP2");
  delay(3000);
  //XBEE2 in AT mode 
  tx64 = Tx64Request( remoteAddress, ATModeRemote, sizeof( ATModeRemote ) );
  XBeeNSS.send( tx64 );
  delay(3000);
  //Xbee2 in API mode
  remoteAtRequest.setCommand(APIModeCmd);  
  remoteAtRequest.setCommandValue(APIModeValue);
  remoteAtRequest.setCommandValueLength(sizeof(APIModeValue));
  XBeeNSS.send(remoteAtRequest);
  delay(5000);
  //END CONFIGURATION XBEE1 AND XBEE2 AS MODE API
  //Reset remote XBEE2
  remoteAtRequest.setCommand(d7Cmd);  
  remoteAtRequest.setCommandValue(d7ONValue);
  remoteAtRequest.setCommandValueLength(sizeof(d7ONValue));
  XBeeNSS.send(remoteAtRequest);
  delay(2000);
  //Enable remote XBEE2 enter bootloader
  remoteAtRequest.setCommand(d7Cmd);  
  remoteAtRequest.setCommandValue(d7OFFValue);
  remoteAtRequest.setCommandValueLength(sizeof(d7OFFValue));
  XBeeNSS.send(remoteAtRequest);
  //Configure remote XBEE2 TO TRANSPARENT MODE to send file .hex in a transparent way
  remoteAtRequest.setCommand(APIModeCmd);  
  remoteAtRequest.setCommandValue(TransModeValue);
  remoteAtRequest.setCommandValueLength(sizeof(TransModeValue));
  XBeeNSS.send(remoteAtRequest);
  //Configure local XBEE1 TO TRANSPARENT MODE to send file .hex in a transparent way
  atRequest.setCommand(APIModeCmd);
  atRequest.setCommandValue(TransModeValue);
  atRequest.setCommandValueLength(sizeof(TransModeValue));  
  XBeeNSS.send(atRequest);
  delay(30);
  Serial.flush();
while(1){
      if (nss.available()) {
          Serial.print((char)nss.read());  
      }
      if (Serial.available()) {
          nss.print((char)Serial.read());  
      }
 }
  //end send Hex file
}

sábado, 12 de marzo de 2011

Arduino programación wireless con Xbee oficial. Tercera parte.

Tercera parte del post sobre cómo programar remotamente un Arduino con los Xbee oficiales.

7. Consideraciones slave bootloader
Hay que grabar el bootloader de Sparkfun, ya sea para el ATMEGA168 o el ATMEGA328 en el Arduino Slave, el que queremos reprogramar remotamente.
A diferencia del bootloader que proporciona SparkFun, en nuestro caso hay cierto delay entre el reset del Slave y el envio del programa. Es el tiempo necesario para pasar los módulos Xbee a modo AT y  enviar el primer caracter de programación (ASCII 0x05) para comunicarle al bootloader remoto que queremos reprogramar el microcontrolador.
Para evitar que este delay sea demasiado grande para que el bootloader entienda que  NO debe entrar en modo programación, modificamos ligeramente el bootloader de Sparkfun en el Arduino Slave alargando el tiempo de espera antes de iniciar el programa.

En el bootloader de Sparkfun está definida la variable MAX_WAIT_IN_CYCLES:
  
MAX_WAIT_IN_CYCLES = [(MAX_CHARACTER_WAIT)*8]*CPU_SPEED / BAUD
Por defecto:
MAX_CHARACTER_WAIT = 15
CPU_SPEED = 16MHz
BAUD= 19200 bps
Por tanto por defecto:
MAX_WAIT_IN_CYCLES = 100E3 ciclos , siendo 1/16MHz = 1ciclo, el tiempo maximo espera 6.25 mseg
Modificando el bootloader encuentro que el máximo valor de MAX_CHARACTER_WAIT que puedo utilizar sin afectar el funcionamientodel bootloader es 75. Con ese valor conseguimos un tiempo máximo de espera de 31.25 mseg. A la práctica resulta suficiente.

Así la modificación que recomiendo sobre el bootloader es:
  
// #define MAX_CHARACTER_WAIT    15 
#define MAX_CHARACTER_WAIT    75

Se compila el bootloader con avrdude, y se graba en el Arduino Slave. Para grabar el bootloader, si no disponéis de un grabador ISP, se puede utilizar un Arduino Duemilanove, las instrucciones de cómo hacerlo están en la web Burning the Bootloader without external AVR-Writer.

Si a alguien le interesa, le puedo enviar el bootloader compilado, enviadme un mail.

En el siguiente post pondré el código del sketch.

Hasta pronto.

viernes, 11 de marzo de 2011

Arduino programación wireless con Xbee oficial. Segunda parte.

Seguimos con los posts que intentarán crear un sistema para programar remotamente un Arduino a través de los shields oficiales Xbee. En el último post planteamos que ibamos a utilizar la aproximación al problema que ya había hecho Sparkfun.

3. Mecanismo de Reset

De Sparkfun no puedo aprovechar su mecanismo de reset remoto. Sparkfun activa la señal Ready to Send (RTS) a través del programa Screamer, justo antes de enviar el programa hex  por el USB hasta la UART del AVR del Arduino.
Esta señal de RTS en la implementación de Sparkfun se conecta a un pin del modulo Xbee que con una determinada configuración de los módulos, se transforma en el reset remoto.
Comunicándonos a través de Arduino no se puede aprovechar este procedimiento, es más, tenemos que modificar el Arduino Master para evitar que se nos resetee el Arduino cada vez que enviamos un fichero. Tenemos que cortar el puente de DRT del Arduino, y ponemos un jumper "aéreo" para poder habilitar o deshabilitar este puente cuando nos interese.



Corto la pista que hay en el jumper RESET_EN del Arduino Duemilanove "víctima" de las fechorías.
Atención, nos interesa poner el jumper aereo cuando querramos programar este Arduino master, y tendremos que quitar el jumper cuando querramos programar remotamente el Arduino Slave. Hay que tenerlo en cuenta.

4. Xbee oficial vs Reset remoto
En el caso del Xbee oficial, el pin DIO7 del módulo Xbee está conectado a la señal de Reset, de forma que para resetar el Arduino Slave, hay que activar ese pin de forma remota. ¿Cómo podemos hacer eso?, mediante los comandos API del módulo Xbee y más concretamente, el "Remote AT Command Request", los comandos remotos AT. Enviamos un comando AT desde el Master para que se ejecute en el Slave.
Por tanto, el programa que utilicemos para hacer la programación remota tendrá que comenzar configurando tanto el Xbee del Master y del Slave en modo API.
Pero eso lo veremos en detalle más adelante, antes hay otro asunto que tratar.

5. Softserial
¿Cómo podemos enviar por un canal serie al modulo Xbee del Master el programa hex, al mismo tiempo que lo estamos recibiendo?, sólo hay un canal serie, el que viene del USB. La solución es utilizando una UART de software, un software-serial.
La librería que utilizo para implementar esta UART soft es la librería Newsoftserial.
La recepción del softserial (ssRX) la asigno al pin digital 6, y la transmisión (ssTX) al pin digital 7. Basta con tres comandos en el programa para la inicialización:

#include
uint8_t ssRX = 6;
uint8_t ssTX = 7;
NewSoftSerial nss(ssRX, ssTX);


En la función setup del sketch configuraremos la soft UART de la forma:
XBeeNSS.begin( 19200, ssRX, ssTX );

6. Xbee en modo API
Recordad que queremos hacer ese comando remoto para activar el pin DIO7 del modulo Xbee Slave y  de esa forma resetearlo para que se inicie el bootloader. La secuencia será la siguiente:

La softserial comunicación nos obliga a llevar dos cables de las UART soft desde el conector a los jumpers, tal como ilustra la siguiente foto:
 
En siguientes posts sigo explicando la implementación.

Hasta pronto.

jueves, 10 de marzo de 2011

Arduino programación wireless con Xbee oficial. Primera parte.

El objetivo de esta serie de posts es presentar un sketch para programar remotamente un Arduino utilizando los shields Xbee "oficiales".
En su momento me sorprendió no encontrar en la web una solución para esta funcionalidad. La encontré con los Xbee shields de Adafruit y de SparkFun, pero no para los Xbee shield oficial de Arduino. Finalmente desistí de seguir buscando, y me puse manos a la obra.
El proyecto consiste en lo siguiente:

1. Objetivo
Tenemos dos Arduinos con shields Xbee oficiales de Libelium, con módulos del tipo S1. A uno lo llamo Master y al otro Slave. El objetivo es programar desde el Master, remotamente, el Arduino Slave.

2. Herramientas disponibles
Esta funcionalidad está ampliamente comentada en la web para los shields de Adafruit y de Sparkfun. En ambas implementaciones utilizan la señal de Ready to Send (RTS) para resetear remotamente el Arduino Slave y cargar durante el arranque de su bootloader la aplicación por el puerto serie. De esta forma estamos simulando el serial bootloader pero sustituyendo el puerto serie-USB convencional del Arduino, por un puerto serie "virtual" a través del modulo Xbee.
A grandes trazos la solución de Adafruit tiene una serie de potenciales problemas:
- tenemos que tener el módulo Xbee que proporciona Adafruit o Sparkfun, que incorpora la posibilidad de conectar un I/O del modulo Xbee al reset de Arduino;
- la comunicación vía radio no es robusta, ruidos, mala recepción, ... puede provocar que finalmente no grabemos la aplicación correctamente en el Arduino Slave.

Sparkfun lo mejoró creando un bootloader que implementaba un control de errores en la comunicación.  A través de un programa software en PC se envía el programa binario en paquetes, y el bootloader del Slave, comprueba que el CRC es correcto. Si el paquete recibido no tiene el CRC correcto solicita que se le reenvie el paquete de nuevo. De esta forma la comunicación se hace más robusta.

Me decanto por la opción de Sparkfun, aprovechando el software (Screamer) para fragmentar el fichero hex a enviar. La extensión de la compilación de un programa tiene típicamente la extensión hex. Es el fichero binario, que se graba en la memoria Flash del microcontrolador.  No es fácil encontrar el fichero hex después de la compilación en el entorno de Arduino. Las instrucciones para encontrarlo están aquí.

Utilizo el bootloader diseñado por Sparkfun para el Arduino Slave, incorporando de esa forma, el cálculo del CRC y los mensajes de conformidad.

En siguientes posts sigo con la historia.

Hasta pronto.

jueves, 24 de febrero de 2011

Próximo lanzamiento web

Os podemos informar que dentro de poco tendremos online una primera versión de la web de lynxing en la que podréis ver los servicios que ofrecemos y los próximos productos.

Esperamos tener lista la primera versión en breve y anunciaros el lanzamiento en breve, estad atentos!!! ;)

jueves, 3 de febrero de 2011

Eagle PCB tutorial video

Farnell compró Cadsoft, la empresa propietaria de Eagle, el editor PCB más popular en el mundo de HW libre. Aquí va:

Farnell and CadSoft Webinar from element14 on Vimeo.

Hasta pronto

martes, 1 de febrero de 2011

open source ecology

El open source ha llegado al mundo granjero:


El video tiene música de Carl Orff.
Hasta pronto.

lunes, 31 de enero de 2011

Quadrotors

Hay un grupo de trabajo en la universidad de Pensilvania que trabaja en la programación de robots, es el  GRASP Lab. Aquí van algunos de sus logros en video:





domingo, 30 de enero de 2011

Arduino documental

En su día ya me hice eco del proyecto sobre un documental de Arduino. Pues bien, finalmente el documental dió a luz hará unas semanas.
Aquí está:

Arduino The Documentary (2010) Spanish HD from gnd on Vimeo.

Hasta pronto.

sábado, 29 de enero de 2011

Steve Jobs

Estas últimas semanas se ha hecho pública los problemas graves de salud de Steven Jobs, que le han obligado a dejar Apple.
Nunca es un mal momento para escuchar su discurso en Stanford:

Hasta pronto.

viernes, 28 de enero de 2011

IBM centenario

Uno de los mejores videos que he visto últimamente. A raíz del centenario de IMB, se ha hecho este documental. Es una serie de testimonios sobre la historia de IBM por algunos notables empleados:

La música es de Philip Glass.
Hasta pronto.

jueves, 27 de enero de 2011

Photoduino

Ya vimos en un anterior post aplicaciones de hardware libre para el mundo de la fotografía. Pues bien, descubrí hace unos días el proyecto photoduino. Es un shield de Arduino diseñado para controlar el disparo de la cámara fotográfica a partir de sensores de sonido, de impacto, barrera óptica, barrera laser...
Además tiene un display y unos botones para configurar la funcionalidad. Muy completo y con un vídeo muy didáctico.

A primera vista, parece un trabajo estupendo. 
Hasta pronto.

viernes, 14 de enero de 2011

Arduino Xbee SparkFun shield

Sparkfun ha sacado un shield de Arduino para Xbee que intenta implementar algunas mejoras con respecto al shield oficial de Arduino diseñado y comercializado por Libelium.

Puntos a destacar:
- Hay una gran zona de prototipaje, donde se pueden montar los circuitos de sensores, que serán muestreados por el micro de Arduino y después transmitidos por el módulo Xbee
- Con un switch (no con jumpers como el shield de Libelium) se puede conmutar entre una comunicación con la uart del micro de arduino o dos pines digitales donde se puede implementar una soft-UART. De esta segunda forma, tal como hemos explicado en un anterior post, se puede programar arduino sin necesidad de manipular el shield, y podemos configurar el módulo xbee mediante una terminal en el PC.
- Se añaden doble raster (doble footprint) para cada linea del conector de Arduino, permitiendo poder acceder a todas las señales.
- Se protege con un diodo la señal DIN del módulo. Recuerdo que las señales de control de Arduino van a 5V y el módulo está alimentado a 3.3V.
- Hay LEDs de estado del modulo Xbee para DOUT, DIN, RSSI, ASSOC, Power.
- Hay varios ejemplos de aplicaciones para programar remotamente un arduino a través de Xbee. Todas esas aplicaciones, entre las que se encuentra una de sparkfun, utilizan una comunicación directa del módulo Xbee con el PC. Utilizan la señal de RTS para resetear el equipo remoto. Para más detalles, aquí y aquí. Este shield incorpora el circuito que la aplicación de spark fun presenta, dejando la posibilidad de conectar en serie la señal DIO3 con un condensador y la señal de Reset del micro, con la intención de activar el reset de Arduino en caso de haber un flanco en DIO3.

Todos los componentes son SMD, cosa que abarata la producción. De hecho para evitarse cualquier proceso de soldadura que no sea SMD, no montan los conectores al Arduino, ya que eso les obligaría a montar un componente through-hole y encarecería el producto unos céntimos...

El diseño es presentado con licencia CC BY-SA 3.0

Hasta pronto.

miércoles, 12 de enero de 2011

Arduino Xbee SoftwareSerial

Tal como comenté en un anterior post, el shield Xbee de Libelium tiene el problema de no poder trazar la comunicación que estamos haciendo con el módulo xbee a través del puerto USB y por tanto, a un terminal del PC.

Una posible solución para ello es implementar una soft-UART con dos pines del micro. De forma que la UART del micro esté enteramente dedicada a la comunicación con el PC, y la soft-UART sea la que se comunique con el módulo xbee.

El objetivo de este post es explicar cómo se implementa esto.

Para empezar, necesitamos descargarnos la última versión de la librería de SoftwareSerial. Es la librería con la que implementaremos la UART soft en el micro de Arduino. La podeís encontrar aquí. Tenéis que instalaros esta librería en el directorio de librerías del IDE de Arduino, borrando (haciendo un backup previamente) el directorio Softwareserial que encontréis.

Para probarlo necesitamos:
- Arduino + Xbee shield Libelium, lo llamo Emisor
- Arduino + Xbee shield Libelium, lo llamo Receptor
Grabamos el Emisor con una aplicación sencilla que se limite a enviar por la UART al modulo xbee, dos caracteres H y L con una pausa de 1 segundo entre envíos.
 void setup()


{
Serial.begin(9600);
}
void loop()
{
Serial.print('H');
delay(1000);
Serial.print('L');
delay(1000);
}
En el Receptor, antes de nada vamos a hacer un cambio en el hardware. Queremos comunicarnos a través de dos pines configurados del micro como puerto serie (en el ejemplo serán los pines DIO2 y DIO3 de Arduino) con el modulo xbee, de forma que la uart del micro sea sólo de comunicación con el USB.


Adecuando el programa de arduino para ello, podremos ver lo que el micro recibe de xbee y lo que le enviamos al xbee, y también podremos programar el micro, sin necesidad de quitar y poner jumpers (cosa que es un poco engorroso).

Vamos a puentear las señales de comunicación serie de la uart del micro de arduino con la uart del módulo xbee. Quitamos, por supuesto, los jumpers, y puenteamos DIO2 con DIN del xbee (cable rojo foto), y DIO3 con DOUT de Xbee (cable negro foto). La siguiente mediocre foto ilustra el cambio:



El Receptor lo grabamos con una aplicación que implemente la uart soft, la implementación software de una uart en los pines 2 y 3.

//libreria softwareSerial.h se puede encontrar en: http://arduiniana.org/2011/01/newsoftserial-11-beta/
#include < SoftwareSerial.h >

SoftwareSerial XbeeSerial(3, 2);

const int ledPin = 13; // pin del LED

int incomingByte; // variable para los datos serie de entrada

void setup() {
          Serial.begin(9600); //conexion al PC
          Serial.println("Xbee Software Serial Test!");
          XbeeSerial.begin(9600); //conexion al Xbee shield
          // inicializa pin LED como salida
         pinMode(ledPin, OUTPUT);
         }

void loop()
{
         if (XbeeSerial.available()) {
         // leer el byte más antiguo del buffer serie
         incomingByte = XbeeSerial.read();
         // Si es H (ASCII 72), enciende el LED:
         if (incomingByte == 'H') {
               digitalWrite(ledPin, HIGH);
         }
         if (incomingByte == 'L') {
              digitalWrite(ledPin, LOW);
         }
        Serial.print((char)incomingByte); //envia dato de Xbee a PC
        }
        if (Serial.available()) {
             XbeeSerial.print((char)Serial.read()); //envia dato de PC a Xbee
        }
}



Si abrís un terminal en el equipo Receptor deberiáis ver como Arduino traza el mensaje enviado por el Emisor y cambia el estado del LED según el mensaje recibido.

Hasta pronto.

domingo, 9 de enero de 2011

Arduino Xbee Libelium shield

La implementación de comunicación radio con Arduino más común, y seguramente la más sencilla de implementar, se hace con módulos Xbee de la empresa Digi International.
Estos módulos permiten establecer muy fácilmente una comunicación serie wireless. Es muy sencillo de configurar a través de comandos AP, y también hay una aplicación gratuita de configuración en la web, X-CTU.

El "shield oficial" de Arduino lo diseñó una empresa aragonesa llamada Libelium, dedicada, entre otras cosas, al diseño y comercialización de módulos de comunicación wireless con diferentes tecnologías.
Algunos puntos sobre el shield Xbee de Libelium:

Se comunica con el micro de Arduino a través de las mismas lineas de la UART del micro. A través de unos jumpers se puede configurar el shield para:
  • comunicar el módulo xbee con el micro de Arduino, en la serigrafía la posición está marcada como XBEE
  • comunicar el módulo xbee con el USB hacia el PC. Para ello hay que extraer físicamente el micro del Arduino. La posición de los jumpers está marcada en serigrafría como USB.
Quizás este sea el gran "inconveniente" de este shield, la imposibilidad de establecer una comunicación USB-micro-xbee a través de un terminal. Para poder grabar Arduino con el shield puesto, es necesario extraer los jumpers, de forma que el módulo xbee no interrumpa la comunicación serie del PC al micro de Arduino.
En un siguiente post explicaré una de las posibles opciones para solventar esto.

El módulo Xbee se alimenta a 3.3V, las señales de comunicación vienen a 5V, para adaptar la señal serie de entrada (DIN) se pone un divisor de tensión.

En los zócalos de conexión de los módulos Xbee, se pueden montar los módulo xbee (serie 1) y xbee-pro (serie 2). Las diferencias entre los dos módulos podeís consultarlas aquí.

La tensión de alimentación la coge de los 5V que vienen de Arduino. Es un regulador lineal MC33269D-3.3. El consumo del módulo xbee (serie 1) es bajo, alrededor de 50mA. Tenemos un consumo mucho más alto con el módulo xbee-pro, hasta 215 mA.

El conector ICSP, que es conector que se utiliza en Arduino para hacer la programación de su bootloader, está conectado al shield, pero no sería necesario. Se utiliza para llevar la alimentación (5V) y el reset. Estas señales se podrían haber llevado a través de los conectores laterales. Sospecho que se montó ese conector (incrementado por tanto el coste del producto) por una cuestión de fijación mecánica, le da rigidez a la conexión del Arduino y shield.

El pulsador de reset sólo resetea el micro de Arduino, no es el reset del modulo Xbee.

Los componentes tiene doble footprint, SMD y through-hole. Esto puede crear cierta confusión a primera vista del esquemático, donde no están indicados los componentes que no se montan.


La señal del módulo xbee /CTS - DIO7 se lleva a través de un transistor a la señal de reset del micro de Arduino. Supongo que se hizo así, para permitir poder resetear remotamente un Arduino, hacer correr por tanto su bootloader  y pasarle a través del módulo Xbee una nueva aplicación. Es decir, programar por wireless el Arduino. Curiosamente, no he visto ningún ejemplo, en ningún foro, que implemente esta funcionalidad. Sí que he visto ejemplos con otros shields de xbee, pero ninguno con el shield de Libelium. Si alguien ha implementado o conoce algun ejemplo para realizar la programación remota de un Arduino con el shield de Libelium, por favor, que me lo haga llegar.


Hasta pronto.

sábado, 1 de enero de 2011

Arduino Ethernet shield y TelnetClient

Como primera aplicación con el shield "oficial" de Arduino, voy a comentar uno de los ejemplos básico que el IDE de programación de Arduino te proporciona, es el sketch TelnetClient.
Con este programa podemos acceder al ordenador donde esté alojado el servidor Telnet, crear y modificar sus ficheros. Estoy convencido que se os ocurrirá alguna aplicación en la que esto os resulte útil.
Sin más demora, voy a describir, paso a paso, lo que hay que hacer para probarlo con el sistema operativo Windows. 
Básicamente tenemos tres piezas en este juego:
  1. Arduino con el shield de Ethernet
  2. PC al que conectamos el puerto USB de Arduino. Lo llamo PCArduino
  3. PC donde corre el servidor telnet. Lo llamo PCTelnet
No se me ocurre ninguna razón por la que PCArduino pueda ser PCTelnet, pero me parece más divertido sin son distintos, a mí me da una mejor idea de la verdadera función de la aplicación, el control remoto de un PC a través de Ethernet.

Configuración de Arduino
Una vez hayamos conectado el shield Ethernet en Arduino, el puerto USB al PCArduino y arrancado el IDE de programación, debemos seleccionar el sketch TelnetClient:

Tomamos nota del COM al que se conecta Arduino, después necesitaremos esa información para abrir una sesión con hypeterminal.


Modificación sketch
Este sketch consta de tres partes, una primera de inicialización de variables globales, una función de setup, y por último, una función de loop.
  • Variables globales. En este sketch las variables globales son:
    • MAC y la IP que le queremos dar a Arduino. En los últimos shields de Ethernet se indica la MAC en una pegatina. En cuanto a la IP, teniendo en cuenta que nos vamos a comunicar dentro de la intranet de nuestra casa, elegimos una que sepamos que no utilizamos en ninguno de los PCs que tenemos. Yo, por defecto, pongo 192.168.1.177.
    • IP del PCTelnet, en el que corre el servidor Telnet y donde queremos conectarnos a través de Arduino. Para saber la IP de ese ordenador ya sabéis: linea de comando DOS y ejecutamos ipconfig. En mi caso 192.168.1.35
    • Puerto del servidor telnet. Normalmente es el puerto 23.
  • Función de setup.  
    • Inicializa la conexión a Ethernet y el puerto serie a 9600bps.
    • Se ejecuta la conexión al servidor telnet
  • Función loop
    • Traza por el puerto serie todo lo que recibe del servidor y viceversa
    • Detecta si el cliente telnet se mantiene conectado, en caso de no estarlo, saca el mensaje de desconexión.
Así pues, sólo tenemos que modificar el programa con los datos de las variables globales.  En mi caso:
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = {
  192,168,1,177 };
// Enter the IP address of the server you're connecting to:
byte server[] = {
  192,168,1,35 };
// Initialize the Ethernet client library
// with the IP address and port of the server
// that you want to connect to (port 23 is default for telnet;
// if you're using Processing's ChatServer, use  port 10002):
Client client(server, 23);
Una vez lo hayamos hecho, compilamos el programa y lo bajamos a Arduino.

Servidor Telnet
¿Tenemos disponible un servidor Telnet en el PCTelnet al que queremos conectarnos?. En mi caso no era así, por lo que me bajé el servidor Telnet KpyM. Dudo que sea el mejor, sencillamente fue el primero que encontré.
El servidor  telnet nos exige tener un usuario y un password para Windows. Si no lo tenéis, tendréis que crearlo, ¿cómo?: Panel de control > Cuentas de usuario.
Telnet dejó de utilizarse a través de la red, a nivel profesional, porque es un protocolo muy primitivo, sin ninguna seguridad, los nombres de usuario y los passwords van por la red en caracteres, sin ningún tipo de codificación. Para nuestro propósito está bien, ya que hacemos una conexión punto a punto, pero desde luego, esta conexión a través de Internet no es segura.
No os olvidéis de abrir el puerto 23 en el PCTelnet. Para hacer esto: Propiedades de conexión de área local > Opciones avanzadas > Configuración > Excepciones > Agregar Puerto ... > Nombre: telnet / Numero puerto: 23 / TCP.

KpyM crea una aplicación para configurar el servidor telnet, no es necesario modificar nada, en todo caso, en caso de tener algun problema, echadle un vistazo, ejecutad la opción start service para comprobar que el servidor está efectivamente corriendo.

Sesión hypeterminal
Una vez hemos conectado con el cable de Ethernet el shield con el PCTelnet, abrimos una sesión de hypeterminal del PCArduino con el COM de Arduino, en mi caso COM4, con 9600bps:

Si todo es correcto, al abrir la sesión de hypeterminal, Arduino intenta conectarse con el servidor telnet alojado en el PCTelnet. Las siguientes pantallas son las que obtenemos en el hypeterminal:

Una vez hayamos introducido el usuario y el password para Windows, accederemos al PC remotamente. Podemos controlar el PCTelnet a través de la sesión hypeterminal del PCArduino.


Hasta pronto.