Todo hay que decir que el celebro despues de 3 horas haciendo PCBs y 5 horas programando acaba un poco puff así que no os asusteis por las locuras que hacemos. (Las escenas más duras las hemos eliminado).

Como caracteristicas más importantes, aparte de sus 9 grados de libertad, cabe destacar las comunicaciones: Bluetooth, usb y I2C. Varios sensores: Medidor de distancias Infrarojo, acelerometro, voltaje de bateria. Tiene bastantes posibilidades a la hora de usarlo como plataforma de aprendizaje por ejemplo permite su conexion a PC o el uso del nunchuck de la wii.

Para la programación se usa el entorno Arduino lo que permite desarrollar aplicaciones de forma muy rapida y a cualquier nivel.

¡Espero que os guste y que pronto podamos ver muchas más!

Hace poco que realizamos un nuevo hardware para Galatea basado en un ATMega168 y programable desde Arduino. A las ventajas de este nuevo hardware le aparecieron algunos problemas entre los que destacan: El poco tiempo que disponemos y la necesidad de ver resultados a corto plazo, sabiendo que reescribir todo el código de la antigua versión iba a ser una tarea poco sencilla. Visto desde este modo solo había una solución Innovar. Dejamos de lado ordenadores códigos de versiones y con solo un folio en blanco un un papel nos dispusimos a dibujar lo que queríamos, en forma de ondas. Después de unas cuantas horas de trabajo obtuvimos una cosa que caminaba, pero lo importante es eso ¡que caminaba! Han bastado un par de días para modificar las formas de ondas y los defases hasta obtener el siguiente resultado:

Espero que os guste!

El conexionado del montaje es muy simple conectamos el enable a dos canales PWM y la señal de dirección a otros dos pines digitales cualesquiera.conectamos las bobinas a la etapa de potencia y alimentamos todo.

El codigo fuente es bastante sencillo dos bucles For uno encargado de la ida y otro de la vuelta. Todo controlado por 2 variables Y y Z las cuales controlan la potencia de las bobinas y la velocidad de avance:

int y = 2;
int z = 125;

void loop()
{
for (int x = 0; x < 65; x++)
{
digitalWrite(4, HIGH);
digitalWrite(7, HIGH);
delay(y);
digitalWrite(4, HIGH);
digitalWrite(7, LOW);
delay(y);
digitalWrite(4, LOW);
digitalWrite(7, LOW);
delay(y);
digitalWrite(4, LOW);
digitalWrite(7, HIGH);
delay(y);
}
for (int x = 0; x < 65; x++)
{
digitalWrite(4, LOW);
digitalWrite(7, LOW);
delay(y);
digitalWrite(4, HIGH);
digitalWrite(7, LOW);
delay(y);
digitalWrite(4, HIGH);
digitalWrite(7, HIGH);
delay(y);
digitalWrite(4, LOW);
digitalWrite(7, HIGH);
delay(y);
}
}


unsigned int lectura()
{
unsigned long acu = 0;
unsigned long largo = 0;
unsigned long primero = 0;
unsigned long ultimo = 0;
for (int x = 0; x <2; x++)
{
// enviamos al sensor un pulso de 10uS
pinMode(pulso1, OUTPUT);
pinMode(eco1, OUTPUT);
digitalWrite(pulso1, HIGH);
delayMicroseconds(10);
digitalWrite(pulso1, LOW);

while(digitalRead(eco1) == 0); //Esperamos a que el SRF05 ponga la linea en alto para empezar a contar
primero = micros(); //anotamos el valor al poner la linea en alto
while(digitalRead(eco1) == 1); //Cuando pone la linea en bajo seguimos adelante
ultimo = micros(); //anotamos el valor al poner la linea en bajo
largo = ultimo – primero; // calculamos el valor de la distancia
acu += largo ; //acumulamos los valores
delay(50); //evitamos que se solapen los rebotes
}
// convertimos a centimetros la medida (1 cm por cada 58uS por dos medidas)
return( (unsigned int) (acu / 116) );
//(Salida para debug):
//Serial.print(“Delante = “);
//Serial.println(acu / 116);
}

Y ahora las posibles mejoras:

• Timeout:

while(digitalRead(eco1) == 0);
while(digitalRead(eco1) == 1);


Se podría añadir una segunda condición por si el sensor esta desconectado no se quede bloqueado.

• Desbordamiento:

largo = ultimo - primero; // calculamos el valor de la distancia
acu += largo ; //acumulamos los valores


No se tiene en cuenta que la función micros() se desborda cada 70 minutos. Se podría hacer una comparación para que segundo siempre sea mayor que primero.

• Precisión:


return( (unsigned int) (acu / 116) );


Se podría añadir parametros o sobrecargas para definir el numero de muestras a tomar y si queremos precisión de milimetros.

Espero que sea de utilidad.

Así que el primer paso es este tutorial de como montar una sonda de temperatura (sumergible). Para ello voy a usar un TC1047A (sensor de temperatura fabricado por microchip) aunque bien podría usarse cualquier otro por ejemplo un LM35.

Leer el texto completo

Para empezar la lista de materiales:

-Sensor a usar (En mi caso un TC1047A).
-Conector de 3 pines con sus contactos.
-Cable con 3 hilos (o más) he usado un cable de auricular roto por que es bastante fino y queda bien.
-Un chupón para fijar cables dentro del acuario (nos valdrá cualquiera que sea pequeño)
-Estaño y útiles de soldadura.
-Silicona termofusible, también se puede usar silicona no toxica pero tardará en secar un par de días.
-Paciencia si habéis elegido el sensor smd o es la primera vez que soldáis.

Para empezar cortaremos el cable del auricular por donde estén juntos los dos cables y 5-10mm antes del conector. Los pelaremos y tendremos cuidado de rascar con una cuchilla el esmalte protector de la punta del hilo de Audio. En primer lugar conviene soldar el conector, ya que así podremos ir marcando las conexiones que hacemos en el sensor. En mi caso he dejado la masa en medio, la señal en el pin 1 y el positivo en el pin 3. Para montarlo lo primero sera cortar los contactos y soldar cada cable a uno de los contactos, después habrá que introducirlos hasta que hagan clip (nos podemos ayudar con un destornillador fino con cuidado de no romper el cable)

Para darle mas protección al conector y evitar que se nos rompa fácilmente lo pincharemos en su macho y le añadiremos silicona termofusible en el lado del cable quedando esa solida dejando el primer segmento de cable fijo.

El siguiente paso será soldar el sensor al otro extremo y marcar que conectamos a cada pin para ello nos guiaremos de la imagen que facilita la hoja de características:

Dejándolo todo soldado como se ve en la siguiente imagen:

El siguiente paso será adaptarlo al acuario, para ello tendrá que cumplir dos condiciones: Se deberá poder fijar al cristal y debe ser estanco. Para cumplir la primera usaremos el chupón pasa tubos:

Como veis tiene un agujero para pasar muy grande y que no vamos a necesitar así que lo cortamos dejando solo un par de espigas a donde se sujetará nuestro sensor.

Para cumplir la otra condición usaremos la silicona termofusible primero con ayuda de una caña haremos un pequeño tubo con el sensor totalmente cubierto de silicona. Para después fijarlo con mas silicona al chupón.

Una vez terminado de montar nos deberá quedar algo así:

Por ultimo solo nos queda probar el sensor para lo que nos sería útil tener la temperatura conocida de la habitación o por ejemplo usar un vaso de hielo con algo de agua. En mi caso lo he comparado con el termómetro de escritorio. El montaje es sencillo conectar el positivo a 5 voltios, la masa con la masa y en la señal conectamos el polímetro (ojo la masa del polímetro también hay que conectarla a masa).

Como podréis imaginar no estamos a 745ºC ni nada por el estilo para saber la temperatura debemos restar 500 a la medida en mV y multiplicarla por 100, por lo que tenemos 24,5ºC. En el vaso con hielo deberíamos tener 500mV. La razón de este calculo nos lo da también la hoja de características:

Espero que os haya gustado, próximamente seguiré con mas tutoriales entre ellos iluminación LEDs, Sonda de PH y algunas cosas que vayan surgiendo.

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.

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.

Mi mayor participación en el evento ha sido la realización junto con FJ_Sanchez de un Nodo/Taller sobre Arduino, en el se han iniciado en su uso unas veinte personas. El taller se componía de dos sesiones, una primera teórica donde se explicaba el proyecto, su hardware, su software y se acabo comentando las posibilidades que ofrece el sistema. Desde aquí gracias a todos los que asistieron aunque no participaran despues en el Taller práctico. Al final de esta sesión se realizaron dos pequeñas demostraciones de uso, una de ellas preparada por FJ_Sanchez el control de un led desde un servidor Apache. Por mi parte realicé una demostración del Robot Fonera.

La segunda sesión fue algo mas alocada, una sala amplia, muchos ordenadores, muchos arduinos y muchas ganas de aprender. El comienzo fue como todos los comienzos, encender y apagar un led, escribir Hola mundo en el puerto serie, etc… Despues se repartio material y cada uno empezo a desarrollar lo que quiso, movimiento de servos, leds de colores (incluso con leds RGB) se llegó a la conclusión que no se puede programar con un led parapadeando en tu cara, lectura de sensores de temperatura, potenciometros y alguna música con buzzers.

Si hubiera una segunda ocasión personalmente cambiaría dos cosas, la primera acortaría la teoria a 1 hora y alargaría la práctica a 2 horas y la segunda, que junto con el Arduino se trajera un “kit” de componentes para empezar a trabajar, un par de leds, un par de potenciometros y algún sensor barato de forma que todos pueden programar fácilmente cualquiera de esos elementos.

Enlaces:

http://www.sindominio.net/hackmeeting/index.php/2008/Nodos/Taller_de_arduino

http://www.arduino.cc/es/

http://www.arduino.cc/

Presentación