PaperRobot: Robot simple con Arduino

Descripción

El objetivo de este proyecto es realizar un sencillo robot controlado por Arduino de una forma fácil y económica.
El chasis está realizado en cartón pluma, material rígido y de fácil manipulación. Las ruedas delanteras están hechas con dos tapas de botes de conservas, para la rueda trasera he utilizado el "RollOn" de un desodorante y los motores son dos microservos trucados para que puedan girar más de 180º. Si no dispones de una placa protoboard, con unos pocos pines hembra y un trozo de stripboard podemos hacer una regleta de expansión que nos multiplique el número de bornas de 5v y masa de Arduino, y así poder conectar todo tipo de sensores.

Chasis

Para realizar el chasis puedes imprimir el PaperDocumento (no es en absoluto necesario) y pegarlo sobre el material que quieras utilizar para la confección del chasis. Antes de recortarlo, le he pegado encima un poco de Aironfix, para mantener la superficie del robot un poco "limpia". (El paper documento está disponible en el apartado de descargas en la parte final de este página)

Una vez impreso el documento, comprobaremos que la impresión se ha realizado a la escala correcta con la ayuda de la regla impresa situada en el lateral izquierdo de la hoja. Al colocar a su lado un regla en centímetros deberán coincidir las marcas.

No tiene por que ser cartón-pluma, puedes utilizar cualquier otro tipo de material (madera, plástico... ), pero la gran ventaja del cartón pluma es que se corta con gran facilidad.

Dependiendo de la "rueda trasera" que utilices deberás cortar el chasis:

Ruedas delanteras

Al utilizar servomotores trucados, tienen un sistema de engranajes con una gran reducción, suministrando una velocidad máxima muy baja, por lo que es conveniente utilizar unas ruedas de diámetro amplio, y así aumentar la velocidad máxima.
Yo he utilizado dos tapas de botes de conservas, con una junta tórica que hace de banda de rodadura (no es estrictamente necesario, y vale perfectamente una goma elástica)

Para calcular el centro de la tapa, medimos el diámetro de la misma:

Hacemos una pila con unos libros o folios y colocamos sobre él un rotulador (conviene que no sea permanente, para poder borrarlo), de forma que la punta del rotulador esté a la mitad del radio de la base:

Marcamos una linea horizontal manteniendo la rueda vertical

La giramos 180 grados y volvemos a marcar una linea horizontal paralela a la anterior

Ahora giramos 90º la tapa y repetimos el proceso anterior:

Si vemos que nos han quedado las lineas muy separadas (tal y como aparece en la imagen), borramos las líneas, ajustamos la anchura de la pila añadiendo o quitando folios y lo realizamos de nuevo. El punto central del círculo estará entre las 4 lineas dibujadas.
Un ejemplo:

Una vez que tenemos localizado el centro, con un clavo lo marcamos:

Y ya podemos con el taladrín hacer un agujero con una broca de tamaño similar al tornillo que viene con el servo para fijar las palancas de accionamiento

Rueda trasera

Sustituyendo a una rueda, puedes utilizar un deslizador simplemente con un tornillo DIN603, (Tornillo cuadradillo con tuerca), ya que tiene la cabeza redondeada permitiendo un deslizamiento fácil. Con un par de tuercas puedes regular la altura del deslizador.

En vez de utilizar este sistema, he querido probar una idea que surgió en el blog de Arduino en español (no recuerdo su autor Gracias Javier!), y he utilizado la bola de un desodorante RollOn.

Todos los elementos están clipados a presión, primeramente soltamos la bola con su soporte del recipiente (nos podemos ayudar de un objeto afilado como un cutter o un cuchillo para hacer presión)

Después desmontamos el "RollOn" también con la ayuda de un cutter o un cuchillo

Cortamos con un cutter el muelle de plástico para que tenga menos rozamiento

Y por último lo volvemos a unir, pero para que la bola tenga más holgura y se mueva con mayor facilidad, no he clipado las dos partes del soporte, sino que las he unido con cinta aislante manteniendo una separación:

Y ya tenemos nuestra "rueda loca"

Parachoques

Todo robot que se precie necesita unos sensores que le indiquen que se ha chocado.
Estos sensores se pueden hacer colocando un par de microinterruptores en la parte delantera del robot:

Pero como estamos haciendo un paper robot, ¿Por qué no nos lo hacemos nosotros mismos?

La idea es mantener separadas dos superficies conductoras, de forma que cuando se produzca un impacto estas dos superficies entren en contacto y por lo tanto cierren el circuito.

Necesitaremos cinta conductora, debes tener en cuenta que no todas las cintas metálicas que venden son conductoras, algunas están recubiertas por una capa plástica aislante (tal vez se podría quitar con disolvente tipo acetona, pero no lo he intentado). Si no encuentras, podrías pegar directamente papel de aluminio que se utiliza en cocina sobre el chasis o un cartón.

Primeramente cortamos una tira de unos 15mm de anchura

 

Y la pegamos centrada sobre la zona curvada del chasis

 Con unas tijeras hacemos cortes a intervalos regulares para permitir que la cinta se acople a la superficie curva:

Y vamos plegando cada una de las lengüetas generadas y pegándolas sobre el ecatón pluma:

Comprueba que la cinta no llegue a los extremos laterales del chasis para que no generen falsos contactos cuando incorporemos la otra parte del parachoques.

Con una broca o un taladro haces un agujero cerca de la cinta pegada.

Por ese agujero pasamos un cable y lo empalmamos, hacemos la unión más o menos estable con un macarrón termorretráctil (previamente puedes hacer un ligero canal en la zona de la cinta para que el espesor del cable no genere falsos contactos).

 Ahora tendremos que hacer los guardabarros, en el documento los tienes dibujados al tamaño preciso. Si quieres los puedes proteger y rigidizar un poco pegando encima de ellos plástico adhesivo transparente (aironfix)

 

Necesitaremos, un trozo de cartulina (yo he utilizado un plástico utilizado como portada de encuadernación de fotocopias), una tira de unos 25mm de ancho de cinta adhesiva conductora, y los guardabarros impresos 

Primeramente pegamos el dibujo del guardabarro sobre la cartulina, 

y en la parte inferior pegamos la cinta adhesiva conductora.

Y ahora cortamos con un cutter siguiendo el dibujo

Y obtenemos nuestros guardabarros, por un lado del Athletic y por el otro metálicos ;-)

 

cerca de un extremo hacemos dos muescas y fijamos un cable (podemos hacer la unión permanente utilizanto tubo termorretráctil)

Y colocamos las bandas en las ranuras de nuestro chasis

Motores (microservos 9gr)

Como sistema motriz, he utilizado dos microservos, en ebay los tienes bastante económicos:

Estos servos hay que trucarlos, para que permitan un giro completo (de fábrica sólo permite 180º). En este tipo de servos este proceso tiene tres partes (inspirado en http://letsmakerobots.com/node/9420):

Eliminación del tope mecánico de la carcasa

Para abrir la carcasa soltamos los cuatro tornillos de la parte trasera, y podemos ver que la última rueda dentada tiene un saliente que hace tope con otro saliente de la carcasa.  Lo más sencillo es eliminar el tope de la carcasa con un cutter.

Fijación del eje en el punto medio

En este servo el eje del potenciómetro es también el eje de la última rueda dentada, así que será necesario desmontarlas (ponlas en una superficie en orden, para saber luego como montarlas).
Una posibilidad es eliminar el potenciómetro, y sustituirlo por dos resistencias de valor idéntico de unos 4K, pero creo que es más sencillo, bloquear el potenciómetro en la posición central.
Teniendo el servo conectado a un Arduino y corriendo en él un programa que provoque que el servo está a 90º, deberemos ir moviendo el eje del potenciómetro hasta conseguir que el motor deje de moverse, en ese momento lo que haremos será fijar la posición del potenciómetro en ese punto. Una forma de fijarlo es con adhesivo, no te recomiendo que utilices cianocrilato (Loctite), ya que es muy fluido y se puede extender a la zona de contacto del potenciómetro con la pista, yo he utilizado un adhesivo epoxi rápido de doble componente (Araldit), aplicado en la zona de inicio y fin de la pista del potenciómetro tal y como se indica en la figura siguiente:

Para definir el punto central del potenciómetro del servo, puedes descargar el siguiente sketch PararServo.pde,  una vez cargado en el Arduino, y conectado el cable de señal al pin 9, el de alimentación a 5v y el de masa a GND, debes girar el eje del potenciómetro hasta que el motor se pare, en ese estado puedes fijar el potenciómetro con adhesivo tal y como se ha indicado.

Permitir el giro libre de la última rueda dentada
Una vez que tenemos fijado el eje del potenciómetro, deberemos hacer algo para que el último engrane pueda girar sobre su eje (el eje del potenciómetro), que en su extremo tiene unas entallas para que encaje:

Creo que lo más fácil es con una broca o un destornillador fino, eliminar las entallas agrandando un poco el agujero de la rueda dentada.

 

Y ya podemos colocar las ruedas dentadas, (conviene comprobar que con las manipulaciones no se haya soltado ningún cable) y cerrar el servo con los cuatro tornillos.

Para poder conectarlo, he sustituido el conector hembra de tres vías, por tres pines macho individuales.

Protoboard 

Para poder conectar los diferentes sensores a Arduino, es necesario aumentar el número de pines del Arduino, podemos hacerlo simplemente incorporando una protoboard al chasis:

o también puedes realizar una microprotoboard con un trozo de stripboard y unos pines hembra:

Con un trozo de stripboard de 4 pistas por 15 agujeros podemos conseguir 8 pines de 5v, 8 pines de masa y dos grupos de 3 pines cada uno (no te olvides de cortar las pistas 2 y 3 entre los agujeros 10 y 11):

Alimentación

Como no es muy conveniente alimentar los servos directamente del Arduino, ya que calentamos innecesariamente el regulador de la placa (además una pila de 9v no tiene mucha potencia) . Utilizaremos dos baterías, una para alimentar Arduino y sensores con 9v, y otra de 6v para alimentar los servos realizada con 4 pilas de 1,5v sobre un soporte pegado con cola termofusible a la parte inferior del chasis.
Las pilas de 1,5v conviene colocarlas entre las tres ruedas, para garantizar la máxima estabilidad del robot.
 

Los positivos de los motores están conectados a la batería mediante un conector casero, realizado con dos pines de conexionado hembras.

También he añadido un interruptor en serie con la pila de 9v para apagar el Arduino (perdona por la calidad de la imagen, pero como lo he pegado sobre una pila negra no se ve nada)

Montaje completo

En el documento de descargas (al final de esta página), tienes el segundo PaperDocumentos con los esquemas e instrucciones de montaje:

Para saber como debemos conectar todos los componentes nos fijaremos en el siguiente esquema:

Utilizaremos el regulador de tensión de la placa Arduino para obtener 5v para los sensores que utilicemos a partir de una pila de 9v.

Conectaremos un cable del parachoques a masa y el otro a las entradas D11 (delantero) y D12 (trasero). Deberemos activar por software las resistencias internas pull-up del Arduino, de forma que el Arduino detectará 0v cuando se choque y 5v en caso contrario.

Para activar las resistencias Pull-Up de las patillas D11 y D12 deberemos utilizar un código similar al siguiente:

...

pinMode(pinD11, INPUT);           // pone el pinD11 como entrada
digitalWrite(pinD12, HIGH);       // activa su resistencia pullup

pinMode(pinD12, INPUT);           // pone el pinD12 como entrada
digitalWrite(pinD12, HIGH);       // activa su resistencia pullup

... 

El negativo de las pilas de los motores lo conectamos a masa y el positivo a través de un interruptor al positivo de los servos (no lo he representado en el dibujo de montaje inferior). El negativo de los servos a masa y el cable de control a las patillas D2 y D3 del Arduino.

Si quieres, puedes poner un zumbador entre la patilla 13 y masa, de forma que el robot pite cuando se choca (si está programado en el sketch).

NOTA: Algunos servos identifican los cables de forma diferente:

Positivo: Rojo.

Negativo: Marrón, Negro.

Señal: Naranja, Blanco.

NOTA: en el dibujo superior el conmutador de la pila de 9v está mal colocado, ha de estar conectado la pata central y una pata lateral!!

 
Y aquí podéis ver el resultado (menudo lío de cables!!):

Programa

El archivo PaperRobot.pde lo tienes en el archivo de descargas disponible en el enlace al final de esta página.  (Es mejor que lo copies de ahí, ya que a veces blogger confunde comandos de Arduino con comandos de HTML, sobre todo con #include ) 

/*
 * PaperRobot: Programa de control de un rebot realizado con dos servos controlados por Arduino
 * Version 31.10.2011
 * Copyright 2011 Iñigo Zuluaga
 * http:www.txapuzas.blogspot.com
 */

#include (Esta linea está mal, falta la librería a incluir: servo)

int LUCES_PIN=8;                // Pin al que estan conectadas las luces
int SERVOIZDA_PIN=9;            // Pin al que esta conectado el motor izdo
int SERVODCHA_PIN=10;           // Pin al que esta conectado el motor dcho
int TOPEDEL_PIN=11;             // Pin al que esta conectado el parachoques delantero
int TOPETRAS_PIN=12;            // Pin al que esta conectado el parachoques trasero
int CLAXON_PIN=13;              // Pin al que está conectado un buzzer (con vibrador)
//int Marcha=0;                 // Marcha (velocidad): 1,2,3
boolean TopeDelantero=HIGH;     // Definimos el estado del tope delantero
boolean TopeTrasero=HIGH;       // Definimos el estado del tope trasero
Servo MotorIzda;                // creamos los objetos servo para poder controlarlos 
Servo MotorDcha;

void setup(){
  pinMode(TOPEDEL_PIN, INPUT);           // pone el pin como entrada
  digitalWrite(TOPEDEL_PIN, HIGH);       // activa la resistencia pullup
  pinMode(TOPETRAS_PIN, INPUT);          // pone el pin como entrada
  digitalWrite(TOPETRAS_PIN, HIGH);      // activa la resistencia pullup
  int Marcha=1;                          // ponemos la primera
  MotorIzda.attach(SERVOIZDA_PIN);       // conectamos el servo izquierda
  MotorDcha.attach(SERVODCHA_PIN);       // conectamos el servo derecha
  Serial.begin(9600);                    // definimos la velocidad de la conexion serie
 
  Paro();                                // paramos el robot
  Claxon(50);                            // Y que pite dos veces para indicar que esta listo
  Claxon(50);

}

void loop() {                           
  int Marcha=3;                           // Pone la tercera
  TopeDelantero=digitalRead(TOPEDEL_PIN); // Comprueba si se ha chocado por delante
  TopeTrasero=digitalRead(TOPETRAS_PIN);  // Comprueba si se ha chocado por detras
 
  if (TopeDelantero==LOW){               // si se ha chocado por delante
    if (TopeTrasero==LOW){               // y por detras !!!!
      Serial.println("AMBOS TOPES");     // manda por el puerto serie el caso (solo con cable usb)
      Serial.println("---------------");
      Paro();                            // Para los motores
      Claxon(200);                       // y da unos cuantos pitidos largos para indicar la situacion
      Claxon(200);
      Claxon(200);
      Claxon(200);
    }
    else{                                // Si el choque solo es delantero
    Serial.println("TOPE DELANTERO");    // Manda por el puerto serie la situacion
    Serial.println("---------------");
    Atras(Marcha);                       // Inicia maniobra desbloqueo: Atras
    Claxon(100);                         // pita
    delay(500);                          // durante medio segundo        
    Izda(Marcha);                        // Gira a la izquierda
    Claxon(100);                         // pita
    delay(500);                          // gira durante medio segundo
    Adelante(Marcha);                    // adelante en tercera
    Claxon(50);                          // dos pitidos cortos (50 ms)
    Claxon(50);
    }   
  }
 
  if (TopeTrasero==LOW){                 // Si el choque es trasero
    Serial.println("TOPE TRASERO");      // Manda por el puerto serie el estado
    Serial.println("---------------");
    Adelante(Marcha);                    // y automaticamente va hacia adelante
    Claxon(50);                          // dos pitidos cortos (50 ms)
    Claxon(50);
  }
}

void Adelante(int Marcha){
  // Se encarga de mover los dos motores hacia Adelante
  // ENTRADAS=> Marcha (velocidad): 1,2,3
  int SMotorIzda=1;                    // Motor Izquierdo hacia adelante
  int SMotorDcha=1;                    // Motor Derecho hacia adelante      
  Serial.println("ADELANTE");         // Manda por el puerto serie el estado
  Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Izda(int Marcha){
  // Se encarga de girar el robot hacia la Izquierda
  // ENTRADAS=> Marcha (velocidad): 1,2,3
  int SMotorIzda=-1;                   // Motor Izquierdo hacia Atras      
  int SMotorDcha=1;                    // Motor Derecho hacia Adelante             
  Serial.println("IZQUIERDA");        // Manda por el puerto serie el estado
  Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Dcha(int Marcha){
  // Se encarga de girar el robot hacia la Derecha
  // ENTRADAS=> Marcha (velocidad): 1,2,3
  int SMotorIzda=1;                    // Motor Izquierdo hacia Adelante
  int SMotorDcha=-1;                   // Motor Derecho hacia Atras
  Serial.println("DERECHA");          // Manda por el puerto serie el estado
  Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Atras(int Marcha){
  // Se encarga de mover el motor hacia Atras
  // ENTRADAS=> Marcha (velocidad): 1,2,3
  int SMotorIzda=-1;                   // Motor Izquierdo hacia Atras
  int SMotorDcha=-1;                   // Motor Derecho hacia Atras
  Serial.println("ATRAS");            // Manda por el puerto serie el estado
  Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Paro(){
  // Para los motores
  int SMotorIzda=0;                    // Motor Izquierdo Paro
  int SMotorDcha=0;                    // Motor Derecho Paro
  int Marcha=0;                       // Marcha Ninguna
  Serial.println("PARO");             // Manda por el puerto serie el estado
  Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Mover(int Marcha,int SMotorIzda, int SMotorDcha){
  /* Manda Mover los motores
  ENTRADAS=> Marcha(velocidad): 1,2,3
             SMotorIzda: Sentido de marcha del motor Izquierdo (1=horario, -1=Antihorario)
             SMotorDcha: Sentido de marcha del motor Izquierdo (1=horario, -1=Antihorario)
  */ 
  int VelMotorIzda = 0;                // Velocidad del motor izquierdo
  int VelMotorDcha = 0;                // Velocidad del motor derecho
  VelMotorIzda=90-SMotorIzda*30*Marcha; //M0(90);M1(1:120,-1:60);M2(1:150,-1:30);M3(1:180,-1:0)
  VelMotorDcha=90+SMotorDcha*30*Marcha; //M0(90);M1(1:60,-1:120);M2(1:30,-1:150);M3(1:0,-1:180)
  MotorIzda.write(VelMotorIzda);       // Transmite la velocidad al pin
  MotorDcha.write(VelMotorDcha);       // Transmite la velocidad al pin
  Serial.print("MotorIzda:");
  Serial.println(VelMotorIzda);
  Serial.print("MotorDcha:");
  Serial.println(VelMotorDcha);
  Serial.println("---------------");
}

void Claxon(int Duracion){
  // Realiza un pitido
  // ENTRADAS=> Duracion del pitido en milisegundos
 
  digitalWrite(CLAXON_PIN,HIGH);      // Activa el pin del Buzzer
  delay(Duracion);                    // Espera
  digitalWrite(CLAXON_PIN,LOW);       // Apaga el buzzer
  delay(Duracion);                    // Espera (por si hay que hacer varios pitidos)
}
 

Cuando iniciamos el programa, el robot permanecerá parado hasta que activemos algún parachoques.
Si el parachoques delantero detecta un impacto, efectuará una maniobra de evasión, un poco hacia atras, giro y hacia adelante de nuevo.
Si el parachoques trasero detecta un impacto simplemente cambiará de sentido de la marcha.
A continuación podemos ver el programa anterior en funcionamiento:




Información legal

0. Fallos y txapuzas no controladas.
Los circuitos publicados se han comprobado y funcionan correctamente. No obstante en el caso de que en una página se publiquen varios montajes diferentes de un mismo circuito (sobre un stripboard, PCB, ...), pueden existir fallos que no se han detectado en alguno de los montajes, ya que normalmente sólo realizo un montaje. En ese caso por favor notificad el fallo para que pueda corregirlo. muchas gracias.

1. Propiedad intelectual
Todos los derechos de propiedad intelectual del contenido de Txapuzas eléctronicas, están bajo una licencia Creative Commons Share-Alike, cuyo contenido podéis revisar en este enlace.
Por tanto queda permitido copiar, distribuir, comunicar públicamente la obra y hacer obras derivadas de la misma, siempre que se respeten los términos de la licencia arriba reseñada.
3. Actualizaciones y modificaciones de Txapuzas electrónicas
El autor se reserva el derecho a actualizar, modificar o eliminar la información contenida en Txapuzas eléctrónicas, y la configuración o presentación del mismo, en cualquier momento, sin previo aviso, y sin asumir responsabilidad alguna por ello.
4. Indicaciones sobre aspectos técnicos
El autor no asume ninguna responsabilidad que se pueda derivar de problemas técnicos o fallos en los equipos informáticos, que se produzcan a causa de los circuitos e ideas expuestos en el blog de txapuzas electrónicas, así como de los daños que pudieran ocasionar.
El autor se exime de toda responsabilidad ante posibles daños o perjuicios que pueda sufrir el usuario a consecuencia de errores, defectos u omisiones en la información facilitada.

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

Si tienes problemas con el enlace anterior, aquí puedes descargar todos los archivos de txapuzas

Notas
Para la realización de este proyecto se han utilizado los programas: Arduino, Inkscape, Openoffice, Gimp, Picasa, Fritzing
Si encuentras algún fallo, se te ocurre alguna mejora, o simplemente quieres hacer algún comentario, te lo agradeceré: Gracias.  :-)