Curso básico y avanzado de pilotos drones en Don Bosco (Errenteria)

Curso básico y avanzado de pilotos drones en Don Bosco (Errenteria)

¡La FPeuskadi innova! En Don Bosco estamos trabajando en torno a un proyecto para acercar la tecnología de los drones a la FP. La Agencia Estatal de Seguridad Aérea publicó en Julio la normativa en la cual se regula el sector y se marcan unas normas claras para poder volar cualquier equipo de trabajo. Para poder trabajar como piloto de drones hay que tener la formación acreditada por una Organización de Formación Aprovada (ATO).

 

 

Con el objetivo de impulsar el sector y el empleo, en Errenteria en las instalaciones de FP Don Bosco, se realizará el primer curso del País Vasco básico y avanzado de pilotos rpas. El curso se realizará entre el 12-18 de enero del 2015 con horario de 9:00 a 19:00. El Alumnado adquirirá:
  • Formación teórica básica y avanzada de pilotos rpas
  • Formación práctica de conocimiento y pilotaje de un multirrotor

 

De esta manera al finalizar el curso el alumno estará capacitado legalmente para pilotar un drone (multirrotor). Con esto Don Bosco está ayudando a que el sector pueda despegar en en País Vasco. Las plazas son limitadas y se prevé una alta participación porque la tecnología de las aeronaves autónomas o controladas por control remoto están en plena expansión. La Association for Unmanned Vehicle Systems International (AUVSI), prevé que en una década el negocio de los drones civiles genere en Estados Unidos 100.000 nuevos empleos y unos 82.000 millones de dólares de ingresos. El sector está creciendo a un ritmo tan rápido que la Comisión Europea estima que llegará a acaparar el 10% del mercado aeronáutico en una década.

 

 

La aplicación de los drones es muy variada, algunas están asentadas, otras están en desarrollo y se provee que otras muchas estén por llegar. Algunos ejemplos de sectores y actividades en las que se trabaja con drones:

 

 

El uso civil que está más asentado en el mercado es la obtención de vídeo e imágenes. Este tipo de aplicaciones son las que están empujando al sector, haciendo que los fotógrafos y cámaras estén empezando a formarse en el uso de los drones.

Recordar que aunque usaremos varios medios para transmitir la evolución y los distintos resultados que vayamos obteniendo, principalmente la información la difundiremos en el Blog y mediante Twitter

 

Primer Drone reparado en FPeuskadi

Primer Drone reparado en FPeuskadi

Los drones al ser unos equipos que vuelan más o menos autónomos suelen sufrir averías por fallos al interactuar con ellos las personas o por fallos de diseño. En Don Bosco gracias a los proyectos de innovación de la FP hemos adquirido 2 drones multirotores. Por asesoramiento de Fernando Linares de la empresa SQADrones adquirimos uno muy simple. Esta listo para volar, es robusto por lo que absorbe bien los golpes y responde de una manera muy fiel al comportamiento de un drone de RC. Es un equipo ideal para aprender a volar y acostumbrarnos a la emisora sin miedo a romper el drone.

 

Sabíamos que este tipo de drones están hechos con materiales de baja calidad y elaborados con una cualificación muy justa de mano de obra. Pero nos decantamos a favor por una parte por su precio pero sobre por la gran cantidad de recambios a los que da la opción de acceder.

 

El primer día de uso a los 10 minutos empezó a dar síntomas de avería. No se levantaba más que un palmo del suelo y parecía como si le costase, como si le faltase energía. Al tener solo una batería dimos por supuesto que era la batería que se había descargado y no le dimos la mayor importancia. Eso si al ver la falta de baterías compramos otras 2.

A las semanas cuando llegaron las nuevas baterías fuimos a volar con las 3 baterías al gimnasio de Don Bosco. Cuando poníamos una batería cargada, en un primer momento despegaba sin mayor problema pero a los 15 segundos volvía a faltarle fuerza y no se levantaba más de un palmo del suelo. Ante este problema, compramos todos los repuestos del equipo (tardan casi un mes en llegar los repuestos) para poder ir haciendo pruebas.

Al ser un equipo propietario, no hay disponible mucha información (esquemas, planos…) así que con solo 10 minutos de vuelo era complicado saber que podía fallar. Pero por los síntomas parecía que podía ser problema de la placa controladora, que no era capaz de suministrar la suficiente energía a los motores. Cambiamos la placa controladora con mucho cuidado de no provocar otra avería o rotura del chasis, pero el drone volaba igual, por lo que había que pesar en otra cosa.

 

 

Otro punto fuerte de este drone es que aunque te golpee con las hélices no hace mucho daño. Si la placa controladora no era, deberían de ser lo motores pero a simple vista todos giraban. Al coger con la mano el drone e ir girándolo hacia todos los lados enseguida notamos que al girarlo hacia uno de los lados, la hélice giraba pero no lo hacia con suficiente fuerza por lo que no era capaz de estabilizarlo.

 

 

El cambio de motor es un poco más complicado que el de la controladora de vuelo, no es complejo pero no es apto para manos temblorosas. Primero hay que desmontar gran parte del chasis del drone para poder acceder al motor. Una vez que se ha liberado el motor hay que desoldar los cables con mucho cuidado ya que son muy frágiles y volver a soldárselos al motor nuevo. Por último solo queda rehacer los pasos y volver a montar el motor y el chasis.

 

 

Recordar que aunque usaremos varios medios para transmitir la evolución y los distintos resultados que vayamos obteniendo, principalmente la información la difundiremos en el Blog y mediante Twitter.

Dronecode: Los proyectos libres de drones con linux

Dronecode: Los proyectos libres de drones con linux

La Linux Fundation, organización sin ánimo de lucro dedicada a acelerar el crecimiento de Linux y el desarrollo colaborativo, ha anunciado la creación del Proyecto Dronecode. El proyecto reunirá a los proyectos de aviones no tripulados de código abierto existentes y los activos bajo una estructura sin ánimo de lucro dirigida por la Fundación Linux. El resultado será una plataforma de código abierto común, compartido para vehículos aéreos no tripulados (UAV).

.

 

Una figura muy importante que ha hecho posible, el desarrollo de los drones propiciando la democratización de la tecnología, ha sido Chris Anderson. Como muy bien explica su papel en su blog, Chris empezó a experimentar con su hijo con la robótica y los aviones de radio control hacia 2007. Como vio que era un mundo muy complejo creo la web DIY Drones para que la gente pudiera hacer “públicamente preguntas tontas” sobre la tecnología de los drones.

La plataforma DIY Drones ha crecido muy rápido hasta llegar a los 60.000 miembros activos. Los miembros empezaron colaborando de una manera informal en electrónica, software, diseños aeronáuticos… hasta llegar a colaborar de una manera organizada entorno a proyectos de código abierto, como Ardupilot, Mission Planner, DroidPlaner y otros muchos. Gran parte de estos proyectos fueron posibles usando la plataforma electrónica de código abierto Arduino.
Líderes de la robótica de todo el mundo fueron adoptando la innovación abierta, como Lorenz Meier de ETH en Zurich. Empezando a dirigir los proyectos PX4 y MAVlink, llegó a asociarse con la empresa 3D Robotics creada por Chris Anderson en el 2009. Es un clásico ejemplo de la potencia de la democratización de una tecnología. Está empezando la era de los drones para el consumidor y uso comercial y esto ha sido gran parte gracias a una plataforma de código abierto que ha ayudado a abrir el camino.
Ahora que se ha llegado a este nivel de desarrollo y madurez tecnológico, es el momento de abrazar las mejores prácticas de otros proyectos de código abierto de gran éxito, incluyendo las estructuras de gestión y de gobierno profesionales, para asegurar el crecimiento continuo y la independencia de estos esfuerzos. Se ha creado la Fundación Dronecode para que bajo el control de la Fundación Linux, gestione una organización sin ánimo de lucro, que reúna los proyectos de software de código abierto UAV.

.

.
La creación de una organización formal sin ánimo de lucro para organizar, dirigir y coordinar estos proyectos, hace que sea más fácil que las empresas deseen abrazar la innovación abierta en sus propios esfuerzos en UAV y robótica. Esto les permite participar de una manera más formal, ayudando a garantizar que puedan contribuir a la comunidad en todo, desde el código, a las personas, hasta el recurso financiero. En torno a este proyecto, se han incluido gigantes como Intel, Qualcomm, Box y Baidu, además de líderes en UAV como Yuneec, Walkera y la propia Robotics 3D.
¿Por qué ahora? No sólo porque los drones son una tecnología innovadora en pleno boom y abierta, por encima de todo, es porque las plataformas han madurado, y se dirigen cada vez más en la misma dirección, que es en sí Linux. Las mejoras extraordinarias en la tecnología de hardware móvil (gracias Intel y Qualcomm!) Y la tecnología de la nube (gracias Box y Baidu!), Significa que nuestra comunidad y el software está ejecutando cada vez más en los equipos Linux, con conexiones de banda ancha constantes a la nube. Eso significa que la oportunidad para unir fuerzas con el Linux y la comunidad de Linux embebido es ahora el lugar perfecto gracias a la Fundación Linux. ¡Veamos que nos depara la nueva alianza!
.
.
Proyecto de Innovación: Montaje, mantenimiento y desarrollo de tecnologías de drones

Proyecto de Innovación: Montaje, mantenimiento y desarrollo de tecnologías de drones

A continuación vamos a presentar el trabajo que iremos desarrollando en Don Bosco, para formar a las empresas y técnicos cualificados, entorno a los Drones.
Los vehículos aéreos no tripulados(VANT-UAV-RPA), son comúnmente conocidos como Drones.  Estos vehículos son aeronaves, sin un piloto humano a bordo que funcionan de forma autónoma o teledirigidas. Esta tecnología fue desarrollada a finales del siglo XX  por los militares y se ha ido usando en distintas guerras como las de Bosnia, Irak, Afganistán y Libia. Si bien, hasta hace poco, el acceso de las personas, organizaciones y de las empresas a la misma sólo era posible a través de una gran inversión en la adquisición de la tecnología.
.
.
En la actualidad, está empezando a sufrir una eclosión gracias a los distintos usos que se les está dando en el ámbito civil. Otros de los factores que ha provocado su rápido desarrollo, ha sido la paulatina disminución de costes de los equipos y la popularización en ciertos entornos colaborativos de háztelo tu mismo (DIY).
Un punto de inflexión para el sector ha sido la publicación de Real Decreto-ley 8/2014 el 4 de julio. Esta normativa no es definitiva e irá sufriendo cambios, pero posibilita marcar las bases sobre las que se podrá desarrollar las distintas actividades relacionadas con los drones, que hasta la fecha no estaban reguladas.
Ante esta situación, la Viceconsejería de Formación Profesional del Gobierno Vasco ha encomendado al centro de formación IEFPS Don Bosco acercar esta tecnología a la sociedad, mediante el Proyecto Educativo: Montaje, mantenimiento y desarrollo de tecnologías de drones.

.
.
Teniendo en cuenta lo mencionado, el objetivo es crear y transmitir la formación para que el sistema educativo, pueda formar profesionales cualificados capacitados en los drones. Esta capacitación irá desde la de pilotar, mantener, montar, reparar y desarrollar nuevas funcionalidades al robot apoyándose en los distintos Ikaslab que hay en los centros educativos.

Aunque usaremos varios medios para transmitir la evolución y los distintos resultados que vayamos obteniendo, principalmente la información la difundiremos en el Blog y mediante Twitter.
Robot «Cuadrúpedo AI» controlado por Android

Robot «Cuadrúpedo AI» controlado por Android

¿Que es un robot?

Un robot es un dispositivo electrónico y generalmente mecánico capaz de desempeñar tareas automáticamente, ya sea por medio de supervisión humana directa, a través de un programa predefinido o siguiendo un conjunto de reglas generales establecidas. Existen multitud de robots diseñados para cumplir diferentes objetivos: como brazos robóticos para el montaje de piezas en una fábrica, vehículos aéreos no tripulados o los robots móviles terrestres.

El “cuadrúpedo AI” nace de la idea de dos alumnos con ganas de hacer un proyecto visual, no nos valía un proyecto estanco, que no se moviese, que no llamase la atención, y ahí, aparece el Cuadrúpedo.

El robot esta construido con piezas de plástico, ABS o PLA. Nos decantamos por las piezas de plástico por la sencillez que nos ofrecían las impresoras 3D para crear piezas. Aparte las piezas de plástico son de gran ligereza y lo suficientemente robustas para la estructura del cuadrúpedo. Las piezas de plástico están impresas en las impresoras 3D del ikaslab, gracias a Tumaker.

Las uniones son los servos FUTABA S3003. Estos servos únicamente tienen tres conexiones, alimentación (5v) , masa y control Estos van unidos a las piezas de plástico con tornillos como se puede ver en la siguiente imagen:

Para las patas se corto goma con intención de que no se resbalase por el pavimento, sin esa goma el movimiento del cuadrúpedo habría quedado mermado en exceso. Al principio tuvimos problemas con esto, pensamos que sin goma los movimientos serian naturales y andaría normal, pero resulto que no, se resbalaba y se quedaba en el sitio sin avanzar. Para ello cortamos un trozo de goma y lo pegamos con loctite al ABS de la pata.

Una vez recopiladas todas las piezas el robot queda montado tal que así, únicamente el chasis sin nada de electrónica.

Mientras uno de los componentes del equipo iba montando el esqueleto del robot, el otro iba haciendo los esquemas en Isis y viendo el funcionamiento de este. Para el esquema se utilizo el Arduino Uno puesto que no encontramos la opción de sacar el Mega. El Isis nos proporciono una idea general de como iba a ser el proyecto pero muy virtual y de forma visual.

Para el proyecto se ha utilizado el Arduino mega 2560, principalmente por las salidas PWM de las cuales dispone. El cuadrúpedo esta formado por 9 motores,y esta placa nos los admitía. Ya que con el arduino UNO que habíamos pensado en un principio no tenia tantas salidas PWM para todos los motores.

Una vez teniamos la placa decidimos crear un escudo «shield» para el Mega, para tratar de manipular menos posible la placa de aprendizaje. Intentamos buscar esa Shield por internet pero no dimos con ella, por lo que en Ares nos dispusimos a diseñarla.
Como se ve en la siguiente imagen esta el archivo del diseño en Ares:

Una vez montada la electronica y formado el cuadrupedo nos dispusimos a hacer la parte logica del proyecto, La aplicacion que la controlaria y el codigo para los motores y el ultrasonico.

La tecnología principal de este proyecto es el Bluetooth. Nos decantamos por el bluetooth puesto que necesitábamos algo que no llevase cables y fuese inalámbrico, otro de los factores claves del bluetooth es su simplicidad y la facilidad que Internet ofrece a esta tecnología.

El cuadrúpedo se controla con el móvil mediante un modulo Bluetooth y con un programa creado y diseñado con la aplicación App inventor. El App inventor es una plataforma online para preparar programas, se programa mediante una forma visual y no en código.

Una vez creado el programa App inventor se procederá a su descarga, se nos bajara un archivo .apk  y lo pasaremos al dispositivo Android, únicamente solo con que ejecutemos ese apk se nos instala Nos aparecerá así en nuestro móvil:

La interfaz creada sera tal que asi y se vera de esta forma sencilla:

En el vídeo se observa el programa, y dependiendo los botones que se pulsen el  cuadrúpedo reaccionará de una manera u otra. El programa de Android esta formado por diferentes botones que se explican en el video, excepto dos botones, reset y stop. La primera función es que se quede en el suelo con las piernas abiertas, y stop, es un modo en el que el cuadrúpedo queda apoyado con las cuatro patas pero de forma relajada.

Dispone de un modulo ultrasónico HC-SR04 que permite al cuadrúpedo andar de forma libre, en modo solitario, pero cuando se encuentra con un objeto delante de el, esquivarlo de manera natural para poder seguir andando y moviéndose por el entorno que le rodea.

Según el programa cuando el ultrasónico detecta algún obstáculo a menos de 30cm el cuadrúpedo se dirige hacia atrás.

En el vídeo anterior se observa el programa Android, explicando brevemente lo que ocurre al pulsar los diferentes botones que forman el programa, con su correspondiente reacción del cuadrúpedo.

Como anexo os adjuntamos el programa que hemos utilizado:

#include <Servo.h>
Servo myservoA;  // create servo object to control a servo
Servo myservoB;
Servo myservoC;
Servo myservoD;
Servo myservoE;
Servo myservoF;
Servo myservoG;
Servo myservoH;
Servo myservoQ;
long medir1;
long medir2;
long medir3;
int TrigPin = 12;
int EchoPin = 13;
int A = 90;  //A – Cadera 1
int B = 90;  //B – Cadera 3
int C = 90;  //C – Cadera 5
int D = 90;  //D – Cadera 7
int E = 90;  //E – Pie 2
int F = 90;  //F – Pie 4
int G = 90;  //G – Pie 6
int H = 90;  //H – Pie 8
int Q = 90;
int incomingByte = 0;
#include <SoftwareSerial.h>
SoftwareSerial mySerial(19, 18); // RX, TX
void setup()
{
   // Open serial communications and wait for port to open:
  Serial.begin(9600);
  pinMode(TrigPin,OUTPUT);
  pinMode(EchoPin,INPUT);
  Serial.println(«Hello «);
  Serial.println(«attaching to port_b»);
  myservoA.attach(9);  // attaches the servo on pin 9 to the servo object
  myservoB.attach(8);  // attaches the servo on pin 9 to the servo object
  myservoC.attach(6);  // attaches the servo on pin 9 to the servo object
  myservoD.attach(7);  // attaches the servo on pin 9 to the servo object
  myservoE.attach(2);  // attaches the servo on pin 9 to the servo object
  myservoF.attach(3);  // attaches the servo on pin 9 to the servo object
  myservoG.attach(4);  // attaches the servo on pin 9 to the servo object
  myservoH.attach(5);  // attaches the servo on pin 9 to the servo object
  myservoQ.attach(11);
}
void loop()
{
  long distance;
  distance=medir();
  Serial.print(  medir() );//Serial display distance
  //Serial.print(«cm»);
  Serial.println();
  //delay(1000);
  if (Serial.available() > 0)
  {
    incomingByte = Serial.read();
    Serial.print(«He recibido:»);
    Serial.println(incomingByte,DEC);
  }
 if (incomingByte==0)
  {
    Serial.print(medir());//Serial display distance
    Serial.print(«dm»);
    Serial.println();
  // delay(500);
  }
  if(medir() ==0)
  {
    if (Serial.available() > 0) {
    incomingByte = Serial.read();
    Serial.print(«He recibido:»);
    Serial.println(incomingByte,DEC);
    // delay(500);
    }
  }
if((medir()<80) &( medir()>=30))
{
   cycle_Stop();
   Serial.println();
   cycle_girar();
   Serial.println();
   Serial.print(  medir2);
   Serial.print(«d2mD»);
   Serial.println();
   Serial.print(  medir3);
   Serial.print(«d3mD»);
   Serial.println();
   //delay(1000);
}
   while((medir2>=medir3)&(medir()<80) &( medir()>=30)&(incomingByte==55))
  {
    cycle_Derecha();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print(  medir());//Serial display distance
    Serial.print(«d1mD»);
    Serial.println();
    Serial.print(  medir2);
    Serial.print(«d2mD»);
    Serial.println();
    Serial.print(  medir3);
    Serial.print(«d3mD»);
    Serial.println();
   // delay(2000);
  }
   while((medir2<medir3)&(medir()<80) &( medir()>=30)&(incomingByte==55))
  {
    cycle_Izquierda();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print(  medir());//Serial display distance
    Serial.print(«d1mZ»);
    Serial.println();
    Serial.print(  medir2);
    Serial.print(«d1mZ»);
    Serial.println();
    Serial.print(  medir3);
    Serial.print(«d1mZ»);
    Serial.println();
    //delay(2000);
  }
 if (( medir()<30 )&(incomingByte==55))
  {
    while (( medir()<60 )&(incomingByte==55))
    {
    cycle_Atras();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print( medir() );//Serial display distance
    Serial.print(«d0m»);
    Serial.println();
   // delay(1000);
    }
  }
    while((medir() >=80)&(incomingByte==55))
  {
    cycle_Avance();
    distance=medir();
    Serial.print(medir());//Serial display distance
    Serial.print(«d2m»);
    Serial.println();
    //delay(3000);
    if (Serial.available() > 0 )
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
                       
    }                   
   }
  
   while (incomingByte==50)
   {
     cycle_Avance();
       if (Serial.available() > 0) {
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
       }
     
   }
  
 
     while (incomingByte==53){
      cycle_Stop();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
     
    }
  while (incomingByte==49){
      cycle_Atras();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
     
    }
   
     while (incomingByte==56){
      cycle_Derecha();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
       
    }
   while (incomingByte==52){
      cycle_Izquierda();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
   while (incomingByte==48){
      cycle_Reset();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
     while (incomingByte==54){
      cycle_Avance2();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
}
void   cycle_Avance(){
   for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(200);     // in steps of 10 degree
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(150);
    myservoC.write(90);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                                
    
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(200);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(30);
    myservoB.write(90);
    myservoC.write(150);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Avance»);
  }
void cycle_Stop(){
   myservoE.write( 0);
    myservoH.write(180);
    myservoF.write(0);
    myservoG.write(0);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
    //delay(1000);
    Serial.print(«Stop»);
  }
void cycle_Reset(){
    for(A = 90; A < 150; A += 1)  // goes from 30 degrees to 150 degrees
  {                           // in steps of 10 degree
  
    myservoE.write( 90);
    myservoH.write(90);
    myservoF.write(90);
    myservoG.write(90);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
   
    delay(20);    
                      // waits 15ms for the servo to reach the position
  }
 for(A = 150; A>=91; A-=1)     // goes from 150 degrees to 30 degrees
  {                              
    myservoF.write(90);
    myservoG.write(90);
    myservoE.write(90);
    myservoH.write(90);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
   
    delay(20);   
                      // waits 15ms for the servo to reach the position
  }
}
void   cycle_Atras(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(0);
    myservoH.write( 180);
    myservoF.write(40);
    myservoG.write(40);
    delay(200);     // in steps of 10 degree
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(150);
    myservoC.write(90);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                                
    
    myservoF.write(0);
    myservoG.write(0);
    myservoE.write(40);
    myservoH.write(140);
      delay(200);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(30);
    myservoB.write(90);
    myservoC.write(150);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Atras»);
}
void   cycle_Avance2(){
   for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(150);     // in steps of 10 degree
    myservoA.write(60);              // tell servo to go to position in variable ‘A’
    myservoD.write(120);
    myservoB.write(120);
    myservoC.write(60);
    delay(150);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(180);
    myservoA.write(120);              // tell servo to go to position in variable ‘A’
    myservoD.write(60);
    myservoB.write(60);
    myservoC.write(120);   
    delay(180);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Avance»);
  }
void   cycle_Izquierda(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  {
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(180);     // in steps of 10 degree
    myservoA.write(60);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
    delay(180);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(150);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(60);
    myservoB.write(90);
    myservoC.write(150);   
    delay(150);             // waits 15ms for the servo to reach the position
  }
    Serial.print(«Izquierda»);
}
void  cycle_Derecha(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  {
    myservoE.write(0);
    myservoH.write( 180);
    myservoF.write(40);
    myservoG.write(40);
    delay(200);     // in steps of 10 degree
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(120);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                               
    
    myservoF.write(0);
    myservoG.write(0);
    myservoE.write(40);
    myservoH.write(140);
      delay(200);
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(120);
    myservoC.write(90);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«derecha»);
}
long medir(void)
{
  
  long dist,duration;
  digitalWrite(TrigPin,HIGH);//TrigPin prepare high of more than 10us
  delayMicroseconds(11);
  digitalWrite(TrigPin,LOW);
  duration = pulseIn(EchoPin, HIGH);//EchoPin received high start counting until the receiver to the low,return to the count valu
  dist = duration/29/2;//Calculating the distance  cm
                           // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  return dist;
}
void cycle_girar(){
  
  myservoQ.write(0);   //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir2=medir();
  delay(200);        //Retardo entre coordenadas
  myservoQ.write(90);  //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir1=medir();
  delay(200);  //Retardo entre coordenadas
  myservoQ.write(179); //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir3=medir();
  delay(200);        //Retardo entre coordenadas
  myservoQ.write(90);  //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
   Serial.print(«girar»);

 

  }