pesadillo.com » Arduino

Cotrol IR Robosapien. Hackeando un Robosapiens Version 1

pesadillo — Thu, 09 May 2019 22:36:04 +0000

Después de haberme pillado mi primer juguete robot para estudiarlo, un Robosapiens de segunda mano por wallapop. Este me llegó con un defecto inesperado. el mando no funcionaba!.

La idea inicial era pasárselo a peque de la casa y estudiarlo para preparar un clon o similar. Al final, se ha convertido en un reto para “devolverle vida”.

Tras visitar cientos de webs sobre el robot robosapiens, en donde apenas había contenido, y los artículos estaban a medio terminar en su explicación de como hackear Robosapiens. He recopilado información suficiente para lograr el primer objetivo: Controlar el robot sin entrar a tocar la electrónica.

Esto pasa por entender el funcionamiento del mando IR e intentar reproducir su funcionamiento.

Hay un truco brillante para controlar estos modelos (V1) http://playground.arduino.cc/Main/RoboSapienIR pero también significa que tienes que arruinar tu soldador haciendo un agujero en el cuerpo del robot para colgarle una mochila.

Como referencia ha de tomarse el trabajo de Ken Shirriff http://www.righto.com/2009/08/multi-protocol-infrared-remote-library.html pero este está pensado para la transmisión de códigos IR para televisores no para los robots, aún que las ultimas librerías ya incluyen el nombre “RobotIrRemote”.

Modificando los ficheros de las librerías de la versión 1.0.0 del IRRemote en cuestión, en la página https://cae2100.wordpress.com/2014/01/15/robosapienwowwee-ir-arduino-library/ consiguieron crear un comando específico (irsend.sendRSV1) para el control del robot a través del Arduino (Version 1, 2 y resto de robots sapiens).

Este comando aparece en algunas páginas, pero el código suministrado siempre estaba incompleto, no funcionaba o simplemente no explicaban que debía convertirse el código hexadecimal a decimal, antes de transmitirlo.

En su primera versión (modificación) solo podían manejar el envío de códigos de 8 bits (un byte) (irsend.sendRSV1), pero los productos V2 y otros wowwee usan códigos de 12 bits, por lo que desarrollaron el comando para manejo de las siguientes versiones (irsend.sendRSV2). Los códigos nuevos robots wowwee IR (infrarrojos) utilizan el mismo tipo de datos que se enviaban antes, los mismos códigos de 8 bits, pero utilizan un código identificador de 4 bits que hace que ese control remoto específico solo funcione en ese robot.

Aquí hay una lista de todos los comandos para un grupo de robots wowwee:

Códigos de Robosapien V1:

http://www.aibohack.com/robosap/ir_codes.htm

Robosapien V2 y otros robots wowwee:

http://www.aibohack.com/robosap/ir_codes_v2.htm

En la página V2, el 3xx es el 0011, también conocido como el código de identificación del robot. Para cambiar a otro robot, simplemente cambia el 3 a cualquier robot que esté tratando de controlar.

Para reproducir el proyecto, puedes descargar ya la librería modificada aquí:

https://drive.google.com/file/d/0BwYG1PFb3ZByaTAxMlJZS2pIM1E/edit?usp=sharing

Enlace recogido de la página https://cae2100.wordpress.com/2014/01/15/robosapienwowwee-ir-arduino-library/

También tienes una copia en el repositorio: https://github.com/pesadillo/robosapiensv1/

Una vez instalada en las librerías, es momento del código (Probado en Arduino 1.8 con Arduino UNO):

/*
 * CONTROL REMOTO DESDE PC PARA ROBOSAPIENS V1
 * Version  del codigo 1.0
 *
 * Based on IRSend demo from ken Shirriffs library - this sends simple commands to a RoboSapien V1 using and IR Transmitter with Arduino
 * Based on https://daverobertson63.wordpress.com/2013/05/05/updated-robosapien-ir-control-arduino/
 *
 * La historia:
 * Despues de haber conseguido por wallapop un Robosapiens v 1.0, me encontre que su mando estaba estropeado. Trasteando por Internet, me he encontrado
 * cientos de ejemplos con códigos a medias, o sin explicar completamente. Me decidí a entrar de lleno en la programación y control de este robot
 * tan facil a asequible de conseguir ahora y facilitar el acceso a la documentación a todos los seguidores de la web www.pesadillo.com
 *
 *
 * De interés:
 * La libreria a utilizar es IRRemote V 1.0.0 (modificada) que he incluido desde el apartado Programa/Incluir Libreria/Añadir libreria ZIP
 * Esta libreria puedes descargarla desde https://drive.google.com/file/d/0BwYG1PFb3ZByaTAxMlJZS2pIM1E/edit?usp=sharing
 * que he encontrado en la pagina https://cae2100.wordpress.com/2014/01/15/robosapienwowwee-ir-arduino-library/ y dedonde he conseguido parte del codigo
 * Si ya tienes una libreria mas actualizada instalada, puedes escoger la version activa en el apartado Programa/Incluir Libreria/Gestionar Libreria/IRRemote
 * Selecciona la version 1.0.0 y funcionará a la primera
 *
 * The circuit:
 * IR LED - LED emisor en pin 3 controlado por 2n2222A con sus respectivas resistencias.
 *
 * Revisa el articulo publicado en http://www.pesadillo.com/pesadillo/?p=11092
 *
 * created 09/05/2019
 * by pesadillo 
 * This example code is in the public domain.
*/

/*
 * Lista de comandos disponibles:
 * Fuente : https://daverobertson63.wordpress.com/2013/05/05/updated-robosapien-ir-control-arduino/
 * Botón   Color mando   Función                             Pinzas   Codigo arduino
 * 12      rojo          Girar a la derecha                    1           128
 * 1       rojo          Brazo derecho arriba                  2           129
 * 4       rojo          Brazo derecho hacia fuera             2           130
 * 5       rojo          Inclinar cuerpo derecho               1           131
 * 2       rojo          Brazo derecho abajo                   2           132
 * 3       rojo          Brazo derecho encogido                2           133
 * 11      rojo          Caminar hacia adelante                2           134
 * 15      rojo          Caminar hacia atrás                   2           135
 * 14      rojo          Girar a la izquierda                  1           136
 * 6       rojo          Brazo izquierdo arriba                2           137
 * 9       rojo          Brazo izquierdo hacia fuera           2           138
 * 10      rojo          Inclinar cuerpo derecho               1           139
 * 7       rojo          Brazo izquierdo hacia abajo           2           140
 * 8       rojo          Brazo izquierdo encogido              2           141
 * 13      rojo          Detener                               1           142
 * 19      rojo          Programa de Comando Maestro           1           144
 * 20      rojo          Programa de juego                     1           145
 * 16      rojo          Programa de sensor derecho            1           146
 * 18      rojo          Programa de sensor izquierdo          1           147
 * 17      rojo          Programa de sensor sonoro             1           148
 * 12      Verde         Paso a la derecha                     1           160
 * 1       Verde         Golpe derecho                         1           161
 * 4       Verde         Lanzamiento diestro                   1           162
 * 5       Verde         Dormir                                1           163
 * 2       Verde         Recolección de la mano derecha        1           164
 * 3       Verde         Inclinarse hacia atrás                1           165
 * 11      Verde         Paso adelante                         1           166
 * 15      Verde         Paso hacia atras                      1           167
 * 14      Verde         Paso a la izquierda                   1           168
 * 6       Verde         Golpe izquierdo                       1           169
 * 9       Verde         Tiro de la mano izquierda             1           170
 * 10      Verde         Escucha                               1           171
 * 7       Verde         Recogida de la mano izquierda         1           172
 * 8       Verde         Inclinación hacia delante             1           173
 * 13      Verde         Reiniciar                             1           174
 * 19      Verde         Programa de Comando Maestro           1           176
 * 20      Verde         Despierta                             1           177
 * 16      Verde         Programa de sensor derecho Ejecutar   1           178
 * 18      Verde         Programa de Sensor Izquierdo Ejecutar 1           179
 * 17      Verde         Programa de sensor sonoro ejecutado   1           180
 * 12      Naranja       Golpe de mano derecha 3               1           192
 * 1       Naranja       Barrido de la mano derecha            1           193
 * 4       Naranja       Eructar                               1           194
 * 5       Naranja       LLave de la mano derecha              1           195
 * 2       Naranja       Alta 5                                1           196
 * 3       Naranja       LLave de la mano derecha              1           197
 * 11      Naranja       Excavadora                            1           198
 * 15      Naranja       Ups                                   1           199
 * 14      Naranja       Golpe de mano izquierda 3             1           200
 * 6       Naranja       Barrido de la mano izquierda          1           201
 * 9       Naranja       Silbar                                1           202
 * 10      Naranja       LLave de la mano izquierda            1           203
 * 7       Naranja       Replicar                              1           204
 * 8       Naranja       LLave de la mano izquierda            1           205
 * 13      Naranja       Rugido                                1           206
 * 19      Naranja       Todo demo                             1           208
 * 20      Naranja       Apagado                               1           209
 * 16      Naranja       Demo 1                                1           210
 * 18      Naranja       Demo 2                                1           211
 * 17      Naranja       Demostración de baile                 1           212
*/

#include
IRsend irsend;        // pin 3 es IR LED salida
int data;             // Variable de almace de datos de la lectura serie
void setup()
{
Serial.begin(9600);
irsend.sendRSV1(142);// Envio sonido test de inicio
}
void loop() {
  while (Serial.available()> 0) {
    data = Serial.parseFloat(); //Capturo valor DECIMAL introducido
    Serial.println(data); // Veo datos enviados en monitor serie
    irsend.sendRSV1(data); //Envio datos al pin 3

}
}

Un detalle tonto que me hizo perder algo de tiempo en la puesta en marcha. Acuérdate de que el infrarrojo, esté siempre por encima de la altura de la cabeza del robot, si no, el receptor no recibirá la orden.

El circuito:

Que hace el código?

Los comandos enviados a través del terminal serie del software Arduino, son enviados al Robosapiens a través del diodo IR que tiene una resistencia de 100 Ohm como medida de protección.

Más detalles:

Como se conectan diodos IR emisores y receptores:

Como identificar ánodo y cátodo del diodo:

Fijarse en la musca del encapsulado o que el ánodo tiene la patilla mas larga (en componentes nuevos).

Como ganar mas potencia con más leds:

En este caso, para aumentar la potencia de luz del diodo, en lugar de conectar directamente el diodo a la patilla 3, alimentamos a u transistor 2N2222A que es el que controlará, aplicando tensión directamente al diodo a través de su resistencia.

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (19)

pesadillo — Sun, 04 Oct 2015 19:30:26 +0000

Arduino Robot Ps

A la conquista del Bluetooth (2) …

Ayer planteamos el esquema y este es el resultado:

Una vez localizada la aplicación, y tras averiguar los comandos que envía la aplicación al modulo. Modificamos nuestro programa…

/*********************************************************************************************

  Tutorial: Robot Ps
  Autor: www.pesadillo.com - 27 Agosto 2015

http://www.pesadillo.com/

  Experimento... Implementamos un sistema de control remoto por Bluetooth. En lugar de que el
  robot realice una tarea programada, controlaremos sus movimientos.
  SEGUNDA PARTE: Mediante comunicacion Bluethooth comunicaremos un telefono con el Arduino Robot Ps
  Utilizaremos la aplicacion de  http://www.hobbyprojects.com/bluetooth-device-control/android-bluetooth-robo-remote-control-project.html
  
 ********************************************************************************************/
#define MOTOR1_CTL1  8  // I1
#define MOTOR1_CTL2  9  // I2


#define MOTOR2_CTL1  6  // I3
#define MOTOR2_CTL2  7  // I4


int speakerPin = 13;  // declaro pin para speaker

#include 

#define RxD 10
#define TxD 11
#define RST 5
//#define KEY 4

SoftwareSerial BTSerial(RxD, TxD);

//char Bluetooth; //crear variable que almacena los datos recibidos por el puerto serie
int inputString=0; //definimos 0 el valor de texto recibido por BT
 

void setup()
{
  // Setup pins for motor 1
   pinMode(MOTOR1_CTL1,OUTPUT);
   pinMode(MOTOR1_CTL2,OUTPUT);

   
  // Setup pins for motor 2
   pinMode(MOTOR2_CTL1,OUTPUT);
   pinMode(MOTOR2_CTL2,OUTPUT);

   
   // set the speaker pin mode to output
   pinMode(speakerPin, OUTPUT); 

  pinMode(RST, OUTPUT);
 // pinMode(KEY, OUTPUT);
  digitalWrite(RST, LOW);
  //digitalWrite(KEY, HIGH);
  digitalWrite(RST, HIGH);
  
  delay(500);
  
  BTSerial.flush();
  delay(500);
  BTSerial.begin(9600);
  BTSerial.begin(9600);//Habilitamos puerto BT a la velocidad de 9600
}

//pitidos (subproceso)
void pitido(char pitidos_num)
{
// el sibproceso pitido(3) Haría 3 pitidos)  
   for (int pip=0; pip0; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(200);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(200); 
        
     }
        delay (50);  
     }
}

// Antes de nada, obtenemos la lista de comandos de la aplicacion para manejar el robot
//Programa para control con el telefono: http://www.hobbyprojects.com/bluetooth-device-control/android-bluetooth-robo-remote-control-project.html
// La nuestra utiliza los siguientes caracteres:
//A = Arriba
//B = Abajo
//C = Derecha
//D = Izquierda
//E = Stop
//F = Giro 360
//G = Giro -360

//Empieza el ciclo
void loop()
{
  
  if (BTSerial.available()){ //si hay datos en el BT
   /* COMENTAMOS ESTE TEXTO QUE NO UTILIZAMOS while(BTSerial.available())
    {
      char inChar = BTSerial.read(); //lee la entrada de datos caracter por caracter
      inputString += inChar;        //compone la cadena como la recibe por el puerto serie
      
    }
   BTSerial.println(inputString); //'Imprimimos la cadena de texto almacenada en el puerto en la variable*/
   inputString=BTSerial.read(); //almacenamos el valor del texto enviado
   
   
  
  //delay (50);
   // while (Serial.available() > 0)  
   // { Bluetooth = Serial.read() ; }      // borrar buffer (datos almacenados) del puerto serie
   

  // avance
  if (inputString=='A') //En caso de recibir
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH); 
  
  }

  //atras
  if (inputString=='B')
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW); 
   
  } 

     //giro Derecha  
  if (inputString=='C')
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH);
   delay (50); //giramos durante este tiempo.
      //paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);  
  } 
  
  //giro Izquierda
  if (inputString=='D')
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH);
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW);
   delay (50); 
      // paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);
  } 
 
  
  //para
  if (inputString=='E')
  {
   
         // paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);
   pitido(2);
  } 
 //giro derecha 360
  if (inputString=='F')
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH);
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW);
   delay (490); 
      // paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);
  } 
  
       //giro izquierda 360  
  if (inputString=='G')
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH);
   delay (490); 
      //paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);  
  } 
  
 
   

   
  }
 //inputString = "";//Poner vaciar variable
}//fin del ciclo del programa

y se lo enviamos a la placa Arduino…

Retocamos el código y evitamos que el robot ande continuamente. De la siguiente forma, se controlará mejor el movimiento:

/*********************************************************************************************

  Tutorial: Robot Ps
  Autor: www.pesadillo.com - 27 Agosto 2015

http://www.pesadillo.com/

  Experimento... Implementamos un sistema de control remoto por Bluetooth. En lugar de que el
  robot realice una tarea programada, controlaremos sus movimientos.
  SEGUNDA PARTE: Mediante comunicacion Bluethooth comunicaremos un telefono con el Arduino Robot Ps
  Utilizaremos la aplicacion de  http://www.hobbyprojects.com/bluetooth-device-control/android-bluetooth-robo-remote-control-project.html
  En este codigo evitamos que se mueva continuamente y mandamos ordenes cortas para mejor control.
  
 ********************************************************************************************/
#define MOTOR1_CTL1  8  // I1
#define MOTOR1_CTL2  9  // I2


#define MOTOR2_CTL1  6  // I3
#define MOTOR2_CTL2  7  // I4


int speakerPin = 13;  // declaro pin para speaker

#include 

#define RxD 10
#define TxD 11
#define RST 5
//#define KEY 4

SoftwareSerial BTSerial(RxD, TxD);

//char Bluetooth; //crear variable que almacena los datos recibidos por el puerto serie
int inputString=0; //definimos 0 el valor de texto recibido por BT
 

void setup()
{
  // Setup pins for motor 1
   pinMode(MOTOR1_CTL1,OUTPUT);
   pinMode(MOTOR1_CTL2,OUTPUT);

   
  // Setup pins for motor 2
   pinMode(MOTOR2_CTL1,OUTPUT);
   pinMode(MOTOR2_CTL2,OUTPUT);

   
   // set the speaker pin mode to output
   pinMode(speakerPin, OUTPUT); 

  pinMode(RST, OUTPUT);
 // pinMode(KEY, OUTPUT);
  digitalWrite(RST, LOW);
  //digitalWrite(KEY, HIGH);
  digitalWrite(RST, HIGH);
  
  delay(500);
  
  BTSerial.flush();
  delay(500);
  BTSerial.begin(9600);
  BTSerial.begin(9600);//Habilitamos puerto BT a la velocidad de 9600
}

//pitidos (subproceso)
void pitido(char pitidos_num)
{
// el sibproceso pitido(3) Haría 3 pitidos)  
   for (int pip=0; pip0; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(200);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(200); 
        
     }
        delay (50);  
     }
}

// Antes de nada, obtenemos la lista de comandos de la aplicacion para manejar el robot
//Programa para control con el telefono: http://www.hobbyprojects.com/bluetooth-device-control/android-bluetooth-robo-remote-control-project.html
// La nuestra utiliza los siguientes caracteres:
//A = Arriba
//B = Abajo
//C = Derecha
//D = Izquierda
//E = Stop
//F = Giro 360
//G = Giro -360

//Empieza el ciclo
void loop()
{
  
  if (BTSerial.available()){ //si hay datos en el BT
   /*while(BTSerial.available())
    {
      char inChar = BTSerial.read(); //lee la entrada de datos caracter por caracter
      inputString += inChar;        //compone la cadena como la recibe por el puerto serie
      
    }
   BTSerial.println(inputString); //'Imprimimos la cadena de texto almacenada en el puerto en la variable*/
   inputString=BTSerial.read(); //almacenamos el valor del texto enviado
   
   
  
  //delay (50);
   // while (Serial.available() > 0)  
   // { Bluetooth = Serial.read() ; }      // borrar buffer (datos almacenados) del puerto serie
   

  // avance
  if (inputString=='A') //En caso de recibir
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH); 
     delay (300); //durante este tiempo.
      //paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);  
  }

  //atras
  if (inputString=='B')
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW); 
      delay (300); //durante este tiempo.
      //paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);  
  } 

     //giro Derecha  
  if (inputString=='C')
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH);
   delay (50); //giramos durante este tiempo.
      //paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);  
  } 
  
  //giro Izquierda
  if (inputString=='D')
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH);
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW);
   delay (50); 
      // paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);
  } 
 
  
  //para
  if (inputString=='E')
  {
   
         // paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);
   pitido(2);
  } 
 //giro derecha 360
  if (inputString=='F')
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH);
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW);
   delay (490); 
      // paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);
  } 
  
       //giro izquierda 360  
  if (inputString=='G')
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH);
   delay (490); 
      //paramos motores
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW); 
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);  
  } 
  
 
   

   
  }
 //inputString = "";//Poner vaciar variable
}//fin del ciclo del programa

Y… He aquí el resultado:

Un nuevo Juguete para los peques de la casa…

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (20)

pesadillo — Sun, 20 Sep 2015 19:37:48 +0000

Arduino Robot Ps

Nuestro proyecto de control Bluetooth terminado …

Como hemos visto a lo largo de este tutorial, hemos pasado de programar movimientos predefinidos a lograr un control remoto sobre nuestro pequeño robot. Todavía tenemos mucho juego por delante y ahora es el momento de jugar…

Implementamos accesorios a la estructura y nos ponemos a inventar juegos, por ejemplo coger un objeto y llevarlo de vuelta.

Estoy estudiando la tercera modificación, que será implementar unos sensores que convertirán nuestro pequeño robot en un seguidor de lineas. A la espera de recibir los componentes, no me queda otra que seguir jugando . Las entradas correspondientes se añadirá después de esta para agrupar todo el curso.

Un saludo. Muchas gracias a los que están ayudando a mantener con sus donativos los gastos del nuevo servidor.

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (18)

pesadillo — Fri, 18 Sep 2015 17:59:44 +0000

Arduino Robot Ps

A la conquista del Bluetooth…

Después de 18 días de trasteo 10 minutos diarios con el módulo Arduino UNO, podemos decir que “tenemos todo controlado”, y que mejor control que manejar nuestro pequeño montaje con el bluetooth.

Como he especificado en la entrada anterior, el módulo BT HC-05 nos permitirá conectar nuestro teléfono Android al montaje. Después de probar varios programillas gratuitos, he conseguido uno que es ideal para empezar a trastear…

Bluetooth Robo Control

Aquí vemos un video de funcionamiento:

He decidido pasar de pines en los hilos de conexión hembra que habían llegado con el módulo, y me he hecho con una tira macho hembra de 40 conexiones (0,70€):

Este sistema facilita mucho más las conexiones. En este punto integramos el modulo con la ayuda de un nuevo accesorio que nos permitirá disponer de varios puntos desde donde obtener los puntos de alimentación. Se trata de un accesorio para la placa Arduino UNO que se monta sobre ella y permite incluir un modulo protoboard para montar circuitos de prueba. Este sistema llamado ProtoShield nos permitirá el desarrollo posterior de otro tipo de proyectos con el montaje. Coste aproximado 1,25€ (ebay).

Quedará integrada en nuestra placa de la siguiente forma:

Y la conexión de la circuitería quedará de la siguiente manera:

Tienes trabajo hasta mañana para ubicar el modulo. Si esperas a la próxima entrada, veras como lo he implementado en el chasis.

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (17)

pesadillo — Wed, 16 Sep 2015 22:48:59 +0000

Arduino Robot Ps

Una vuelta de tuerca…

Habiendo programado nuestro pequeño robot para sus “primeros pasos” el peque de la casa me ha preguntado: “¿y por que no puedo usar el mando de la tele para moverlo?”

A lo que he respondido y por que no?

Me he puesto manos a la obra, y en lugar de utilizar el mando del TV, me he dicho, “y si usamos directamente el teléfono por bluethooth y nos evitamos las interferencias infrarrojas y poder usarlo en la calle con un amplio radio de alcance? …

Aquí la solución:

Un modulo BT HC-05 para el arduino (ebay 1,65€)

Antes de implementar el programa definitivo, debemos probar el funcionamiento del Arduino con el puerto serie virtual que se genera en la comunicación entre el programa y la placa Arduino, para ello, utilizaremos un nuevo código, que nos permitirá revisar las ordenes que enviamos desde el puerto serie de la aplicación y verificar el movimiento en el robot.

Elevamos el robot del suelo para que queden las ruedas en el aire y enviamos el siguiente programa:

/*********************************************************************************************

  Tutorial: Robot Ps
  Autor: www.pesadillo.com - 12 Agosto 2015

http://www.pesadillo.com/

  Experimento... Implementamos un sistema de control remoto por Bluetooth. En lugar de que el
  robot realice una tarea programada, controlaremos sus movimientos.
  PRIMERA PARTE: Mediante la consola de puerto serie del programador Arduino (monitor serie) enviaremos los
  comandos para verificar el funcionamiento del programa sobre el Arduino Robot Ps

 ********************************************************************************************/
#define MOTOR1_CTL1  8  // I1
#define MOTOR1_CTL2  9  // I2

#define MOTOR2_CTL1  6  // I3
#define MOTOR2_CTL2  7  // I4

int speakerPin = 13;  // declaro pin para speaker

char Bluetooth; //crear variable que almacena los datos recibidos por el puerto serie
String inputString=""; //definimos a nulo la cadena de texto

void setup()
{
  // Setup pins for motor 1
   pinMode(MOTOR1_CTL1,OUTPUT);
   pinMode(MOTOR1_CTL2,OUTPUT);

  // Setup pins for motor 2
   pinMode(MOTOR2_CTL1,OUTPUT);
   pinMode(MOTOR2_CTL2,OUTPUT);

   // set the speaker pin mode to output
   pinMode(speakerPin, OUTPUT);
   Serial.begin(9600);   // set the baud rate to 9600, same should be of your Serial Monitor
}

//pitidos (subproceso)
void pitido(char pitidos_num)
{
// el sibproceso pitido(3) Haría 3 pitidos)
   for (int pip=0; pip0; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(200);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(200);

     }
        delay (50);
     }
}

// Antes de nada, obtenemos la lista de comandos de la aplicacion para manejar el robot
// La nuestra utiliza los siguientes caracteres:
//F = Arriba
//L = Izquierda
//R = Derecha
//D = Abajo
//E = Stop (aqui utilizaremos el pitido)

//Empieza el ciclo
void loop()
{

if(Serial.available()){//Si hay datos en el puerto serie
  while(Serial.available())
    {
      char inChar = (char)Serial.read(); //lee la entrada de datos
      inputString += inChar;        //compone la cadena como la recibe por el puerto serie
    }
    Serial.println(inputString); //damos saliada a la cadena de texto almacenada.
    while (Serial.available() > 0)
    { Bluetooth = Serial.read() ; }      // borrar buffer (datos almacenados) del puerto serie

  // avance
  if (inputString=="F") //En caso de recibir
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH);
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH);
   //delay (tarea[i]); No utilizamos los delay ya que funcionara mientras reciba el comando por el puerto serie
  }
  //giro derecha
  if (inputString=="R")
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH);
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW);
   //delay (tarea[i]);
  }
  //giro izquierda
  if (inputString=="L")
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW);
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH);
   //delay (tarea[i]);
  }
  //atras
  if (inputString=="D")
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW);
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW);
   //delay (tarea[i]);
  }
  //para
  if (inputString=="E")
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW);
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);
   pitido(2);
   //delay (tarea[i]);
  }

  inputString = "";//Poner vaciar variable
  //cerramos la recepcion datos serie
  }

//fin del ciclo del programa
}

Una vez realizada la programación, nos vamos a HERRAMIENTAS / MONITOR SERIE y enviamos las letras escogidas para efectuar los diferentes movimientos… veremos que el robot interpreta el comando recibido por el puerto serie y lo ejecuta.

En la siguiente entrada, realizaremos la conexión del modulo e implantaremos el nuevo programa.

En este punto, he de mencionar que todo lo publicado hasta ahora en este “paso a paso” funciona perfectamente, intentar utilizar códigos de terceros o recopilados de foros me ha llevado a callejones sin salida y pérdidas de tiempo.

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (16)

pesadillo — Tue, 15 Sep 2015 22:29:48 +0000

Arduino Robot Ps

Llegados a este punto, donde hemos simplificado suficientemente lo comandos de acción sobre nuestros motores a través del Arduino, y viendo la eficacia de comando “array” para generar unas secuencias pre programadas, mejoramos el código de la siguiente manera:

/*********************************************************************************************

  Tutorial: Robot Ps
  Autor: www.pesadillo.com - 12 Agosto 2015

http://www.pesadillo.com/

  Modificamos codigo para programar movimientos y tiempos predifinidos ILIMITADOS

 ********************************************************************************************/
#define MOTOR1_CTL1  8  // I1
#define MOTOR1_CTL2  9  // I2

#define MOTOR2_CTL1  6  // I3
#define MOTOR2_CTL2  7  // I4

//#define MOTOR_DIR_FORWARD  0
//#define MOTOR_DIR_BACKWARD   1
//Se termina de eliminar codigo antiguo con  el // que lo transforma en comentario y nos quedamos con el programa personalizado

int speakerPin = 13;  // declaro pin para speaker

void setup()
{
  // Setup pins for motor 1
   pinMode(MOTOR1_CTL1,OUTPUT);
   pinMode(MOTOR1_CTL2,OUTPUT);

  // Setup pins for motor 2
   pinMode(MOTOR2_CTL1,OUTPUT);
   pinMode(MOTOR2_CTL2,OUTPUT);

   // set the speaker pin mode to output
   pinMode(speakerPin, OUTPUT);
}

//pitidos (subproceso)
void pitido(char pitidos_num)
{
// el sibproceso pitido(3) Haría 3 pitidos)
   for (int pip=0; pip0; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(200);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(200);

     }
        delay (50);
     }
}

/*
Tarea a realizar por el robot
avanza(2000);//enviamos cuanto avanza
para(2000);//enviamos cuanto para
atras(2000);//enviamos cuanto atras...
para(2000);
girad(230);//= +-90g
para(2000);
girai(230);//= +-90g
para(2000);
girad(460);// giro derecha 180g
para(2000);
*/

//comandos (programa)
//definimos dos valores ilimitados, comado y tiempo de tarea (tarea)
// array con mismo numero de valores (se corresponden)
//tabla de comandos
// 0 = parar
// 1 = avanza
// 2 = atras
// 3 = giraderecha
// 4 = giraizquierda

//definimos un array  "comado" que almacena las ordenes a realizar
int comando[]={1,0,2,0,3,0,4,0,3,0,3,0};
//definimos un array "tarea" que especifica los tiempos de esa tarea
int tarea[]={1000,2000,1000,2000,230,2000,230,2000,460,1000,460,2000};

//Empieza el ciclo infinito
void loop()
{

// usamos un bucle para hacer efecto silvido.
 for (int i=500; i>200; i--)
 {
digitalWrite(speakerPin, HIGH);
delayMicroseconds(i);
digitalWrite(speakerPin, LOW);
delayMicroseconds(i);

 }
delay (5000);//esperamos 5 segundos despues de silvido

//comenzamos el ciclo del programa en el bucle
//si el programa esta bien definido (misma cantidad de valores) en "comando" y "tarea", ejecutamos el programa
if (sizeof(comando)==sizeof(tarea)){
  //ejecutamos las ordenes programadas en el array,
  //donde "sizeof(comando)" nos dará el numero total de comandos a realizar
  //y restamos 1 por que el primer comando ha de ser el array con valor "0"
  for (int i = 0; i < sizeof(comando)-1; i++) {
  // avance
  if (comando[i]==1)
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH);
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH);
   delay (tarea[i]);
  }
  //giro derecha
  if (comando[i]==3)
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,HIGH);
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW);
   delay (tarea[i]);
  }
  //giro izquierda
  if (comando[i]==4)
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW);
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,HIGH);
   delay (tarea[i]);
  }
  //atras
  if (comando[i]==2)
  {
   digitalWrite(MOTOR1_CTL1,HIGH);
   digitalWrite(MOTOR1_CTL2,LOW);
   digitalWrite(MOTOR2_CTL1,HIGH);
   digitalWrite(MOTOR2_CTL2,LOW);
   delay (tarea[i]);
  }
  //para
  if (comando[i]==0)
  {
   digitalWrite(MOTOR1_CTL1,LOW);
   digitalWrite(MOTOR1_CTL2,LOW);
   digitalWrite(MOTOR2_CTL1,LOW);
   digitalWrite(MOTOR2_CTL2,LOW);
   pitido(2);
   delay (tarea[i]);
  }
  }
}

//Final de tarea programada y volvemos al principio despues de 3 pitidos y 3 segundos de espera.
pitido(3);
delay (3000);
}

Interesante… pre programamos tareas en un array “ilimitado”… ummm podríamos realizar varios subproceos para que se ejecutaran arrays distintos en función de si hay un choque, una acción de un haz de luz,…

La utilización de arrays es muy simple aún que podríamos entrar más en la utilización de “arrays dobles” que almacenan las dos variables, pero ahora no es el momento.

Lo que hemos estirado a 15 días (10 minutos diarios), se ha realizado en la mesa en una tarde de rompederos de cabeza, y funciona!!!

En este punto, damos por entendido el programa de control de nuestro robot y pasamos a tareas mayores….

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (15)

pesadillo — Mon, 14 Sep 2015 22:12:10 +0000

Arduino Robot Ps

Seguimos de lleno con la programación, entendiendo paso a paso, y evolucionando nuestro programa para conseguir simplificar las ordenes a enviar a nuestro pequeño robot.

Hemos dedicado 10 minutos diarios, y ya tenemos nuestro pequeño robot autónomo, realizando pequeños movimientos pre programados.

Seguimos programando…

Hemos pasado a la utilización del “array”… un comando que nos permitirá almacenar varios valores en una variable…

Lo entenderemos fácilmente con el codigo:

(código 7)

/*********************************************************************************************

  Tutorial: Robot Ps
  Autor: www.pesadillo.com - 12 Agosto 2015

http://www.pesadillo.com/

  Modificamos codigo para porgramar movimientos y tiempos predifinidos para conseguir simplificar las ordenes de mando.
  Implementacion del "array"

 ********************************************************************************************/
#define MOTOR1_CTL1  8  // I1
#define MOTOR1_CTL2  9  // I2

#define MOTOR2_CTL1  6  // I3
#define MOTOR2_CTL2  7  // I4

#define MOTOR_DIR_FORWARD  0
#define MOTOR_DIR_BACKWARD   1

int speakerPin = 13;  // declaro pin para speaker

void setup()
{
  // Setup pins for motor 1
   pinMode(MOTOR1_CTL1,OUTPUT);
   pinMode(MOTOR1_CTL2,OUTPUT);

  // Setup pins for motor 2
   pinMode(MOTOR2_CTL1,OUTPUT);
   pinMode(MOTOR2_CTL2,OUTPUT);

   // set the speaker pin mode to output
   pinMode(speakerPin, OUTPUT);
}

//pitidos
void pitido(char pitidos_num)
{

   for (int pip=0; pip0; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(200);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(200);

     }
        delay (50);
     }
}

/*
Tarea a realizar
avanza(2000);//enviamos cuanto avanza
para(2000);//enviamos cuanto para
atras(2000);//enviamos cuanto atras...
para(2000);
girad(230);//= +-90g
para(2000);
girai(230);//= +-90g
para(2000);
girad(460);// giro derecha 180g
para(2000);
*/

//comandos
//definimos dos valores, comado y tiempode tarea (tarea)
// array con mismo numero de valores (se corresponden)
//tabla de comandos
// 0 = parar
// 1 = avanza
// 2 = atras
// 3 = giraderecha
// 4 = giraizquierda
int comando[10]={1,0,2,0,3,0,4,0,3,1};
int tarea[10]={1000,2000,1000,2000,230,1000,230,2000,460,1000};

//Empieza el ciclo
void loop()
{

// usamos un bucle para hacer efecto silvido.
 for (int i=500; i>200; i--)
 {
digitalWrite(speakerPin, HIGH);
delayMicroseconds(i);
digitalWrite(speakerPin, LOW);
delayMicroseconds(i);

 }
delay (5000);//esperamos 5 segundos después de silvido

//comenzamos el cliclo del programa bucle
//Este ciclo es el encargado de realizar cada orden almacenada en los dos arrays predefinidos
//el que controla el movimiento y el tiempo de ese movimiento

//definimos la variable numérica (INT) "i" con el valor cero, decimos que se ejecite mientras sea menor que 10 (i < 10) y vamos sumando uno (i++)
for (int i = 0; i < 10; i++) {

// avance
if (comando[i]==1)
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,HIGH);
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,HIGH);
 delay (tarea[i]);
}

//giro derecha
if (comando[i]==3)
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,HIGH);
 digitalWrite(MOTOR2_CTL1,HIGH);
 digitalWrite(MOTOR2_CTL2,LOW);
 delay (tarea[i]);
}

//giro izquierda
if (comando[i]==4)
{
 digitalWrite(MOTOR1_CTL1,HIGH);
 digitalWrite(MOTOR1_CTL2,LOW);
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,HIGH);
 delay (tarea[i]);
}

//atras
if (comando[i]==2)
{
 digitalWrite(MOTOR1_CTL1,HIGH);
 digitalWrite(MOTOR1_CTL2,LOW);
 digitalWrite(MOTOR2_CTL1,HIGH);
 digitalWrite(MOTOR2_CTL2,LOW);
 delay (tarea[i]);
}

if (comando[i]==0)
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,LOW);
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,LOW);
 pitido(2);
 delay (tarea[i]);
}
}

//Una vez terminado el bucle "for" realizamos 3 pitidos y vuelve al comienzo del bucle infinito -void loop()-
pitido(3);
delay (3000);
}

Como hemos visto anteriormente, una vez simplificada la acción de los motores, nos dedicamos a mejorar el programa simplificando la forma de enviar las ordenes a nuestro robot. En este caso, dos arrays “emparejados” se encargan almacenar los dos comando necesarios para la realización del movimiento.

Veremos un nuevo retoque el próximo día.

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (14)

pesadillo — Sun, 13 Sep 2015 22:08:01 +0000

Arduino Robot Ps

Seguimos probando…

Siguiendo con el objetivo de simplificar las ordenes de mando para nuestro pequeño robot, nos hemos puesto las manos a la obra y hemos llegado a una simplificación interesante:

/*********************************************************************************************

  Tutorial: Robot Ps
  Autor: www.pesadillo.com - 12 Agosto 2015

http://www.pesadillo.com/

  Implementamos altavoz para proporcionar pitidos de señalizacion. Simplificamos los giros en motores.
  Simplificamos codigo enviando a los subprocesos los tiempos de ejecución del comando.

 ********************************************************************************************/
#define MOTOR1_CTL1  8  // I1
#define MOTOR1_CTL2  9  // I2


#define MOTOR2_CTL1  6  // I3
#define MOTOR2_CTL2  7  // I4


#define MOTOR_DIR_FORWARD  0
#define MOTOR_DIR_BACKWARD   1

int speakerPin = 13;  // declaro pin para speaker
 

void setup()
{
  // Setup pins for motor 1
   pinMode(MOTOR1_CTL1,OUTPUT);
   pinMode(MOTOR1_CTL2,OUTPUT);

   
  // Setup pins for motor 2
   pinMode(MOTOR2_CTL1,OUTPUT);
   pinMode(MOTOR2_CTL2,OUTPUT);

   
   // set the speaker pin mode to output
   pinMode(speakerPin, OUTPUT); 
}


void motorStart(char motor_num, byte direction)
{
  
   char pin_ctl1;
   char pin_ctl2;
   
   if (motor_num == 1)
   {
      pin_ctl1 = MOTOR1_CTL1;
      pin_ctl2 = MOTOR1_CTL2;
   }   
   else
   {
      pin_ctl1 = MOTOR2_CTL1;
      pin_ctl2 = MOTOR2_CTL2;     
   }
  
   switch (direction)
   {
     case MOTOR_DIR_FORWARD:
     {
       digitalWrite(pin_ctl1,LOW);
       digitalWrite(pin_ctl2,HIGH);          
     }
     break; 
          
     case MOTOR_DIR_BACKWARD:
     {
        digitalWrite(pin_ctl1,HIGH);
        digitalWrite(pin_ctl2,LOW);          
     }
     break;         
   }
}

void motorStop(char motor_num)
{
   if (motor_num == 1)
   {
     digitalWrite(MOTOR1_CTL1,LOW);
     digitalWrite(MOTOR1_CTL2,LOW);     
   }
   else
   {
     digitalWrite(MOTOR2_CTL1,LOW);
     digitalWrite(MOTOR2_CTL2,LOW);     
   }
}


//pitidos
void pitido(char pitidos_num)
{
  
   for (int pip=0; pip0; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(200);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(200); 
        
     }
        delay (50);  
     }
}


// avance
void avanza(int avanza_num) //seguimos con el SUBPROCESO "avanza" al que le pedimos un valor numerico (INT)
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,HIGH); 
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,HIGH); 
 delay (avanza_num);//Aplicamos el valor numerico obtenido entre parentesis 
}  

void para(int para_num)
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,LOW); 
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,LOW);
 pitido(2);
 delay(para_num);
}  

//giro derecha
void girad(int girad_num)
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,HIGH);
 digitalWrite(MOTOR2_CTL1,HIGH);
 digitalWrite(MOTOR2_CTL2,LOW);
 delay (girad_num);  
}   

//giro izquierda  
void girai(int girai_num)
{
 digitalWrite(MOTOR1_CTL1,HIGH);
 digitalWrite(MOTOR1_CTL2,LOW); 
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,HIGH);
 delay (girai_num);   
} 

//atras
void atras(int atras_num)
{
 digitalWrite(MOTOR1_CTL1,HIGH);
 digitalWrite(MOTOR1_CTL2,LOW); 
 digitalWrite(MOTOR2_CTL1,HIGH);
 digitalWrite(MOTOR2_CTL2,LOW); 
 delay (atras_num);  
} 
  

void loop()
{
  
    // usamos un bucle para hacer efecto silvido.
   for (int i=500; i>200; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(i);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(i); 
        
     }
    //fin silvido 
   delay(5000);// espera 5 segundos

//He aqui el código simplificado con los comandos del anterior desarrollo:
  
avanza(2000);//enviamos cuanto avanza
para(2000);//enviamos cuanto para
atras(2000);//enviamos cuanto atras...
para(2000);
girad(230);//= +-90g     
para(2000);
girai(230);//= +-90g
para(2000);
girad(460);// giro derecha 180g        
para(2000);
//Final

// Como se observa muchisimo mas simple
pitido(3);
delay (3000);
}

El próximo día rizaremos más el rizo y conseguiremos un nuevo objetivo.

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (13)

pesadillo — Sat, 12 Sep 2015 22:42:35 +0000

Arduino Robot Ps

Seguimos probando…

Una vez implementado este accesorio es hora de probarlo:

Un buen comportamiento, pero con alguna modificación de código quedaría mejor la exactitud de movimientos.

Intentando mejorar el código y simplificación de comandos he llegado a esto:

/*********************************************************************************************

  Tutorial: Robot Ps
  Autor: www.pesadillo.com - 12 Agosto 2015

http://www.pesadillo.com/

  Implementamos altavoz para proporcionar pitidos de señalizacion. Simplificamos los giros en motores.

 ********************************************************************************************/
#define MOTOR1_CTL1  8  // I1
#define MOTOR1_CTL2  9  // I2

#define MOTOR2_CTL1  6  // I3
#define MOTOR2_CTL2  7  // I4

#define MOTOR_DIR_FORWARD  0
#define MOTOR_DIR_BACKWARD   1

int speakerPin = 13;  // declaro pin para speaker

void setup()
{
  // Setup pins for motor 1
   pinMode(MOTOR1_CTL1,OUTPUT);
   pinMode(MOTOR1_CTL2,OUTPUT);

  // Setup pins for motor 2
   pinMode(MOTOR2_CTL1,OUTPUT);
   pinMode(MOTOR2_CTL2,OUTPUT);

   // set the speaker pin mode to output
   pinMode(speakerPin, OUTPUT);
}

void motorStart(char motor_num, byte direction)
{

   char pin_ctl1;
   char pin_ctl2;

   if (motor_num == 1)
   {
      pin_ctl1 = MOTOR1_CTL1;
      pin_ctl2 = MOTOR1_CTL2;
   }
   else
   {
      pin_ctl1 = MOTOR2_CTL1;
      pin_ctl2 = MOTOR2_CTL2;
   }

   switch (direction)
   {
     case MOTOR_DIR_FORWARD:
     {
       digitalWrite(pin_ctl1,LOW);
       digitalWrite(pin_ctl2,HIGH);
     }
     break;

     case MOTOR_DIR_BACKWARD:
     {
        digitalWrite(pin_ctl1,HIGH);
        digitalWrite(pin_ctl2,LOW);
     }
     break;
   }
}

void motorStop(char motor_num)
{
   if (motor_num == 1)
   {
     digitalWrite(MOTOR1_CTL1,LOW);
     digitalWrite(MOTOR1_CTL2,LOW);
   }
   else
   {
     digitalWrite(MOTOR2_CTL1,LOW);
     digitalWrite(MOTOR2_CTL2,LOW);
   }
}

//pitidos
void pitido(char pitidos_num)
{

   for (int pip=0; pip0; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(200);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(200);

     }
        delay (50);
     }
}

// avance

void avanza() //creamos el comando "avanza" y especificamos el comportamiento de las salidas (sentido de giro de los motores)
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,HIGH);
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,HIGH);
}

void para() //comando "para" donde dejamos de suministrar energia a los morores
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,LOW);
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,LOW);
pitido(2);
}

void girad() //giro a derecha
{
 digitalWrite(MOTOR1_CTL1,LOW);
 digitalWrite(MOTOR1_CTL2,HIGH);
 digitalWrite(MOTOR2_CTL1,HIGH);
 digitalWrite(MOTOR2_CTL2,LOW);
}

void girai() //giro a izquierda (vease que se alimenta uno de los polos de las bobinas del motor en funcion del giro deseado)
{
 digitalWrite(MOTOR1_CTL1,HIGH);
 digitalWrite(MOTOR1_CTL2,LOW);
 digitalWrite(MOTOR2_CTL1,LOW);
 digitalWrite(MOTOR2_CTL2,HIGH);
}

void atras()//atras... invertimos "avanza"
{
 digitalWrite(MOTOR1_CTL1,HIGH);
 digitalWrite(MOTOR1_CTL2,LOW);
 digitalWrite(MOTOR2_CTL1,HIGH);
 digitalWrite(MOTOR2_CTL2,LOW);
}

void loop()
{

    // usamos un bucle para hacer efecto silvido.
   for (int i=500; i>200; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(i);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(i);

     }
    //fin pitido
   delay(5000);// espera 5 segundos

//Ejecutamos los comandos deseados llamando a los subprocesos:
avanza();
delay (2000);//paramos 5 segundos

para();
delay (5000);//paramos 5 segundos

atras();
delay (2000);//paramos 5 segundos

para();
delay (5000);//paramos 5 segundos

girad();
  delay(230);//= +-90g

para();
  delay (5000);//paramos 5 segundos

girai();
  delay(230);//= +-90g

para();
  delay (5000);//paramos 5 segundos

  // giro derecha 180g
girad();
  delay(460);//=+-180grados

para();
  delay (10000);//paramos 10 segundos

pitido(3);//damos 3 pitidos
delay (3000);//esperamos 3 segundos
}

Un código más entendible… podéis probarlo enviando la programación a la placa para ver su comportamiento.
El próximo día seguiremos con el desarrollo y aprendizaje.

Construye tu robot por menos de 20€ con Arduino. Arduino Robot Ps (12)

pesadillo — Fri, 11 Sep 2015 22:23:54 +0000

Arduino Robot Ps

Seguimos programando…

Esta vez, implementaremos un nuevo accesorio a nuestro robot. Un pequeño altavoz que nos proporcione información de en que punto del proceso se encuentra.

/*********************************************************************************************

  Tutorial: Arduino Robot Ps V1.0
  Autor: Pesadillo.com Agosto 2015

http://www.pesadillo.com

 ********************************************************************************************/
//esto es una linea comentada (no se ejecuta en el codigo)

/*
Esto es una frase comentada (no se ejecuta en el codigo)
*/

/*
En este ejercicio simplificamos variables no utilizadas (salidas analógicas para el control de velocidad) con respecto al código anterior.
Implementamos un altavoz (buzz) de PC para averiguar en que punto del proceso se encuentra nuestro Arduino Robot Ps. Nos informará con sonidos de lo que hace.

*/

#define MOTOR1_CTL1  8  // I1
#define MOTOR1_CTL2  9  // I2

#define MOTOR2_CTL1  6  // I3
#define MOTOR2_CTL2  7  // I4

#define MOTOR_DIR_FORWARD  0
#define MOTOR_DIR_BACKWARD   1

int speakerPin = 13;  // declaro pin para speaker (aprobechamos que la masa esta al lado de este pin)

void setup()
{
  // Configuramos pines para motor 1
   pinMode(MOTOR1_CTL1,OUTPUT);
   pinMode(MOTOR1_CTL2,OUTPUT);

  // Configuramos pines para motor 2
   pinMode(MOTOR2_CTL1,OUTPUT);
   pinMode(MOTOR2_CTL2,OUTPUT);

   // Configuramos pin para salida (OUTPUT) del altavoz (speaker)
   pinMode(speakerPin, OUTPUT);
}

/*
void NOMBRE
son subprocesos a los que llamamos desde el programa principal
*/
void motorStart(char motor_num, byte direction)
{
  /*En este  void se reclaman dos variables (una de tipo "caracter (CHAR)" y otra de tipo BYT (byte) para especificar el numero de motor y direccion*/
   char pin_ctl1;
   char pin_ctl2;

   if (motor_num == 1)
   {
      pin_ctl1 = MOTOR1_CTL1;
      pin_ctl2 = MOTOR1_CTL2;
   }
   else
   {
      pin_ctl1 = MOTOR2_CTL1;
      pin_ctl2 = MOTOR2_CTL2;
   }

   switch (direction)
   {
     case MOTOR_DIR_FORWARD:
     {
       digitalWrite(pin_ctl1,LOW);
       digitalWrite(pin_ctl2,HIGH);
     }
     break;

     case MOTOR_DIR_BACKWARD:
     {
        digitalWrite(pin_ctl1,HIGH);
        digitalWrite(pin_ctl2,LOW);
     }
     break;
   }
}

void motorStop(char motor_num)
{
  /*Este void "motorstop" detiene el motor que recibe entre parentesis (mediante una variable del tipo caracter ej. a,b,c,d,1,2,3...)*/
   if (motor_num == 1)//si el motor es el 1
   {
     digitalWrite(MOTOR1_CTL1,LOW);//ponemos a 0v (low) la salida
     digitalWrite(MOTOR1_CTL2,LOW);//ponemos a 0v (low) la salida del pin MOTOR1_CTL2 (nombre del pin que hemos puesto mas arriba y que se corresponde don el pon 9 del Arduino)
   }
   else
   {
     digitalWrite(MOTOR2_CTL1,LOW);
     digitalWrite(MOTOR2_CTL2,LOW);
   }
}

void loop()
{

    // usamos un bucle para hacer efecto silvido.
   for (int i=500; i>200; i--)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(i);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(i+500);
     }

   delay(5000);
  // espera 5 segundos

  // avance
  motorStart(1, MOTOR_DIR_FORWARD);
  motorStart(2, MOTOR_DIR_FORWARD);
  delay(1100);//2200 milisegundos = +- 1metro

  //paro
  motorStop(1);
  motorStop(2);
  delay (5000);//paramos 5 segundos

  // giro derecha 90g
  motorStart(1, MOTOR_DIR_FORWARD);
  motorStart(2, MOTOR_DIR_BACKWARD);
  delay(230);//= +-90g
  //paro
  motorStop(1);
  motorStop(2);
  delay (5000);//paramos 5 segundos

  // giro izquierda 90g
  motorStart(2, MOTOR_DIR_FORWARD);
  motorStart(1, MOTOR_DIR_BACKWARD);
  delay(230);//= +-90g
  //paro
  motorStop(1);
  motorStop(2);
  delay (5000);//paramos 5 segundos

  // giro derecha 180g
  motorStart(1, MOTOR_DIR_FORWARD);
  motorStart(2, MOTOR_DIR_BACKWARD);
  delay(460);//=+-180grados
  //paro
  motorStop(1);
  motorStop(2);
  delay (5000);//esperamos 5 segundos

}

Y así queda nuestra nueva implementación:

Y ya podéis hacer la prueba… no olvidéis retocar los valores del bucle

   for (int i=500; i>200; i--)//restamos (de grave a agudo)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(i);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(i+500);
     }

por

   for (int i=200; i<500; i++)//sumamos (de agudo a grave)
     {
        digitalWrite(speakerPin, HIGH);
        delayMicroseconds(i);
        digitalWrite(speakerPin, LOW);
        delayMicroseconds(i+500);
     }

u otras combinaciones (modificando los valores numéricos) para conseguir vuestro propio sonido.
Con este bucle creamos una onda cuadrada con una determinada frecuencia que es lo que interpreta el altavoz (speaker).
A valores mas pequeños, frecuencias mas altas = Sonidos más agudos.

Seguimos mañana.