RoBoOpS

Hace tiempo que en los foros de A.R.D.E. comente que había hecho las pruebas para usar Pinguino (una especie de Arduino pero con un PIC 18F2550 ) con la LCD2550, ahora que tengo algo de tiempo os cuento los resultados:

Para empezar he tenido que modificar el hardware, pero muy ligeramente he colocado una resistencia de pull up de 4k7 entre RA4 y +5v, y un pulsador de RUN entre RA4 y GND. A partir de hay solo toca jugar con el software. Cargamos el hex en nuestro pic y a funcionar, para empezar instalamos el software, y si es necesario también los drivers (Todo ello y el hex para el PIC18F2550 está disponible en http://www.hackinglab.org/ ).

Para empezar he modificado su programa de blink para usarlo con el backlight de la LCD:

// Parpadeo de retroiluminado basado en:
// Test blink with Pinguino jean-pierre MANDON 2008
// Modificado por BoOpS - FJSG

int bl=8;                    // Backlight conectado al pin 8
int tiempo;                    // declaramos tiempo como entero

void setup()
{
tiempo=300;                // tiempo de parpadeo 300ms (ciclo de 600ms)
pinMode(bl,OUTPUT);            // configuramos el pin como salida
}

void loop()
{

while (1)
{
digitalWrite(bl,HIGH);            // encendemos el retroiluminado
delay(tiempo);                // espera 300ms
digitalWrite(bl,LOW);            // apagamos el retroiluminado
delay(tiempo);                // espera 300ms
}
}

Con eso, compilamos y cargamos, ojo si estamos en linux tendremos que ejecutar el software como root.

Bueno para los que les gusten las comparaciones, no es ni mejor ni peor que Arduino. Eso si ligeramente más económico ya que nos ahorramos de algunos componentes como puede ser el conversor usb serie.

Próximamente espero migrar alguna de las librerias de LCD de Arduino y más cositas!

Al llegar de Campus Party 08, compré un modulo WT11 de Bluegiga para una posible implementación de Bluetooth en las Galateas. Como ya os dije en la entrada anterior estas Navidades van a estar llenas de electrónica, hoy ha tocado el Bluetooth, así que hojeando la documentación de la SkyBluetooth, la tarjeta ArduinoBT y con un poco de polimetro he mirado la forma mas sencilla de conectar el modulo bluetooth sin tener que ponerme a hacer una PCB. Para ello voy a usar un Arduino Diecimila, más que nada por comodidad y por disponer de varios ejemplos de uso.

Para trabajar con ella necesitaremos 3 cables de señales y la alimentación (3v3 y GND). Las señales de entrada se conectan a través de una resistencia de 2k2, ojo a la de salida (TX) no se le puede conectar ninguna resistencia ya que reduciría la tensión y no es detectado por el Arduino. Sobre las alimentaciones y masas son comunes, con conectar un pin de alimentación y uno de masa es suficiente. El esquema para conectarlo es el siguiente:

Una vez listo el montaje el siguiente paso es cargar el código en el Arduino, yo le he realizado una pequeña modificación para que me permita comprobar que la recepción es correcta:

/* BT test 01
* ——————
* Massimo Banzi
* Modificado por F. Javier Suvires G. - BoOpS
*
*/

int LED = 13;   // selecciona el pin del LED
int RESET = 7;

void setup() {
pinMode(LED,OUTPUT);   // declara el pin del LED como salida
pinMode(RESET,OUTPUT);   // declara el pin del RESET como salida
Serial.begin(115200);        // conecta el puerto serie
digitalWrite(RESET, HIGH);  //genera un reset
delay(10);
digitalWrite(RESET, LOW);
delay(2000);
Serial.println(”SET BT PAGEMODE 3 2000 1″);
Serial.println(”SET BT NAME ARDUINOBT”);
Serial.println(”SET BT ROLE 0 f 7d00″);
Serial.println(”SET CONTROL ECHO 0″);
Serial.println(”SET BT AUTH * 12345″);
Serial.println(”SET CONTROL ESCAPE - 00 1″);
Serial.println(”SET CONTROL BAUD 115200,8n1″);
}

void loop () {
digitalWrite(LED, HIGH);
delay(100);
digitalWrite(LED, LOW);
Serial.println(”Hola mundo +123″); //imprime la prueba
while (Serial.available() > 0)  {Serial.print(Serial.read(), BYTE);} //imprime los caracteres recibidos
delay(1000);
}

El siguiente paso será Symbian + Python + Bluetooth. ¿Alguien quiere colaborar? Espero que sea pronto.

Hace tiempo que publiqué una pequeña introducción a mi trabajo con los módulos Xport de Lantronix. Debido a la falta de tiempo entre viajes estudios y trabajo no he podido seguir publicando mis avances. Ahora por fin estamos en las vacaciones de Navidad y puesto que tengo que preparar la documentación para entregar el proyecto, voy a refrescarme a mi mismo la memoria subiendo mas información por aquí.

Como ya hice una primer acercamiento en la anterior entrada: “Empezando con Xport”.  Ahora me voy a centrar más en el uso que creo que me es mas interesante, servir una página web desde nuestro proyecto permitiendo interactuar con el desde una red LAN o  desde Internet.

Para empezar lo primero que haremos es configurar el Xport con los siguientes parametros:

*** Channel 1
Baudrate 9600, I/F Mode 4C, Flow 00
Port 00080
Connect Mode : C4
Send ‘+++’ in Modem Mode enabled
Show IP addr after ‘RING’ enabled
Auto increment source port disabled
Remote IP Adr: — none —, Port 00000
Disconn Mode : 80  Disconn Time: 00:03
Flush   Mode : 77

Para ello o bien podemos usar la utilidad de Lantronix Device Installer o conectarnos por Telnet al puerto 9999. Si usamos la utilidad de Lantronix tenemos la ventaja de que automáticamente nos buscará algún Xport conectado a nuestra red.

Una vez configurado esto el siguiente paso es escuchar por el puerto serie las peticiones que nos harán para ello he usado la librería de Arduino con lo que se simplifica el control a tres bloques:

Bloque uno: Definición de las posibles respuestas, en el usaremos la memoria de código para grabar el código html para las respuestas. Quizás fuera conveniente usar una memoria eeprom externa o na tarjeta SD pero para no complicar la cosa seguí usando este método.

const char http_404header[] PROGMEM = “HTTP/1.1 404 Not Found\nServer: arduino\nContent-Type: text/html\n\n<html><head><title>404</title></head><body><h1>404: Página no encontrada</h1></body>”;
const char http_header[] PROGMEM = “HTTP/1.0 200 OK\nServer: arduino\nContent-Type: text/html\n\n”;
const char html_header[] PROGMEM = “<html><head><title>Servidor web con Arduino</title><link rel=\”shortcut icon\” href=\”http://www.roboops.es/wp-content/uploads/w3/favicon.ico\” type=\”image/x-icon\” /></head><body>”;
const char forma[] PROGMEM = “<p><h1>Probando Arduino como WebServer</h1></p><img src=\”http:/”;
const char formb[] PROGMEM = “/www.roboops.es/wp-content/uploads/2008/10/10102008R.JPG\”>”;
const char formc[] PROGMEM = “<p>Esta página está servida por un ATmega168 con un Xport.</p></body>”;
const char formd[] PROGMEM = “<p>Bienvenido a la home</p></body>”;

Bloque dos: El siguiente bloque es el que se encarga de interpretar las peticiones.

read = xport.readline_timeout(linebuffer, 128, 200);
if (read == 0)     // Se ha alcanzado el tiempo limite
return 0;
if (read)          // Hay algo!
Serial.println(linebuffer); //Lo mostramos por el segundo puerto serie (para pruebas)
if (strstr(linebuffer, “GET / “)) {
return 200;   // Si comienza con una peticion es correcto
}
if (strstr(linebuffer, “GET /?”)) {
return 200;   // Si es un CGI valido es correcto
}
if (strstr(linebuffer, “GET /home”)) {
return 201;   // Si es la pagina home es correcto
}
if(strstr(linebuffer, “GET “)) {
return 404;    // si es cualquier otra cosa, lo siento pero no la tenemos.
}

Bloque tres: Respuesta. Se definen las diferentes respuestas para las diferentes peticiones.

void respond(){
uint8_t temp;
xport.flush(50);  //  vaciamos el buffer
xport.ROM_print(http_header);  // mandamos la cabecera http
xport.ROM_print(html_header); // mandamos la cabecera html
xport.ROM_print(forma); /comenzamos a enviar la página
xport.ROM_print(formb);
xport.ROM_print(formc);
xport.flush(255); // vaciamos el buffer
xport.disconnect(); // nos deconectamos
}

Ya tenemos nuestra web servida por el Xport ahora el siguiente paso será hacer una web interactiva mediante la que recibamos y enviaemos datos del usuario.