Introducción
Lós módulos XBee utilizan el protocolo IEEE 802.15.4 mejor conocido como ZigBee.
Zigbee es un protocolo de comunicaciones inalámbrico basado en el estándar de comunicaciones para redes inalámbricas IEEE_802.15.4. Creado por Zigbee Alliance, una organización, teóricamente sin ánimo de lucro, de más de 200 grandes empresas (destacan Mitsubishi, Honeywell, Philips, ODEM do, Invensys, entre otras), muchas de ellas fabricantes de semiconductores.
Zigbee permite que dispositivos electrónicos de bajo consumo puedan realizar sus comunicaciones inalámbricas. Es especialmente útil para redes de sensores en entornos industriales, médicos y, sobre todo, domóticos.
Aplicaciones
Cada módulo Zigbee, al igual que ocurre con las direcciones MAC de los dispositivos ethernet, tiene una dirección única. En el caso de los módulos Zigbee cada uno de ellos tiene una dirección única de 64bits que viene grabada de fábrica. Por otro lado, la red Zigbee, utiliza parasus algoritmos de ruteo direcciones de 16 bits. Cada vez que un dispositivo se asocia a una redZigbee, el Coordinador al cual se asocia le asigna una dirección única en toda la red de 16bits. Por eso el número máximo teórico de elementos que puede haber en una red Zigbee es de 2^16 =65535, que es el nº máximo de direcciones de red que se pueden asignar. Estos módulos Xbee, pueden ser ajustados para usarse en redes de configuración punto-a-punto, punto-a-multipunto o peer-to-peer.
Conexión de pines entre Xbee y Arduino
Equivalente en USB Explorer
Descripción de pines:
Los módulos Xbee
Los módulos Xbee proveen 2 formas amigables de comunicación:
Transmisión serial transparente (modo AT) y el modo API que provee muchas ventajas.
Modo AT
Esta el modo de transmisión serial transparente (Modo AT), en el cual la comunicación se asemeja a lo que seria una transmisión a través de un puerto serial, ya que el dispositivo se encarga de crear la trama y el dato que llegue al pin Tx sera enviado de forma inalámbrica, por lo cual se considera como el modo mas sencillo para utilizar estos nodos, su principal desventaja es que para enviar información a distintos nodos es necesario entrar constantemente al modo configuración para cambiar la dirección de destino.
Modo API
El otro modo de comunicación se conoce como Modo API, en este caso un microcontrolador externo se debe encargar de crear una trama especifica al tipo de información que se va a enviar, este modo es recomendado para redes muy grandes donde no se puede perder tiempo entrando y saliendo del modo configuración de los dispositivos. Para redes con topología en Malla este es el modo a utilizar.
Software para configurar
Los módulos Xbee pueden ser configurados desde el PC utilizando los programas X-CTU, Moltosenso o Cool Terms además de otros. Moltosenso y Cool Terms nos permiten trabajar en múltiples plataformas, mientras que X-CTU solo trabaja en Windows.
Los Xbee pueden comunicarse en arquitecturas punto a punto, punto a multi punto o en una red mesh. La elección del módulo XBee correcto pasa por escoger el tipo de antena (chip, alambre o conector SMA) y la potencia de transmisión (2mW para 300 pies o 60mW para hasta 1 milla).
El módulo requiere una alimentación desde 2.8 a 3.4 V, la conexión a tierra y las líneas de transmisión de datos por medio del UART (TXD y RXD) para comunicarse con un microcontrolador, o directamente a un puerto serial utilizando algún conversor adecuado para los niveles de voltaje.
Características:
-Buen Alcance: hasta 300ft (100 mts) en línea vista para los módulos Xbee y hasta 1 milla (1.6 Km) para los módulos Xbee Pro.
-9 entradas/salidas con entradas analógicas y digitales.
-Bajo consumo <50mA cuando están en funcionamiento y <10uA cuando están en modo sleep.
-Interfaz serial.
-65,000 direcciones para cada uno de los 16 canales disponibles. Se pueden tener muchos de estos dispositivos en una misma red.
-Fáciles de integrar.
Series
Existen 2 series de estos módulos. La serie 1 y la serie 2 o también conocida como 2.5. Los módulos de la Serie 1 y la Serie 2 tienen el mismo pin-out, sin embargo, NO son compatibles entre sí ya que utilizan distintos chipset y trabajan con protocolos diferentes.
La serie 1 está basada en el chipset Freescale y está pensado para ser utilizado en redes punto a punto y punto a multipunto. Los módulos de la serie 2 están basados en el chipset de Ember y están diseñados para ser utilizados en aplicaciones que requieren repetidores o una red mesh. Ambos módulos pueden ser utilizados en los modos AT y API.
XBee 1mW – Serie 1
- – 250kbps máxima velocidad de datos
- – 1mW de salida (0 dBm)
- – 100m rango línea abierta, 30 metros en interiores
- – 6 pines de 10bits para entrada ADC
- – 8 pines de E / S digitales
XBee 2mW – Serie 2
- – 250kbps máxima velocidad de datos
- – 2mW de salida (+3 dBm)
- – 120m rango línea abierta, 40 metros en interiores
- – 6 pines de 10bits para entrada ADC
- – 8 pines de E / S digitales
- –
Comunicación Xbee
Las comunicaciones Zigbee se realizan en la banda libre de 2.4GHz. A diferencia de bluetooth no utiliza FHSS (Frequency hooping), sino que realiza las comunicaciones a través de una única frecuencia, es decir, de un canal. Normalmente puede escogerse un canal de entre 16 posibles. El alcance depende de la potencia de emisión del dispositivo así como el tipo de antenas utilizadas (cerámicas, dipolos, …) El alcance normal con antena dipolo en visión directa suele ser aproximadamente (tomando como ejemplo el caso de MaxStream, en la versión de 1mW de potencia) de 100m y en interiores de unos 30m. La velocidad de transmisión de datos de una red Zigbee es de hasta 256kbps. Por último decir que una red Zigbee la pueden formar, teóricamente, hasta 65535 equipos, es decir, el protocolo está preparado para poder controlar en la misma red esta cantidad enorme de dispositivos. La realidad es menor, siendo, de todas formas, de miles de equipos.
Arquitectura Básica de una Red XBee.
Una red Zigbee la forman básicamente 3 tipos de elementos. Un único dispositivo Coordinador, dispositivos Routers y dispositivos finales (end points).
Los módulos XBee son versátiles a la hora de establecer diversas topologías de red, dependiendo la serie de XBee que escojamos pueden crearse redes:
El Coordinador:
Es el nodo de la red que tiene la única función de formar una red. Es el responsable de establecer el canal de comunicaciones (como hablábamos antes) y del PAN ID (identificador de red) para toda la red. Una vez establecidos estos parámetros, el Coordinador puede formar una red, permitiendo unirse a él a dispositivos Routers y End Points. Una vez formada la red, el Coordinador hace las funciones de Router, esto es, participar en el enrutado de paquetes y ser origen y/o destinatario de información.
Los Routers:
Es un nodo que crea y mantiene información sobre la red para determinar la mejor ruta para enrutar un paquete de información. Lógicamente un router debe unirse a una red Zigbee antes de poder actuar como Router retransmitiendo paquetes de otros routers o de End points.
End Device:
Los dispositivos finales no tienen capacidad de enrutar paquetes. Deben interactuar siempre a través de su nodo padre, ya sea este un Coordinador o un Router, es decir, no puede enviar información directamente a otro end device. Normalmente estos equipos van alimentados a baterías. El consumo es menor al no tener que realizar funciones de enrutamiento.
Los módulos XBee son versátiles a la hora de establecer diversas topologías de red, dependiendo la serie de XBee que escojas puedes crear redes:
- Punto a punto
- Estrella
- Malla
- Árbol
- Mixtas
Modos RECIBIR/TRANSMITIR.
Se encuentra en estos modos cuando al módulo le llega algún paquete RF a través de la antena(modo Receive) o cuando se manda información serial al buffer del pin 3 (UART Data in) que luego será transmitida (modo Transmit).
La información transmitida puede ser Directa o Indirecta. En el modo directo la información se envía inmediatamente a la dirección de destino. En el modo Indirecto la información es retenida durante un período de tiempo y es enviada sólo cuando la dirección de destino la solicita.
Además es posible enviar información por dos modos. Unicast y Broadcast. Por el primero, la comunicación es desde un punto a otro, y es el único modo que permite respuesta de quien recibe el paquete RF, es decir, quien recibe debe enviar un ACK (paquete llamado así, y que indica que recibió el paquete, el usuario no puede verlo, es interno de los módulos) a la dirección de origen. Quien envió el paquete, espera recibir un ACK, en caso de que no le llegue, reenviará el paquete hasta 3 veces o hasta que reciba el ACK. En el modo Broadcast la comunicación es entre un nodo y a todos los nodos de la red. En este modo, no hay confirmación por ACK.
Modo de Bajo Consumo (Sleep Mode).
El modo de sueño hace posible que el módulo RF entre en un modo de bajo consumo de energía cuando no se encuentra en uso.
Modo de Comando.
Este modo permite ingresar comandos AT al módulo Xbee, para configurar, ajustar o modificar parámetros. Permite ajustar parámetros como la dirección propia o la de destino, así como su modo de operación entre otras cosas. Para poder ingresar los comandos AT es necesario utilizar un Hyperterminal como el programa CoolTerms.
Idle
Cuando el módulo no se está en ninguno de los otros modos, se encuentra en éste. Es decir, si no está ni transmitiendo ni recibiendo, ni ahorrando energía ni en el modo de comandos, entonces se dice que se encuentra en un estado al que se le llama IDLE.
Xbee Shield
El XBee shield para Arduino permite comunicar tu Arduino de forma inalámbrica usando ZigBee.
Configuración de los jumpers
La Xbee shield tiene dos jumpers (las pequeñas fundas de plásticos que están sobre los tres pines etiquetados como Xbee/USB). Estos determinan como se conecta la comunicación serie del Xbee entre el microcontrolador ATmega328 y el chip serie FTDI de la placa Arduino.
Con los jumpers en la posición Xbee ( los dos pines más cercanos al interior de la placa), el pin DOUT de el módulo Xbee está conectado al pin RX del microcontrolador; y el pin DIN está conectado a TX. Notar que los pines RX y TX del microcontrolador están todavía conectados a los pines TX y RX (respectivamente) del chip FTDI – los datos enviados desde el microcontrolador serán transmitidos al ordenador vía USB y a la vez enviados de forma inalámbrica por el módulo Xbee. El microcontrolador, sin embargo, solo será capaz de recibir datos desde el módulo Xbee, no desde el USB del ordenador.
Con los jumpers en la posición USB ( los dos pines más cercanos al borde de la placa), el pin DOUT del módulo Xbee está conectado al pin RX del pin del chip FTDI, y el DIN del módulo Xbee está conectado al pin TX del el chip FTDI. Esto significa que el módulo Xbee puede comunicarse directamente con el ordenador – sin embargo, esto solo funciona si el microcontrolador ha sido quitado de la placa Arduino. Si el microcontrolador se deja en la placa Arduino, solo será capaz de comunicarse con el ordenador vía USB, pero ni el ordenador ni el microcontrolador podrán comunicarse con el módulo Xbee.
Práctica 1:
Comunicación entre 2 Arduinos vía XBee 802.15.4.
Deberías tener dos placas Arduino con XBee shield comunicándose una con la otra sin configurar nada, usando sólo los comandos estandard de Arduino.
Para cargar un programa a la placa Arduino con XBee shield, necesitarás poner los dos jumpers del shield en la posición USB (coloca los dos jumpers en la parte cercana al borde de la placa) o quítalos completamente.
Luego, ya puedes cargar un programa con normalidad desde el Arduino IDE. En este caso, carga el programa Communication | Physical Pixel a una de las placas. Este programa manda a la placa encender el LED conectado al pin 13 cuando recibe ‘H’ por el puerto serie y lo apaga cuando recibe ‘L’.
Puedes probarlo conectando la placa con el monitor de puerto serie de Arduino (asegurate de configurarlo a 9600 baudios), escribiendo H y INTRO (o pinchando en “send”) el LED debería encenderse. Envía L y el LED debería apagarse.
Una vez que has cargado el programa Physical Pixel y comprobado que funciona, desconecta el primer Arduino del ordenador. Conecta los jumpers en la posicion XBee (en la posición más alejada del borde de la placa). Ahora, necesitas cargar otro programa a la otra placa. Asegúrate de que sus jumpers estan en la posición USB. Luego carga el siguiente programa a la placa:
Sketch XBee:
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print('H');
delay(1000);
Serial.print('L');
delay(1000);
}
Cuando se haya cargado el programa, puedes comprobar que funciona con el monitor de puerto serie de Arduino. Deberías ver H’s y L’s llegando cada segundo. Apaga el monitor de puerto serie y desconecta la placa. Cambia los jumpers a la posición XBee. Ahora conecta las dos placas al ordenador, después de unos segundos, deberías ver el LED de la primera placa encenderse y apagarse cada segundo (el LED de la placa Arduino, no el LED de la placa XBee shield, que proporciona información sobre el estado del módulo XBee).
Práctica 2:
Timbre inalámbrico con Arduino y Xbee
Ahora vamos amos a hacer uso de dos estaciones cada una con Arduino Uno, Shield XBee, módulo XBee Serie 1. En la estación de Emisión (E) tenemos un pulsador para poder activar vía inalámbrica el buzzer y el LED ubicados en la estación de Recepción (R).
Scketch Emisor:
/*
-----------------------------------------------
Timbre inalámbrico - Estación Emisión (E)
-----------------------------------------------
Consiste en escribir por la pantalla del computador (consola serial)
una letra predeterminada, en este caso la letra 'D', cada
vez que se presione el pulsador se va a enviar la letra, como
el Arduino tiene conectado un módulo XBee esta letra se
enviar de manera inalámbrica.
*/
//--------------------------------------------------
//Declara puertos de entradas y salidas y variables
//--------------------------------------------------
int boton = 2; //Pin donde se encuentra el pulsador, entrada
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicación serial
pinMode(boton,INPUT); //Configura el pulsador como una entrada
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
//Pregunta si el pulsador esta oprimido
if(digitalRead(boton)==HIGH){
Serial.print('D'); //Imprime vía serial la letra 'D'
delay(10); //Retardo para no congestionar la escritura serial
}
}
Scketch Receptor:
/*
-----------------------------------------------
Timbre inalámbrico - Estación Recepción (R)
-----------------------------------------------
Este programa se mantiene recibiendo datos por el puerto serie,
si recibe la letra esperada en este caso la 'D', el programa
activa el buzzer (alarma sonora) y activa el LED (alarma visual)
*/
//--------------------------------------------------
//Declara puertos de entradas y salidas y variables
//--------------------------------------------------
int buzzer=5; //Pin donde se encuentra el buzzer, salida
int led=13; //Pin donde se encuentra el led, salida
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicación serial
pinMode(buzzer,OUTPUT); //Configura el buzzer como una salida
pinMode(led,OUTPUT); //Configura el led como una salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
// Pregunta si hay algún dato en el puerto serial
if(Serial.available()>0){
// Pregunta si el dato recibido es la letra 'D'
if(Serial.read() == 'D'){
digitalWrite(buzzer,HIGH); //Activa buzzer
delay(10); //Retardo
digitalWrite(buzzer,LOW); //Apaga buzzer
digitalWrite(led,HIGH); //Activa led
delay(10); //Retardo
digitalWrite(led,LOW); //Apaga led
} //Corchete If lectura letra 'D'
} //Corchete If lectura puerto serie
}
Práctica 3:
Comunicación entre dos Ordenadores mediante dos módulos XBee 802.15.4 (serie 1)
En esta aplicación vamos a realizar la conexión vía radio entre dos módulos conectados a dos PC. Se trata de enviar y recibir textos que se enviaran desde uno u otro PC a modo de un chat (bidireccional). Para ello utilizaremos los siguientes dispositivos:
2 Arduino XBee 802.15.4 OnChip (Series 1) Comprar
2 Arduino UNO Rev.3 Comprar
2 Ordenadores corriendo en cada uno de ellos un programa de Comunicación con el puerto serie.
Existen varios programas de Comunicación con el puerto serie para realizar la programación del modulo. En este caso vamos a usar el CoolTerm ya que trabaja con todos los sistemas operativos Windows, Mac, and Linux y además es libre.
Nota: En el caso en que usemos un Xbee explorer en vez del Arduino uno debemos instalar los drivers FTDI necesarios para que el ordenador reconozca el módulo XBee Explorer.
Preparación de Arduino Uno
Para configurar nuestras Xbee vamos a usar Arduino Uno sin el microcontrolador. Es posible retirarlo del Arduino, pero yo preferiria no intentarlo ya que podriamos estropearlo. Afortunadamente existe una forma para que el Arduino se salte al microcontrolador.
Para esto conectamos con un cable entre si RESET y GND de Arduino.
Preparación de Arduino Shield
En éste ejemplo ponemos los jumpers en la posición USB ( los dos pines más cercanos al borde de la placa).
START
Ahora ya podemos conectarlos:
Marcamos el primer modulo XBee con el que vamos a trabajar con la letra “A.”
Insertamos el módulo XBee sobre el XBee shield y éste al Arduino UNO.
Ahora conectamos el Arduino al Ordenador mediante el cable USB.
Configurar el software CoolTerm.
Abrimos el software CoolTerm y seleccionamos “Options” Seleccionamos el puerto serie por el que se ha conectado el módulo XBee.
Debemos asegurarnos de que la velocidad de transmisión se establece en 9600. El numero de bits de los datos es de 8. Se ajusta paridad a “ninguno”. Se ajusta el número de bits de parada en 1.
Ahora en la lista de la parte izquierda de la ventana de opciones, haga clic en “Terminal”. Asegúrese de que esta activo “Eco local”. Esto le permitirá ver lo que estás escribiendo en el terminal.
Hacemos Click en OK para grabar la configuración y cerramos la ventana de Opciones. Hacemos Click en “Connect” en la barra de menus. Debemos ver el estado “Connected” en la barra de estado.
Escribimos “+++” para entrar en el modo Comando. El sistema nos devuelva “OK”.
Nota: Por defecto el modulo XBee se desconecta si deja de recibir comandos en 10 segundos.
Comandos para configuración del módulo
Escribir cada comando seguido de sus parámetros y pulsar ENTER.
PAN ID: PAN es el número de la Red de Área Personal. Se trata de un identificador único para la red. Solo los XBees asignados a un PAN ID pueden comunicarse entre sí. Esto permite configurar redes separadas en el mismo lugar.
MY Address: Esta es la dirección de origen de un XBee, es una dirección única para cada unidad en particular.
Dirección de destino (parte alta): Representa la primera mitad de la dirección que queremos habilitar. En los módulos XBee puede tener una dirección de 64 bits, por lo que esta es la parte más alta de 32-bit de ese número de direcciones. Puesto que no necesitamos tantas direcciones, vamos a ponerlo a 0 y a sólo usar la parte alta.
Dirección de destino (parte baja): Esta es la dirección que usaremos para localizar el XBee Asegúrese de que coincida con el ajuste de la ATMY XBee con el que quiere hablar.
Los ajustes no se guardan hasta que no escriba el comando ATWR para guardar la configuración.
Así es como se verá la sesión en el terminal, a partir de la “+ + +” entraremos en modo comando.
+++ OK ATID 3001 OK ATMY 1 OK ATDH 0 OK ATDL 2 OK ATID 3001 ATMY 1 ATDH 0 ATDL 2 ATWR OK
Nota: Debemos obtener una respuesta OK después de emitir cada comando para establecer los parámetros, y otra respuesta OK al escribir los cambios en el firmware. Si usted no recibe una respuesta OK, lo más probable es que tomó más de diez segundos para el comando y el módulo dejo de estar en moco comando. El otro error común es no escribir el comando ATWR para guardar los cambios, si no lo hace su configuración se pierde al desconectar el módulo.
Haga clic en desconectar CoolTerm y quite el módulo XBee
Configuración de la segunda unidad de Radio
Marcar la segunda unidad XBee con una “B.”
Insertamos el módulo XBee sobre el XBee shield y éste al Arduino UNO.
Ahora conectamos el Arduino al Ordenador mediante el cable USB y hacemos click en “Connect” en el programa CoolTerm. A continuación seguir los mismos pasos que anteriormente hemos realizado con el modulo “A”. En este caso hacer ATMY 2 y el valor de ATDL 1.
Recordar que hay que escribir ATWR y presionar enter para salvar la configuración.
A continuación se muestran los códigos tal como se deben escribir y aparece en el terminal:
+++ OK ATID 3001 OK ATMY 2 OK ATDH 0 OK ATDL 1 OK ATID 3001 ATMY 2 ATDH 0 ATDL 1 ATWR OK
Funcionamiento
Para probar que funcionan la aplicación procederemos de la siguiente manera:
Conectamos el XBee “A” a otro XBee shield con otro arduino y conectamos a distintos PC en la misma habitación las dos Arduino.
Cargamos el programa CoolTerm y conectamos este siguiendo los pasos que ya comentamos anteriormente.
Si usted todavía está en el modo de comandos en cada módulo, puede escribir ATCN para salir del modo de comando sin tener que cuidarse de los 10 segundos de tiempo que tiene para escribir en el terminal sin que se desconecte el módulo.
Estamos en condiciones de realiza las pruebas de comunicación de mensajes entre ambos módulos de radio XBee. Si todo está configurado correctamente, el texto que se escribe en el programa del terminal serie en el primer equipo será transmitida al segundo ordenador y aparecerá en su pantalla de la terminal de serie también.
Más funciones
El protocolo 802.15.4 no sólo permite la comunicación punto a punto, también permite comunicarse punto-a-multipunto. Si tiene más de dos XBees y los puso a todos a la misma PAN ID (con ATID) y luego ponga la dirección de destino bajo de la emisora a FFFF (con ATDL FFFF). Ahora, al escribir en el terminal del XBee emisor, debemos ver el texto en todas las otras estaciones terminales.
| +++ | Enter command mode. |
| ATRE | Reset to factory defaults. |
| ATID | Get/set the radio’s PAN (Personal Area Network) ID. Radios working together must be in the same PAN. |
| ATBD | Get/set baud rate for the radio. |
| ATCH | Get/set the channel the radio will use to transmit/receive. |
| ATMY | Get/set a radio’s unique receive address. |
| ATDL | Get/set a radio’s transmission destination address. |
| ATWR | Write changes to the radio’s non-volatile memory. |
| ATCN | Exit command mode. |
Comandos ATBD:
- 1 = 2400bps
- 2 = 4800bps
- 3 = 9600bps
- 4 = 19200bps
- 5 = 38400bps
- 6 = 57600 bps
- 7 = 115200 bps
Si queremos configurar el Badurate a 9600bps, ponemos ATBD 3.
ATRE: restaura los valores predeterminados de fabrica antes de realizar cualquier modificación.
ATAP*: configuración de la API de XBee. Colocar el número que tiene la API de XBee, en nuestro caso 2, por lo que el comando sería ATAP2.
ATCE1: configuración del módulo XBee en modo Coordinador.
ATMY*: dirección del módulo XBee en modo Coordinador. El valor de * en nuestro caso será 1234. (ATMY1234)
ATID*: ID de la conexión que vamos a crear entre nuestros módulos XBee. El valor de * en nuestro caso es 1111. (ATID1111)
ATCH*: Canal por el cual los módulos XBee se van a conectar. El valor de * en nuestro caso será 0C. (ATCH0C)
ATWR: escribe una nueva configuración en la memoria no volátil. Si no se escribiese este comando, las modificaciones realizadas solo duraría hasta que el módulo se quede sin batería.
ATFR: reinicia el módulo XBee.
Para mas información mira la Tabla de Comandos AT
Modulos xBee 2
Ahora veremos la configuración basica para poder transmitir de un xBee serie2 a otro.
En este caso se usaron 2 modulos xBee 2 con antena de chip conectado al ordenador a través de Arduino.
Primero necesitamos descargar los drivers y programas necesarios de las siguientes paginas.
Software de configuracion XCTU ver. 5.1.4.1 installer installer (solo disponible para windows)
Driver de Arduino. Normalmente estos drivers vienen con el Software de Arduino. Lo puedes descargar en la siguiente página: http://arduino.cc/es/Main/Software
Si usas el xBee explorer descarga los drivers FTDI VCP 2.06.02 (multiplataforma).
Descarga el software XCTU en la siguiente página:
http://www.digi.com/support/productdetail?pid=3352&osvid=57&type=utilities
Instalalo siguiendo los pasos del instalador.
Conecta con el cable usb los dos modulos, cuando pregunte por el driver indicale que busque en la carpeta descargada anteriormente, una ves correctamente instalado el driver, en el administrador de dispositivos de windows deben de salir 2 puertos com. Si no te reconoce los puertos USB, debes actualizarlos.
Ahora inicia 2 ventanas de XCTU (una para cada modulo) y seleccionas el puerto com que se usara en cada uno, por default los modulos vienen configurados a 9600. El numero de bits de los datos es de 8. La paridad a “ninguno”. Y el número de bits de parada en 1. Deja estos valores así, si están distintos configúralos de este modo.
Para probar que este correctamente conectado damos click en el boton test/query, si todo sale bien tendremos la siguiente ventana, y tambien nos dira el tipo de modem que estamos utilizando y el firmware que lleva cargado.
Ahora nos vamos a la pestaña de Modem configuration.
Hacemos click en Read para ver la version actual del firmware en tu Xbee.
Para Restaurar las Xbee a su configuración inicial, le damos a “Clear Screen” y después a “Restore”.
Posteriormente le damos a “Read”. Ahora tenemos nuestras Xbee listas para configurar.
Configuración Xbee punto a multipunto
Si queremos hacer una conexión punto a multipunto, podríamos tener 1 Coordinator y varios Routers. De modo que configuramos todos los Routers de la siguiente forma.
Vamos a configurar una como COORDINATOR y otra o otras como ROUTER.
En modem elegimos el tipo de modem que desplego la ventana de test/query, en function set elegimos en el primer modem como COORDINATOR AT y en el segundo ROUTER/END DEVICE AT.
Los configuramos de la siguiente manera:
Observamos que el PAN ID, puede ser cualquier numero entre 0 y 65535 pero debe ser el mismo en todas las Xbee.
El COORDINATOR, Pone en DL: FFFF: Para enviar a todos los dispositivos de la misma red.
Damos click a Write para que suba la nueva configuración al modulo. Cuando termine de programar ya estarán listos para transmitir y recibir datos el uno al otro, para probar usamos la pestaña de Terminal, escribe algo y veras lo que pasa.
Una vez configurados los modulos estarán listos para nuestras aplicaciones electrónicas, para usar con el puerto serial de un microcontrolador y comunicarte con una pc u otro microcontrolador.
Si vamos a Terminal y damos:
+++OK
ATND
Nos salen los modulos a los cuales está conectada nuestra Xbee.
El orden de estos datos es el siguiente:
62FF= MY (dirección de red de 16 bits)
0013A200= SH (Numero de serie alto)
409BB861= SL (Numero de bajo)
Robot5= NI (Identificador de Nodos)
FFFE= Canales escaneados
01= Determina si es Router o Coordinator.
Comunicaciones Punto a Punto en Xbee 2
Para hacer una configuración punto a punto debemos configurar el direccionamiento, en ambos modulos debemos tener el mismo PAN ID.
En el COORDINATOR configuramos DH y DL (Destination Address) con SH y SL (Serial Number) del ROUTER, y en el ROUTER configuramos DH y DL con SH y SL del COORDINATOR.
El PAN ID debe ser el mismo numero en ambos XBee
El Destination Address High (DH), debe ser la dirección Alta (SH) del otro XBee, normalmente 13A200
El Destination Address Low (DL), debe ser la dirección Baja (SL) del otro XBee.
Nota: Tanto SH como SL se encuentran impresas en la etiqueta bajo el XBee, por lo tanto puedes escribirlo con anticipación o con el comando ATND pedemos ver las caracteriasticas de los modulos a los que estamos conectados.
Comunicación entre Xbee y Arduino por el puerto serial
En el caso en que no tengamos un Arduino Shield y usemos un Xbee Explorer, la conexión entre Arduino y Xbee es la siguiente:
- Arduino GND -> XBee GND
- Arduino TX -> XBee RX
- Arduino RX -> XBee TX
- Arduino VIN -> XBee VIN
Si tenemos una Xbee Shield, recordemos que tenemos que retirar el link entre Reset y GND para poder cargar al microcontrolador.
Ahora vamos a hacer una prueba. Carguemos el siguiente sketch en el COORDINATOR.
Sketch Xbee Hello Network:
void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.println("Hello XBee Network!");
delay(1000);
}
Cuando ya hayamos cargado el Sketch, conectamos la Xbee Shield a Arduino pero esta vez con los jumpers en posición Xbee (hacia el centro de la placa).
Si abrimos el Monitor Serial, vemos lo siguiente:
Si conectamos nuestro Xbee ROUTER a un ordenador y abrimos el Terminal de XCTU vemos que estaria recibiendo esto:
De esta forma podemos ver que las 2 Xbee se están comunicando y una de ellas se comunica con Arduino.
Comunicación inalámbrica entre 2 placas Arduino con Xbee
Controlando un Motor Servo con un potenciómetro de forma inalámbrica con Arduino y Xbee
Ahora podemos probar la comunicación inalámbrica entre 2 placas Arduino. Vamos a controlar un Motor Servo con un potenciómetro de forma inalámbrica.
Sketch Emisor:
int sensorValue1 = 0; // Almaceno el valor analogico
int myAngle1; // Divido el valor entre 6 para ajustar el angulo
const int analogInPin1 = A0; // Pin analogico conectado al potenciómetro
void setup(){
Serial.begin(9600);
}
void loop () {
sensorValue1 = analogRead(analogInPin1); // Leo el valor del potenciómetro
myAngle1=sensorValue1 / 6 ;
Serial.write(byte (myAngle1));
}
Sketch Receptor:
#include <Servo.h> // Libreria de servos
Servo myservo1; // variable servo
byte recepcion=0; // almacena el valor enviado desde el emisor
int myAngle1; // utilizada para pasar el valor a grados
void setup(){
Serial.begin(9600);
myservo1.attach(9); // se define el pin al que esta conectado el servo
}
void loop () {
if (Serial.available() > 0) { // si hay algun dato entrado por el serial empezamos
recepcion=Serial.read(); // se lee el dato se almacena
myAngle1=recepcion; // Volcado del dato recibido del emsior
myservo1.write(myAngle1); // se llama a la libreria con el valor del potenciómetro convertido en grados.
Serial.println(recepcion);// Imprime el valor que recibe
}
}
Nota: Esto funciona para Xbee Serie 1 y Xbee Serie 2. Pero no entre ellas. Debes configurar antes las Xbee para que se comuniquen entre ellas. No olvides programar con los Jumpers en modo USB y después ponerlos en modo Xbee para que se comunique entre ellas y con los Arduinos.
Con un Fotoresistor LDR
Si conservamos la misma configuración, pero en vez del potenciómentro ponemos un LDR podemos controlar el motor con la intensidad de luz.
La conexion seria un divisor de voltaje con 2 resistencias, 1 de 1kohm y la otra una resistencia variable LDR. En medio de las dos el divisor de voltaje que va al pin análogo 0.
Controlando un Motor Servo con un Acelerometro ADXL 335 de forma inalámbrica con Xbee
Escribimos el siguiente sketch en el Arduino que envía y el que recibe continua con el mismo sketch del ejemplo anterior.
Sketch xbee adxl send
/* ADXL 335
Lee el ADXL 335, acelerometro de tres ejes.
El circuito: * Salida X del acelerometro al pin analogico 3 * Salida Y del acelerometro al pin analogico 2 * +V del acelerometro a +3,3V * GND del acelerometro a ground
*/
const int xPin = 3; // eje x del acelerometro
const int yPin = 2; // eje y del acelerometro
int valox = 0; // variable para almacenar el valor x capturado desde el sensor
int valoy = 1; // variable para almacenar el valor y capturado desde el sensor
int adxl;
void setup()
{
// incializa comunicacion:
Serial.begin(9600);
}
void loop() {
valox = analogRead(xPin); // lee el valor x sensor valoy = analogRead(yPin); // lee el valor y sensor
int sensorValueX = analogRead(3); int sensorValueY = analogRead(2);
//imprime los valores:
adxl=sensorValueX / 6 ;
Serial.write(byte (sensorValueX));
//Serial.print("X");
//Serial.println(sensorValueX);
//Serial.print("Y");
//Serial.println(sensorValueY);
delay(50); }
Controlando un Motor Servo con un Sensor de Ultrasonido Ping de forma inalámbrica con Xbee
Escribimos el siguiente sketch en el Arduino que envía y el que recibe continua con el mismo sketch de los ejemplos anteriores.
Sketch Ultrasonido xbee send
// Ping pd theremin.
// constante pin 7 const int pingPin = 7; int xbee;
void setup() {
// inicializa la comunicacion serial:
Serial.begin(9600);
}
void loop()
{
//establece unas variables para la duracion del ping,
// y el resultado lo expresa en cm:
long duration, cm;
// PING es activado con un pulso HIGH de 2 o mas microsegundos. // Entrega un pulso LOW antes para asegurar que el pulso HIGH sea limpio: pinMode(pingPin, OUTPUT); digitalWrite(pingPin, LOW); delayMicroseconds(2); digitalWrite(pingPin, HIGH); delayMicroseconds(5); digitalWrite(pingPin, LOW);
// El mismo pin es usado para leer la señal del Ping: El pulso HIGH // Su tiempo de duracion se expresa en microsegundos y es el tiempo que pasa // ente la señal enviada por el Ping y la recepcion de su eco reflectado en un objeto. pinMode(pingPin, INPUT); duration = pulseIn(pingPin, HIGH);
// convierte el tiempo en distancia
cm = microsecondsToCentimeters(duration);
//imprime los valores: xbee=cm; Serial.write(byte (cm)); //Serial.print(cm); //Serial.println();
delay(100); }
long microsecondsToCentimeters(long microseconds)
{
// La velocidad del sonido es de 340 m/s o 29 microsegundos por centimetro.
// El sonido viaja de ida y vuelta, entonces para obtener la distancia del
// objeto tomamos la mitad de la distancia recorrida.
return microseconds / 29 / 2;
}
Controlando Motored DC y Dimmerizado de LEDS
Ya hemos experimentado con diversos sensores para controlar un Motor Servo.
Ahora veamos como controlar el Dimmerizado de un LED o la velocidad de un motor DC.
En el Arduino de la Xbee Receptora escribimos el siguiente sketch:
Sketch Dimmer LED con LDR
//Dimmer LED con LDR
const int ledPin = 9; // El pin al que el LED está conectado
void setup()
{
// Inicializamos puerto serie a 9600 bps:
Serial.begin(9600);
// inicializamos el ledPin como salida:
pinMode(ledPin, OUTPUT);
}
void loop() {
byte brightness;
// chequeamos que los datos hayan sido enviados por el ordenador:
if (Serial.available()) {
// Lee el byte mas reciente (debe ser entre 0 y 255):
brightness = Serial.read();
// Determina la luminocidad del LED:
analogWrite(ledPin, brightness);
}
}
Ahora conectamos nuestro led al pin 9. Recordemos usar siempre una resistencia de 220ohm en serie con el led para proteger la placa arduino y el led.
Red MESH
La figura anterior muestra un ejemplo de una red MESH. Se observa que se deseaacceder al punto B a partir del punto A. Suponiendo que la distancia entre A y B es demasiadopara que alcance la señal, se utiliza la red MESH para poder alcanzarla, así cada nodo ubicado enmedio del camino mostrado en celeste, funciona como módulo transparente, donde todo lo que lellega es retransmitido hacia el punto A. Esto funciona para cada un de los módulos de la red.
Xbee PRO
También existen los llamados módulos Xbee PRO de la Serie 1 que se diferencian en lacapacidad de alcance, permitiendo en algunos casos doblar la distancia de transmisión, ya queposeen una mayor potencia en la señal. Con los módulos Xbee PRO de la Serie 2, es posiblecrear redes más complejas, como las llamadas MESH. Estas permiten acceder a un punto remoto,utilizando módulos intermedios para llegar como routers. Además los módulos automáticamentegeneraran la red entre ellos, sin intervención humana alguna, permitiendo la reparación de la reden caso de que algún nodo falle. Al mismo tiempo la red por sí sola resuelve la mejor ruta paraun determinado paquete.
Modo “Sleep”
Un punto importante a la hora de comunicar 2 nodos es tener en cuenta la configuración del modo “Sleep” (Dormido) del nodo transmisor, un consejo para enviar datos con nodos que tienen periodos cíclicos de sueño, es habilitar el pin “Wake up” (Despertar), de tal manera que cuando se envíen datos a través del puerto serial para enviarlos de forma inalámbrica, se deba activar este pin para asegurar que el nodo Tx reciba la información y la envíe por la interfaz de aire, para ello se debe configurar las 2 opciones para dormir del dispositivo, las cuales serían: Por el pin “Wake up” y periodos cíclicos de sueño. Para el caso de la recepción no es necesario “despertar ” el nodo Rx a través del pin “Wake up”, ya que este nodo una vez que se despierta (Por los periodos cíclicos) envía una trama preguntando si existen mensajes para el, y el nodo Tx mantiene el mensaje en el buffer de salida hasta que recibe esta trama de solicitud del mensaje.