Tutorial Wifly

From Asociación de Robótica UC3M
Jump to navigation Jump to search

Tutorial practico para configurar el WiFly

Resumen

Este tutorial esta destinado a configurar el RN 171 (modelo RNXV) y se ira actualizando conforme se verifiquen las posibilidades que ofrece el modulo. Se va a configurar de manera que se conecte automaticamente a un router por si solo cada vez que se encienda. Para ello se guardaran los valores apropiados en memoria. Existen varias maneras de empezar a trabajar con el modulo. La primera de ellas sera configurarlo forzando un modo Ad-Hoc via Hardware y configurarlo mediante telnet. Seguidamente se explican otras maneras de configurarlo via arduino (FIO en este caso).

Se utilizara:

WiFly 171 RN XV
  1. Ubuntu
  2. FIO Arduino FIO
  3. Manual WiFly y Pequeño datasheet]
  4. Conocimientos previos nulos sobre nada en absoluto.


Nota: El arduino FIO incorpora un "socket" que permite acoplar un modulo XBEE en principio de la compañia DIGI. Roving Networks pone a la venta una version del modelo RN 171 con el mismo patillaje destinado a que se acople a cualquier tarjeta con soporte para XBEE. Aunque tanto el soporte XBEE de Fio y el WiFly sean de 20 pines, tan solo unos pocos estan fisicamente conectados entre el soporte XBEE y la propia tarjeta Fio. En el momento de escribir este tutorial se tiene conocimiento de que el Arduino Fio proporciona VCC, GND, RX y TX al modulo que se le acople. El esquematico de FIO no proporciona informacion sobre alguna otra conexion.


Via Telnet

Pasos

1. En primer lugar habilitamos el modo AdHoc del WiFly conectando con un cable VCC (3,3V) y el pin 8 del XBEE (GPIO_9) (Observar fotografias; el pin 1 tiene soldadura cuadrada). De esta manera el dispositivo se le prepara para que otro dispositivo se conecte al el sin AP (punto de acceso). (Nota: Puede observarse que se ha optado por la solucion mas profesional posible). Existen 2 maneras de activar el AdHoc: via Hardware como aqui se ha hecho y via Software entrando en modo configuracion, pero como aun no nos podemos conectar esta manera no nos sirve.


  • conexion pin8 a VCC
  • Wifly1.jpg
  • Wifly2.JPG
  • Wifly3.JPG
Cable cotesia de Juan Victores.
Al alimentarlo con el FTDI tiene que encenderse, a parte de los LEDs rojo y verde, el ambar. Si es asi, vamos por buen camino.


2. Segun el fabricante el WiFly en modo AdHoc viene por defecto con:


IP: 169.254.1.1
Netmask: 255.255.0.0


Ahora debemos conectarnos a su red. Para ello, una vez alimentado debemos esperar (puede que minutos) hasta que aparezca Wifly-GSX-XX en el listado de conexiones inalambricas de linux (arriba a la derecha). Las XX son los dos ultimos bytes de la direccion MAC del dispositivo Wifly. Una vez que aparezca vamos a editar conexiones y seleccionamos Wifly-GSX-XX dentro de wireless y la editamos. Dentro de la pestaña "wireless" debemos seleccionar modo AdHoc y dejar todo lo demas como esta. En la pestaña "Wireless security" escogemos "none". En la pestaña IPv4 escogemos metodo manual y selccionamos "add" en "Addresses" (o añadir en direccion). Ahora debemos escribir una IP para nuestro PC que este en la misma subred que el Wifly. Podemos configurar una IP por ejemplo que sea 169.254.1.2 y escribimos en Netmask 255.255.0.0.
Guardamos los cambios y conectamos con la red Wifly-GSX-XX. Una vez conectados desde la terminal hacemos "ping 169.254.1.1" y de esta manera comprobamos que estamos enviando y recibiendo paquetes a esa direccion. Si todo va bien, deberiamos de recibir informacion. Para salir de ping tecleamos "ctrl + c".


3. Es hora de configurar el modulo: En el manual se explican todas las instrucciones posibles para configurarlo y algunos ejemplos. Aqui vamos a hacer un resumen para no tener que sumergirse tanto en todas las instrucciones que hay disponibles y poder tener el modulo "ready to go" en pocos pasos y tiempo.
  • El modulo Wifly puede estar en dos modos: configuracion, y datos (por defecto). Para empezar a hablar al WiFly, desde la terminal tecleamos "telnet 169.254.1.1 2000" (puerto 2000 por defecto) y deberiamos recibir un "HELLO" por parte del dispositivo.
  • Introducimos $$$ y deberia contestarnos CMD. Ya estamos en modo configuracion.
  • Escribimos set wlan auth 0 para que la red sea abierta, sin autentificacion.
  • set ip dhcp 0 Con esto hacemos "DHCP off": No pedira al router una IP ni puerta de acceso. Usara la configuracion que le guardemos a continuacion.
  • set ip address XXX.XXX.XXX.YYY. Aqui escribimos la IP que tendra el Wifly.
  • set ip host XXX.XXX.XXX.ZZZ. Aqui la IP del router al que se debe conectar. (observese que solo debe variar el ultimo byte).
  • set ip netmask 255.255.255.0.
  • set wlan ssid "nombre de la red".
  • set wlan channel 0. Un valor de 0 hara que busque por la SSID escrita anteriormente por todos los canales.
  • set wlan join 1. Intentara acceder automaticamente al punto de acceso que coincida con la SSID guardada.
  • save.
  • reboot.


4. Ahora podemos desconectar el FTDI y quitar el cable que puentea el VCC con el PIN8 (GPIO_9). La proxima vez que se alimente el WiFly se conectara automaticamente al router.


Mediante libreria

En internet pueden encontrarse varias librerias destinadas al manejo del WiFly, y funcionan todas ellas de un modo similar (WiFly, WiFlySerial, WiflyHQ, etc).

La libreria mas completa y robusta es: Wifly-Shield-Master

Para instalarla hay que descargarla y descomprimir el contenido en la carpeta libraries (si no existe se debe crear) dentro de sketchbook (carpeta principal de arduino), esto es colocar la carpeta Wifly-Shield-Master en ~/sketchbook/libraries. La propia libreria trae ejemplos de codigos para arduino (cliente, servidor, etc). El arduino IDE no acepta librerias con guiones '-' asi que debemos cambiar el nombre de la carpeta (por ejemplo por simplicidad a Wifly). (luego para usarla en un programa habra que escribir #include <Wifly.h>).

Para empezar a trabajar con ella basta con escribir una funcion setup() de esta manera:

#include <SoftwareSerial.h>
#include <WiFly.h>
#include <SPI.h>
#include "Credentials.h"


//(naranja, amarillo) del ftdi
SoftwareSerial serialTest(8,7);


void setup() {
Serial.begin(9600);
serialTest.begin(9600);
serialTest.println("antes del begin");
WiFly.setUart(&Serial);
WiFly.begin();
serialTest.println("despues del begin");
Serial.flush();


if (!WiFly.join(ssid, passphrase, true)) {
serialTest.println("no se ha conectado");
while (1) {
// Hang on failure.
}
}
serialTest.print("IP: ");
serialTest.println(WiFly.ip());
}



En esta funcion de inicializacion mediante la funcion Wifly.begin() se entra en modo configuracion y establece (por defecto) un servidor externo del cual extraer la hora. Se recomienda comentar esa parte de la libreria para simplificar la configuracion. El fichero de la libreria Wifly.h en el que se encuentran casi todos los metodos de referencia es WiflyDevice.cpp.

Mediante las funciones begin() de los puertos serie se inicializan dichos puertos. Con la libreria SoftwareSerial habilitamos unos pines diferentes de los pines por defecto como tx y rx. Como argumentos de entrada del objeto de la clase SoftwareSerial hay que escribir los pines a los que se conectan los cables (Naranja, amarillo).

Con la funcion Join se conecta a la red con la ssid y clave que se especifiquen en el fichero credentials.































Para llevar a cabo este programa es necesario disponer de dos calbes ftdi. El primero de ellos carga el programa y alimenta la FIO por los pines estandar TX y RX , (puertos Serial) y estos se comunican con el modulo Wifly (mediante Serial.print()). El segundo cable solo necesita tener los colores naranja y amarillo y se conectara a los pines que se definan con SoftwareSerial a otro USB. Los datos que lea ese segundo cable son los que se mostraran por pantalla en el monitor serie del 'IDE'. Para ello escribimos un bucle loop() de la siguiente manera:

void loop() {
while (Serial.available()) {
int incomming = Serial.read();
serialTest.println(incomming);
}
}


Ahora lo que el arduino lea proveniente del Wifly lo escribira en el monitor serie asociado al puerto usb que se conecte con los pines SoftwareSerial.

Para enviar datos al Wifly se hace un telnet a la IP que devuelve el programa a traves del Serial monitor del IDE. De esta manera todo lo que se escriba en la terminal telnet aparecera en el monitor serie. Si se quiere invertir la comunicacion basta con cambiar Serial.avaiilable() por serialTest.available(), Serial.read() por SerialTest.read() y serialTest.print() por Serial.print(). Ya se ha establecido por medio de Arduino una configuracion, conexion y envio/recepcion de datos.

Directamente mediante Sketch en Arduino IDE

Por ultimo veremos como configurar el modulo Wifly, sin libreria. Simplemente escribiendo un programa (sketch) en el arduino y contando con que la UART del FIO esta conectada con el modulo Wifly. De esta manera las funciones Serial.print() y Serial.read() escribiran y leeran datos en y desde el RN-171.

La unica precaucion que debemos tomar es que entre las cadenas de instrucciones que se manden al modulo Wify, debe pasar un tiempo, entre otras cosas por que este siempre da una respuesta a cada instruccion. A continuacion veremos un programa, que cargado en el arduino FIO, configura el modulo sin problemas:

#include <SoftwareSerial.h>
#include <WiFly.h>
#include <SPI.h>
char receiver[512];
int cont;
//(naranja, amarillo)
SoftwareSerial serialTest(8,7);
void setup() {
Serial.begin(9600);
serialTest.begin(9600);
WiFly.setUart(&Serial);
Serial.flush();
delay(1000);
Serial.print("$$$"); check();
Serial.print("set wlan auth 0\r"); check();//Red abierta, sin autentificacion.
Serial.print("set ip dhcp 0\r"); check();// Con esto hacemos "DHCP off".
Serial.print("set ip adress XXX.XXX.XXX.XXX\r"); check();// IP del Wifly en la red local.
Serial.print("set ip host xxx.xxx.xxx.xxx\r"); check();// IP del router.
Serial.print("set ip netmask 255.255.255.0\r"); check();//mascara de subred.
Serial.print("set wlan ssid "SSID"\r"); check();
Serial.print("set wlan chanel 0\r"); check(); //busque por la SSID escrita anteriormente por todos los canales.
Serial.print("set wlan join 1\r"); check();// Intentara acceder automaticamente al punto de acceso que coincida con la SSID guardada.
//Serial.print("save\r");
//Serial.print("reboot\r");
serialTest.print("IP: ");
serialTest.println(WiFly.ip());
}


void check(){
cont=0; delay(1000);
// Recibe la respuesta del Wifly
while (Serial.available()>0) {
receiver[cont]=Serial.read(); delay(100);
cont++;
}
receiver[cont]='\0';
//Escribe la respuesta
serialTest.println(receiver);
// Vacia el buffer
serialTest.flush(); delay(1000);
}


La funcion check(), sacada de aqui, permite que pase tiempo entre las instrucciones, y recoje la respuesta que da el modulo en un array. Como funcion loop() puede utilizarse la misma que antes como prueba. Por ultimo, cabe destacar, que hay que enviar un caracter '/r' como retorno de carro para todas las instrucciones escepto para la de entrada en configuracion $$$.

Conclusiones

Despues de cualquier metodo utilizado, se recomienda escribir la instruccion save para no tener que entrar en modo configuracion y reconfigurar el modulo cada vez que se quiera probar un nuevo programa, siempre y cuando se trate de la misma red. Con el primer metodo, simplemente seria escribir save, y luego reboot. Para el metodo con libreria habria que editar el fichero .cpp correspondiente y escribir sendCommand(F("save")); dentro del metodo setConfiguration().

Retrieved from "https://apps-robots.uc3m.es/asrob/w/index.php?title=Tutorial_Wifly&oldid=9731"