Lo bueno de esta página es que habla de que las cámaras foscam (y la zaapa ciprw es una de ellas con el modelo FI8901W) no mueren del todo, sino que tienen un puerto serie escondido al que se puede acceder y comunicarse con una consola para cargar un firmware. Yo me he comunicado con la cámara con un conversor serie TTL a USB:

La solución ya estaba, sólo tenía que conseguir el firmware de la zaapa (ya que otros no valen) y decirle a mi amigo que me dejase su cámara para arreglársela. Pero no ha sido así de fácil y he tenido que pelearme con varios frentes.

El primero es el servicio técnico de Foscam. En el comentario 101 del anterior enlace un tal David comentaba que Doris de Foscam había sido muy amable y que le había dado los ficheros de recuperación. Yo probé la misma suerte con el servicio técnico de Foscam y esta fué la primera respuesta que obtuve:

Hi,

We do not have a model No. FI8901W camera, could you please double check the model No.?

Es decir, que no saben ni los modelos que han fabricado. Le dije que si existía ese modelo de cámara en su marca y me contesto esto otro:

Hi,

Sorry for my mistake. We have stopped produce this product for a long time. We do not have the firmware now. Sorry for this.

Vamos que no querían ayudarme en nada (David, que suerte tuviste…).

Buscando por Internet unos ficheros de recupercación para la zaapa o para la FOSCAM FI8901W no encontré nada. Pero por suerte encontré esto otro. Una forma de extraer de una cámara que funcionase su firmware a través de la consola serie oculta. El proceso fue pesado: me tuve que bajar el kermit 95 y buscar cómo demonios abrir una consola serie, después esperé un rato largo a que se ejecutara el script, convertir con el jedit una salida en otro fichero y finalmente pasar el convertidor de hexadecimal a binario, el cual tuve que compilar, modificar y compilar de nuevo para que funcionase. Todo esto para que al final no se hubiera decargado correctamente el firmware linux.bin y romfs.img necesarios para reprogramar la cámara estropeada, dando esta errores nada más arrancar.

Parecía que no iba a dar con la solución, pero encontré un programa que te descargaba automáticamente los ficheros necesarios del firmware. Lo ejecuté y parecía que había hecho bien su trabajo, pero pasó lo mismo que en el anterior párrafo aunque esta vez sólo con el fichero linux.bin. Sin embargo gracias a esta otra página descubro que el fichero linux.bin es en realidad un archivo .zip y que lo que había hecho está aplicación es comerse los últimos 168 bytes, asi que leyendo la memoria de  la cámara que funcionaba recuperé esos 168 bytes.

Finalmente seguí paso por paso el proceso de nuevo pero cambiando los comandos fx por estos:

fx 6 romfs.img 0x7F0D0000 0x7F0D0000 -a
fx 7 linux.bin 0x7F020000 0x00008000 -acxz

Para Windows 7 como no existe el Hyperterminal, he usado el Tera Term.

Finalmente la cámara de mi amigo ha dejado de ser un pisapapeles y ha vuelto a funcionar, pudiéndola manejar ahora con Firefox, con su IPhone, etc.

Para evitaros las incomodidades por las que yo he pasado os dejo los enlaces de los ficheros de recuperación de la versión que le instalé a mi amigo y que es la última que proporciona Zaapa:

romfs.img

linux.bin

Embeded Web UI 2.0.0.16.bin

Este marco ha sido hackeado y se le puede instalar un linux, con las ventajas que ello representa. El objetivo de este primer artículo es mostrar el proceso de instalación de linux y cómo acceder a este de una forma sencilla.

Lo primero es hacer un duplicado de disco del siguiente fichero: minifs-full-ext.img. Esto en linux, siendo root, se consigue con el siguiente comando (disco SD es el nombre que le haya asignado el sistema):

dd if=minifs-full-ext.img of=/dev/<disco SD>

Lo siguiente es actualizar el firmware del marco. Para ello hay que encender el marco sin ninguna tarjeta SD insertada y enchufar el cable usb. Cuando podamos acceder al contenido del disco, crear una carpeta llamada update y dentro de esta copiar el fichero parrotDF3120.plf. Después sacar el usb de forma segura y veremos que aparecen 4 cuadros en la pantalla (uno azul y el resto verde), momento en el cual ya se ha actualizado el firmware.

Ahora tenemos un modo de arranque dual. Por un lado si encendemos el marco sin más veremos su funcionalidad de siempre, es decir, se visualizarán las imágenes que tengamos almacenadas una detrás de otra. Pero si metemos la tarjeta SD y antes de encenderlo pulsamos los botones izquierdo y central de la parte de atrás y, sin soltarlos, encendemos el marco, se arrancará  linux y busybox.

Finalmente para acceder a la consola en el modo linux podemos hacerlo de dos formas (la dificil y la fácil):

La dificil es sacar todos los tornillos para quedarnos con la placa y la pantalla. A continuación soldamos en los agujeros del J4 (la consola serie) los tres pines (1: GND, 2: RX, 3: TX) y nos buscamos un conversor TTL a puerto serie o a usb para poder comunicarnos con el dispositivo usando los siguientes parámetros de conexión: 115200 8,N,1 (recomiendo screen en linux o mac y putty en windows). Esta es la consola serie donde se ven los mensajes de estado del arranque y luego se obtiene una shell donde interactuar con linux:

La fácil es simplemente conectar el cable usb al marco y a nuestro ordenador, lo que nos configurará una conexión ethernet por usb llamada Ethernet Gadget, la cual será una tarjeta de red que debemos configurar con la IP 172.16.61.2 y la máscara de red 255.255.255.0. Si todo ha ido bien y hacemos un ping a la dirección 172.16.61.1 el marco nos debería responder. Finalmente para acceder a una shell sólo hay que hacer un telnet a la IP comentada.

Edición 22/01/2011:
En el marco vienen unos programas para probar la pantalla gráfica. Podeis ejecutar cualquiera de ellos:
/usr/bin/plasma: Una bonita demo sobre el efecto plasma.
/usr/bin/newvox: Un paisaje que si tuvieramos teclado podríamos recorrerlo.

He publicado un segundo artículo que explica cómo crear programas que se ejecuten en el marco.

Toda la documentación de mi charla (presentación, código fuente, esquemáticos, etc.) lo podeis descargar aquí.

Agradecer a los organizadores su tiempo, esfuerzo y ganas por sacar adelante algo tan novedoso y pionero. También dignos de mención son los ponentes que de forma altruista hemos hecho realidad este fantástico evento. Por supuesto no nos olvidemos de los patrocinadores que han permitido que este evento tuviese un nivel alto y de calidad.

A todos, nos vemos en la OSHWCON 2012.

Los días 23,24 y 25 de Septiembre se va a celebrar en Madrid el OSHWCon. Un evento organizado por el colectivo Synusia donde se promociona el hardware libre, la afición a la electrónica, el DIY, etc.

La entrada es gratuita, pero hay que inscribirse. Habrá charlas, talleres, mesas redondas y proyectos personales. En mi caso he creido interesante dar una charla sobre telemetría.

Si os gusta la electrónica y la robótica no os podeis perder este evento único que hará las delicias de todos los aficionados a la electrónica, robótica y cacharreo en general.

http://www.sistemasorp.es/blog/temporizadores_pic.html

De esa necesidad surge este proyecto y para llevarlo a cabo he usado una bomba de agua, un bidón, un detector de nivel y una placa basada en un pic 16f628 con un relé.

La bomba de agua puede ser la que se usa para renovar el agua de una pecera o para mantener el chorro de una pequeña fuente. Sólo hay que conectarla a la alimentación de la casa para que empiece a bombear agua. Es muy importante que cuando esté enchufada tenga siempre agua, porque si no el motor se puede llegar a quemar. Por otro lado la altura de la manguera que va desde la bomba hasta el tiesto no puede ser mayor de un metro, ya que estos motores van perdiendo fuerza de bombeo a medida que crece la altura por donde tienen que enviar el agua.

El bidón que he usado en el proyecto es uno de los de agua mineral de 5 litros de cualquier marca. Al ser de plástico es fácilmente manejable para poder hacer un agujero y meter el detector de nivel.

El detector de nivel es necesario para evitar que la bomba siga extrayendo agua y se queme el motor por no tener agua que bombear. Yo he usado el de sure electronics.

La placa gobernada por un pic 16f628a es la que activará o desactivará la bomba de agua mediante un relé. Puede ser configurado mediante jumpers tanto el tiempo de riego como el intervalo. También se puede activar el riego manualmente mediante un botón.

Los componentes de la placa que he usado son:

• Microcontrolador PIC 16F628A
• 2 diodos led
• 2 resistencias de 220 ohm.
• 1 resistencia de 68K ohm.
• 1 transistor BC237
• 1 diodo 1N4148
• Un relé de 12 voltios RA12W-K
• Un botón
• Un regulador 7805
• Un condensador de 1000 uf
• Un condensador de 100 uf
• 2 bornes de 2 tomas y uno de 3 tomas.
• Pines y jumpers
• Fuente de alimentación de 12 V. y 0,5A.

Es importante que las pistas (o los cables de una placa de topos) que van a los contactos del relé sean más anchos para soportar la intensidad de la corriente.

Para no tener que pelar el cable de la bomba de agua, he usado un alargador que será al que se enchufe la bomba, pero que está cortado por uno de sus cables para poder engancharlo al relé:

El código fuente del PIC:

main.h

#include <16F628A.h>
 
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC_IO                 //Internal RC Osc, no CLKOUT
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
 
#use delay(clock=4000000)
#use fast_io(A)
#use fast_io(B)
 
#define CUANTAS 15

main.c

#include "main.h"
 
int inicio = -1;
int32 segundos = 0;
int interrupciones = CUANTAS;
int32 repeticiones[] = {7 * 24 * 3600, 6 * 24 * 3600, 5 * 24 * 3600, 4 * 24 * 3600, 3 * 24 * 3600, 2 * 24 * 3600, 24 * 3600, 12 * 3600};
int16 duraciones[] = {16000, 14000, 12000, 10000, 8000, 6000, 4000, 2000};
 
// Cuenta los segundos que van pasando para la activación automática del
// riego
#INT_RTCC
void cronometro()
{
    if(--interrupciones == 0) 
    {
      ++segundos;
      interrupciones=CUANTAS;
    }
}
 
// La interrupción es lanzada cuando el nivel del agua detectado por
// el sensor está por debajo de este y activamos el led de alarma
#INT_RB
void nivel()
{
   delay_ms(20);
   if(input(PIN_B4) == 1)
   {
      output_high(PIN_A0);
      output_low(PIN_A3);
   }
   else
   {
      output_low(PIN_A0);
   }
}
 
// La interrupción es lanzada cuando se pulsa el botón
#INT_EXT
void empiece()
{
   delay_ms(20);
   if(inicio == 0)
   {
      inicio = 1;
   }
}
 
void main()
{
   int contador;
 
   set_timer0(0);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   port_b_pullups(TRUE);
   set_tris_a(0);
   output_low(PIN_A0);
   output_low(PIN_A1);
   output_low(PIN_A3);
   enable_interrupts(INT_RTCC);
   enable_interrupts(INT_RB);
   enable_interrupts(INT_EXT);
   enable_interrupts(GLOBAL);
   delay_ms(1000);
   inicio = 0;
 
   for(;;)
   {
      if(inicio == 1)
      {
         // No dejamos que se pulse de nuevo el botón mientras dure el proceso
         disable_interrupts(INT_EXT);
         // Parpadeamos durante 4 segundos el led de trabajo
         for(contador = 0; contador < 8; contador++)
         {
            if(contador % 2 == 0)
            {
               output_high(PIN_A1);
            }
            else
            {
               output_low(PIN_A1);
            }
            delay_ms(1000);
         }
 
         // Si el nivel del agua está por encima del sensor activamos la bomba
         if(input(PIN_B4) == 0)
         {
            output_high(PIN_A1);
            output_high(PIN_A3);
            delay_ms(duraciones[input_b() >> 5]);
         }
         output_low(PIN_A1);
         output_low(PIN_A3);
         enable_interrupts(INT_EXT);
         delay_ms(1000);
         interrupciones = CUANTAS;
         segundos = 0;
         inicio = 0;
 
      }
      // Si el contador de segundos ha llegado a 0 es que hay que empezar 
      // el proceso de riego
      else if(segundos >= repeticiones[(input_b() & 0x0F) >> 1])
      {
         inicio = 1;
      }
   }
}

En el array repeticiones se ponen los milisegundos que dura el intervalo entre riegos, para poder seleccionarlo luego con los jumpers. En el array duraciones se ponen los milisegundos que dura el riego, para poder seleccionarlo luego con los jumpers.

Nada más arrancar el sistema empieza a contar los segundos que quedan para el siguiente riego, según esté configurado en los jumpers. Cuando llega ese momento o se pulsa el botón, el led de trabajo parpadea 4 segundos, permaneciendo encendido al igual que el relé para que funcione la bomba de agua mientras dure el tiempo de riego, según este configurado en los jumpers. Después el led se apaga, se desactiva el relé (y por consiguiente la bomba) y se espera de nuevo al evento de activación (por tiempo o hasta que se pulse de nuevo el botón).

Si el nivel del agua cae por debajo del sensor mientras se está regando se para automáticamente el riego desactivando el relé y encendiendo el led de alarma, que no se apagará hasta que el nivel esté otra vez por encima del sensor. Las siguientes veces que salte el evento por tiempo o por el botón, no activará el relé, protegiendo así a la bomba de estropearse.

Finalmente un video de cómo funciona el conjunto:

En principio he desmontado la carcasa de la videocámara y he extraido la electrónica y la batería:

He desoldado la batería y en su lugar he puesto dos cables para unirlos a una protoboard (aunque podrían soldarse a una placa de topos o a una pcb). Después he soldado dos cables de wrapping a los terminales traseros del botón de encendido y otro cable de wrapping al terminal trasero izquierdo del botón de grabación:

A partir de aquí ya se puede usar la cámara con un microcontrolador. Para este artículo me he decantado por un pic 12f683. La idea es usar dos transistores NPN para que hagan la simulación de pulsar tanto el botón de encendido como el de la grabación, para este artículo he usado 2 BC547. El microcontrolador activará la base del transistor a través de una resistencia de 390K. y comunicará el colector con el emisor como si de una pulsación manual del botón se tratase. Sólo hay que tener en cuenta que para el botón de encendido, el cable de wrapping de la derecha tiene que ir al colector y el cable de la izquierda al emisor, y en el botón de grabación el único cable va al colector y el emisor va a masa (GND).

La batería que trae la videocámara es una LiPo de una sola celda y tiene una capacidad de 230 mAh. Esto nos da la pista de que a la cámara debemos alimentarla con una tensión de 3,7 v. Para ello he usado un regulador Step-Down basado en el chip AX3022 de sure electronics. Este regulador ofrece hasta 1,5 A., más que suficiente para alimentar la videocámara y el microcontrolador (que puede funcionar a 3,7 v.).

Finalmente así queda el conjunto en una protoboard:

El ejemplo que he programado en el microcontrolador es muy sencillo: Espera 5 segundos, activa el transistor del botón de encendido durante medio segundo, esto hace que la videocámara se encienda, espera otros 5 segundos, activa el transistor del botón de grabación durante medio segundo, esto hace que la videocámara empiece a grabar, espera 10 segundos, activa el transistor del botón de grabación durante medio segundo, esto hace que la grabación pare, espera 5 segundos y finalmente activa el transistor del botón de encendido durante medio segundo, que provoca que la videocámara se apague:

El código fuente del programa del pic:

#include "main.h"
 
void power()
{
   output_high(PIN_A0);
   delay_ms(500);
   output_low(PIN_A0);
}
 
void record()
{
   output_high(PIN_A1);
   delay_ms(500);
   output_low(PIN_A1);
}
 
void main()
{
 
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_OFF);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC);
   setup_vref(FALSE);
   setup_oscillator(OSC_8MHZ);
 
   // TODO: USER CODE!!
   set_tris_a(0);
   output_a(0);
   delay_ms(5000);
   power();
   delay_ms(5000);
   record();
   delay_ms(10000);
   record();
   delay_ms(5000);
   power();
 
   for(;;);
}

Cuando vayamos a conectar la videocámara a un puerto USB para ver las grabaciones, no debemos olvidarnos de desenchufar los cables de alimentación que hemos soldado, ya que la fuente de alimentación ya no es la batería original que contenía.

Se trata de una placa open hardware que sirve para medir y/o interactuar de una forma simple con un montón de cosas. Se conecta por puerto usb a un ordenador y con una interfaz serie podemos enviar comandos al bus pirate. Esto es lo que puede hacer:

• Tomar medidas de 0 a 6 voltios.
• Medir frecuencias de 1 Hz a 40 MHz
• Generar PWM de 1 kHz a 4 MHz
• Interactuar con dispositivos UART, SPI, I2C, MIDI, teclado, LCD, JTAG, etc
• Analizador lógico de 10 Hz a 1 MHz
• Se pueden hacer scripts desde Perl, Python, etc.
• Se puede reprogramar para ser un programador de AVR o de PIC

Mi primera prueba ha sido medir la temperatura de un LM35:

Que indica que en la habitación tengo 32 grados (calorcito hace, si )

La verdad es que es muy cómodo y muy rápido para probar todos aquellos componenes que en otro caso tendríamos que desplegar un montón de componentes para obtener algún resultado.

La idea consiste en que un sensor de movimiento piroeléctrico de infrarrojos (PIR) detecte el movimiento de una persona en una sala, este informaría de la detección a un pic y este sería el encargado de llamar a un número de teléfono a través del modem.

El matería que he usado es:

• Sensor de movimiento piroeléctrico de infrarrojos (PIR) de sure electronics DC-SS502 ( http://www.sureelectronics.net/goods.php?id=932 )
• Microcontrolador PIC 16f628A ( http://www.microchip.com/wwwproducts/devices.aspx?ddocname=en010210 )
• Transceptor ds275 ( http://www.maxim-ic.com/datasheet/index.mvp/id/2929 )
• Una placa de topos, cable, un conector serie db9 macho y un modem externo

Para hacer el circuito lo más sencillo posible he usado un pic 16f628a dado que con él podemos ahorrarnos el poner un cristal de cuarzo externo, poder desactivar el pin MCLR y usar la USART que trae consigo (podría haber usado un pic 16f88 igualmente). También he usado el transceptor ds275 porque se puede comunicar con un puerto serie como el del modem sin añadirle ningún condensador como ocurre con el MAX232. Como no quería depender de una fuente de alimentación externa, he soldado unos cables al modem para obtener de este los 5 voltios necesarios para el pic y el transceptor y para la alimentación de 9 voltios del sensor PIR.

Este es el esquema del circuito:

El sensor PIR tiene una salida digital que va conectada al pin RB0 del pic, que se puede programar como interrupción, por lo que el pic puede permanecer en modo sleep hasta que recibe la interrupción del sensor y empezar a mandar los comandos AT para hacer la llamada de alarma. Como el PIC no puede por sí sólo interactuar con un puerto serie, el transceptor convierte las señales del PIC a señales RS232 para enviárselas al puerto serie del modem y viceversa. Una vez que se ha hecho la llamada y el modem detecta que se ha colgado la linea, devolverá un código numérico que el pic recibirá para volver a dejar el sistema en modo de detección.

Foto del conjunto:

Un video de demostración:

Lo que sucede en el video es lo siguiente: Se enciende el modem y el pic configura este para que no tenga eco los comandos, para que devuelva respuestas numéricas y que el altavoz esté desactivado, después de 15 segundos de espera para que el usuario pueda abandonar la habitación el pic se pone a esperar la detección de movimiento, cuando la detecta llama a un número de móvil prefijado para que el usuario reciba la alerta.

El código fuente del pic esta programado en CCS y es el siguiente:

main.h

#include <16F628A.h>
 
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC                    //Internal RC Osc
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
 
#use delay(clock=4000000)
#use fast_io(b)
#use rs232(baud=9600,parity=N,xmit=PIN_B2,rcv=PIN_B1,bits=8)
 
typedef enum {INICIO, DETECTA, ALARMA, LLAMADO} ESTADOS;

main.c

#include "main.h"
 
ESTADOS estado;
volatile int8 dato;
 
// se ha detectado un movimiento y se pasa al estado de alarma
#INT_EXT
void movimiento()
{
   if(estado == DETECTA)
   {
      estado = ALARMA;
   }
}
 
// se ha detectado un carácter en la cola la USART
#INT_RDA
void lectura()
{
   int8 valor;
   if(kbhit())
   {
      valor = getc();
      if(valor != '\r')
      {
         dato = valor;
      }
   }
}
 
// función genérica que pasa al estado de detección borrando cualquier interrupción anterior y activándola 
void deteccion()
{
   estado = DETECTA;
   clear_interrupt(int_ext);
   enable_interrupts(int_ext);
}
 
void main()
{
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   setup_oscillator(OSC_4MHZ);
   // Ponemos a todos los pines del puerto B como entrada excepto el de salida de la USART 
   set_tris_b(0xFB);
   // Empezamos por el estado de inicio
   estado = INICIO;
   // La interrupción debe ser cuando pasa de nivel bajo a nivel alto
   ext_int_edge( L_TO_H );
   enable_interrupts(int_rda);
   enable_interrupts(global);
 
   // TODO: USER CODE!!
 
   for(;;)
   {
      switch(estado)
      {
         // En el estado de inicio inicializamos el modem para que no haga eco de los comandos, 
         // los valores de respuesta sean numéricos y apague el altavoz del modem, esperando
         // 15 segundos para dejar salir al usuario de la sala y pasamos al estado de detección
         case INICIO:
            delay_ms(2000);
            printf("ATE0V0M0\r");
            delay_ms(13000);
            deteccion();
            break;
         // En el estado de detección esperamos la interrupción en modo sleep para consumir menos
         case DETECTA:
            sleep();
            break;
         // Se desactiva la interrupción y marcamos el número de teléfono que queramos alertar
         case ALARMA:
            disable_interrupts(int_ext);
            dato = 'A';
            printf("ATDTXXXXXXXXX\r");
            estado = LLAMADO;
            break;
         // Esperamos a que termine la llamada para que vuelva al estado de detección
         case LLAMADO:
            if(dato != 'A')
            {
               deteccion();
            }
      }
   }
 
}

Sólo comentar que XXXXXXXXX hay que sustituirlo por el número de teléfono al que queramos dar la alarma.

Primero extraemos la electronica y nos quedamos con los cables de los motores del coche teledirigido, después añadimos un conector tamiya con fusible para la batería LIPO:

Nos hacemos con una placa Arduino y un motorshield, en la cual se pueden acoplar en sus pines los cables de los motores:

En el mercado existen multitud de módulos bluetooth, yo he comprado el de sure electronics por su sencillez tanto de montaje como de comunicaciones (va a 9600 bps). Dos cables van a los pines RX y TX de la arduino y otros dos van a la salida de 3,3 voltios y GND de la arduino. Para comunicarse con él en windows basta con el putty accediendo al puerto COM que se haya asociado a vuestra conexión bluetooth;  si se trata de linux o mac podeis conectaros desde la consola con screen /dev/<dispositivo> 9600 siendo <dispositivo> el tty asociado a la conexión:

Montamos los bumpers. El cable suelto va a uno de los pines GND de la arduino, los otros dos cables van conectados a los pines EC1 y EC2 de la motorshield, que a su vez están conectados a los pines 4 y 5 de la arduino, por lo que se deberá activar la resistencia pull-up interna de esos pines:

Una batería LIPO para alimentar el conjunto, pegada con velcro para que se sujete bien a la vez que sea fácil quitarla para cargarla o sustituirla:

Aunque no es necesario, he puesto una cámara wireless alimentada con una pila de 9 voltios para grabar los movimientos. Al final el conjunto queda así:

Como el movimiento se demuestra andando, pongo un video de su funcionamiento (recomiendo agrandarlo para ver mejor los detalles). A la izquierda el putty mostrando los mensajes que envía la arduino a través de bluetooth, en el centro un video del cómo responde el robot y a la derecha otro video desde dentro del robot:

Finalmente dejo el código fuente del robot para el entorno Arduino:

int dirA = 12; // sentido
int dirB = 13;  // direccion 
int speedA = 10; // velocidad del motor
int speedB = 11; // parada o encendido de la dirección
int bumperI = 5; // bumper izquierdo
int bumperD = 4; // bumper derecho
int boton2 = 6; // boton 2 de la motorshield
int boton1 = 7; // boton 1 de la motorshield
 
// El robot va hacia atrás
void atras()
{
  digitalWrite (dirA, HIGH);
}
 
// El robot va hacia alante
void alante()
{
  digitalWrite (dirA, LOW);
}
 
// El robot tuerce a la izquierda
void izquierda()
{
  digitalWrite (dirB, LOW);
}
 
// El robot tuerce a la derecha
void derecha()
{
  digitalWrite (dirB, HIGH);
}
 
 
void setup() 
{
  // Configuración de los pines de la motorshield
  pinMode (dirA, OUTPUT); 
  pinMode (dirB, OUTPUT); 
  pinMode (speedA, OUTPUT); 
  pinMode (speedB, OUTPUT);
 
  // Configuración de los pines de los bumpers
  pinMode (bumperI, INPUT);
  pinMode (bumperD, INPUT);
 
  // Configuración de los botones de la motorshield
  pinMode (boton1, INPUT);
  pinMode (boton2, INPUT);
 
  // Configuración de las comunicaciones por bluetooth
  Serial.begin(9600);
}
 
 
void loop() 
{ 
  // Si se ha pulsado el boton de arranque
  if(digitalRead(boton1) == 0)
  {
    delay(200); // para evitar rebotes en el boton
    Serial.println("empiezo");  
    analogWrite(speedA, 100); // PWM a 100
  }
  // Si se ha pulsado el boton de parada
  else if(digitalRead(boton2) == 0)
  {
    delay(200); // para evitar rebotes en el boton
    Serial.println("termino");
    analogWrite(speedA, 0); // PWM a 0
  }  
  alante();
  // Si se ha detectado una colisión por el flanco derecho
  if(digitalRead(bumperD) == 0)
  {
    Serial.println("choque derecha");
    digitalWrite(speedB, HIGH); 
    // Va hacia atrás a la derecha durante 1 segundo    
    derecha();
    atras();
    delay(1000);
    // Va hacia alante a la izquierda durante medio segundo
    alante();
    izquierda();
    delay(500);
    digitalWrite(speedB, LOW); 
  }
  // Si se ha detectado una colisión por el flanco izquierdo
  else if(digitalRead(bumperI) == 0)
  {
    Serial.println("choque izquierda");
    digitalWrite(speedB, HIGH); 
    // Va hacia atrás a la izquierda durante 1 segundo
    izquierda();
    atras();
    delay(1000);
    // Va hacia alante a la derecha durante medio segundo    
    alante();
    derecha();
    delay(500);
    digitalWrite(speedB, LOW); 
  }
}