Subir a Inicio

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.



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 :-)

27 comentarios:

  1. Muy bueno, increíblemente barato y funcional! muchas gracias!

    ResponderEliminar
  2. Joder, vaya crack que estas hecho colega!

    ResponderEliminar
  3. Increible, me ha encantado, una vez mas felicidades. Por cierto lo del roll-on lo comente yo. Ja Ja

    ResponderEliminar
  4. Muy bueno Lo tratare con mis estudiantes.

    ResponderEliminar
  5. Increible! Lo acabo de bajar y ya tengo ganas de probar y modificar

    ResponderEliminar
  6. acabo de conocer tu pagina, esta todo genial!!
    lo del roll-on me ha encantado xD

    ResponderEliminar
  7. Perdona, me ha surgido un problema despues de trucar los servos (en realidad no se si me pasaba ya antes). Para un lado gira mas deprisa que para el otro y la casualidad que a la hora de ponerlos en las ruedas los sentidos de los dos son inversos, por lo que solo gira sobre su eje.

    ¿Se te ocurre que puede pasar?

    Gracias y enhorabuena por el blog, te das maña para las explicaciones ;-)

    ResponderEliminar
  8. Perdona que antes no he puesto nombre.

    Lo siento, no es problema mecanico, era cuestion de software. Estaba tomando como punto muerto el 0 en lugar del 90 y claro cuando daba velocidades de 60 y -60, pues uno corria mas que el otro.

    Lo dicho, muy bueno tu chapuzillas, espero que pongas mas.

    Enrique

    ResponderEliminar
  9. Realmente dominas todos los campos. No solo tienes las habilidades necesarias para desarrollar los proyectos electrónicos, también realizas diseños aplicables a la escala correcta y adaptas los materiales del día a día a tus necesidades. Se nota que eres un "Macgyver"

    Un saludo cordial y gracias en nombre de todos los que aprendemos con tus documentos.

    ResponderEliminar
  10. ¡Hola
    ¿Cuál es la mejor Arduino ¿Lo recomendaría?

    Mega2560 AVR o Arduino Duemilanove

    Gracias

    ResponderEliminar
  11. una pregunta a esa placa le podriamos agregar un servo y un sensor infra rojo para detectar en ves de por choque por distancia?

    ResponderEliminar
    Respuestas
    1. Hola Eder...!
      Como la placa es un arduino, le puedes añadir un servo y un sensor para detección tipo radar (tendrías que realizar el software o utilizar alguno existente por la red)

      SL2

      Eliminar
  12. Hola buenas estoy intentando realizar este proyecto pero me gustaria cambiar el sensor delantero por un sensor de proximidad ping, el resto sería igual. Si alguien me echaria una mano para modificar el codigo que me responda . Le estaría muy agradecido. Un saludo.

    ResponderEliminar
  13. En el codigo la variable luces que has asociado al pin 8 no la has utilizado no? según el video hay un led que luce cuando hay un pitido, no se si los has asociado y no lo has colocado en el void claxon().
    void Claxon(int Duracion){
    digitalWrite(CLAXON_PIN,HIGH);
    digitalWrite(led1, HIGH);
    delay(1000);
    digitalWrite(CLAXON_PIN,LOW);
    digitalWrite(led1, LOW);
    delay(1000);
    }
    Un saludo.

    ResponderEliminar
  14. Hol, soy nuevo en esto de las placas de arduino que modelo usas para el robot?

    ResponderEliminar
    Respuestas
    1. Hola Anónimo
      El modelo utilizado es un duemilanove, pero puedes utilizar cualquier placa Arduino.
      SL2

      Eliminar
  15. Impecable! Felicitaciones por semejante labor. Muchas gracias por tan buen aporte!

    ResponderEliminar
  16. Excelente trabajo, pero tengo una duda, dices que puede funcionar con cualquier placa Arduino, ¿tambien funcionara con tu version del PAPERduino (este: http://txapuzas.blogspot.com/2010/07/paperduino-pcb.html#) o con el clon del Arduino Leonardo (este: http://txapuzas.blogspot.com/2009/12/paperduino-leonardo-clon-de-arduino.html) esa es mi duda, funcionara con alguno de esos? o los dos?

    ResponderEliminar
  17. Que chulo. Es como el 'primo' de Minidron: http://forja.guadalinex.org/plugins/mediawiki/index.php?group_id=75

    ResponderEliminar
  18. es muy bueno solo que no muestra que modelo de microinterruptor es el que usa

    ResponderEliminar
  19. Buenos dias , tengo un problema , los servos me giran desfasados , algo con lo que me puedas ayudar???

    ResponderEliminar
  20. Hola , necesitaba ayuda con los servos , cuando el arduino envia angulos positivos los servos andan lentamente y cuando envia angulos negativos andan bien. Que puede ser??

    ResponderEliminar
  21. Hola, que material pusiste al rededor de las tapas para la rueda!!!

    ResponderEliminar
  22. Espectacular, yo también he echo uno inspirándome en este blog. Es buenísimo, me lo paso genial, pero una cosa, como haces las imágenes de los esquemas eléctricos?

    ResponderEliminar
  23. me encanta! enhorabuena! :)

    ResponderEliminar