jueves, 29 de septiembre de 2011

Gestión en TI (Robot Patrulla NXC

Autor: Rodrigo Andres Soto Parra
Competencia: Gestion En tecnologias de la informacion.


Descripcion de la actividad

El robot debe recorrer esta area utilizando el sensor de luz para seguir el circuito perfectamente, es asi como a la vez esta usando el sensor de sonido, ya que cada vez que este registre un sonido mayor a 40 decibeles, el robot ira mostrando en pantalla un nivel de alerta nivel de energia y uno de intentos de robos.
En términos prácticos, ya que no se cuenta con un robot (ni un recinto de esta índole) a escala real, con ayuda de nuestro robot NXT, debimos simular esta actividad en la mesa de competición preparada para la ocasión.

Modelo de solución
            La forma que utilizamos es similar a al informe anterior ya que utilizamos una solución estable al problema fue  asignándole una función a cada de  integrante en lo que mejor se desempañaban.
            Junto con ello se planificaron las instrucciones que debía seguir el robot El código fue aportado por cada uno de nosotros ya que fue dividido en sub rutinas, debíamos dividirnos el trabajo y después llegar con el a probarlo en el “ladrillo”. Este trabajo estuvo dividido por la siguientes sub rutinas “Modo Patrulla”, “Modo Guardián” y “Modo de Ataque”.
También en esta nueva actividad se planteo un nuevo desafío, el uso de adecuadamente de WHILE y SUB, es decir utilizando el while es para que repita un ciclo hasta que ocurra una devida instrucción por ejemplo: hacer el modo patrulla hasta que se registren un numero de alerta mayo a 100 y asi pasara a la siguiente sub rutina esto ocurre y no terminara nunca hasta que se page manuelamente ya que en el ultimo modo este queda atacando a un hasta apagarlo.
Es asi como utilizando el WHILE y las SUB rutinas podríamos llegar a la solución del problema y no complicarnos tanto. Es por esto que se tuvo que investigar el modo de desarrollar este nuevo comando, ya que gran parte de la solución al problema era  el uso de este.

Pseudocódigo actividad “Robot Patrulla”.

Sub rutina Modo_Patrulla()
     {
    Avanzar;
    Hacer Siempre;
         Si(color Blanco)
              {
              Gira hacia la izquierda;
              }
         Si(Sonido)
              {
               Sirena;
               Sumar robos;
               Mostrar en pantalla la cantidad de intentos de robos;
               Dar un valor aleatorio entre 20 y 50;
               Acumular el valor aleatorio como nivel de alerta;
               Mostrar en pantalla el nivel de alerta;
               Dar un segundo valor aleatorio entre 50 y 60;
               Restar el valor aleatorio al nivel de energía;
               Mostrar en pantalla l nivel de energía restante;
               }
      }
Sub rutina Modo_Guardian ()
      {
      Girar a media potencia;
      Hacer siempre;
           Si(Sonido)
              {
              Restar el valor aleatorio al nivel de energía;
              Mostrar en pantalla el nivel de energía restante;
              }
     }
Sub rutina Modo_Ataque ()
      {
      Apagar motores;
            Si(Objeto cerca)
               {
               Avanzar a todapotencia;
               Hacer por un segundo;
               Retroceder a la misma potencia;
               Hacer por un segundo;
               }
    }
Inicio de tarea ()
     {
     Activar sensor táctil (IN_1);
     Activar sensor de sonido (IN_2);
     Activar sensor de distancia (IN_3);
     Activar sensor de luz (IN_4);
     Mientras (energía >0)
        {
        Modo_Patrulla();
               Si (alerta>=100)
                   {
                    Entrar al círculo
                    }
       Mientras (alerta>100 y Energia>0)
          {
          Modo_Guardian();
      Mientras (Energia<=0)
          {
           Modo_Ataque();
          }
      }
   }
}

Codigo Del Ejercicio “Robot Patrulla”.

int Robo=0;
int Alerta=0;
int Alerta2;
int Energia=500;
int Energia2;
#define UMBRAL 40
#define SONIDO 80
#define ENERGIA 500
#define CERCA 10
sub Modo_Patrulla()                           //primera sub rutina.
      {
      OnFwd(OUT_BC,70);                    //avanzar hacer siempre.
            if (Sensor(IN_4) >UMBRAL)   //el sensor de luz detecta el color blanco.
              {
              OnFwd(OUT_B,50);             //giro hacia la izquierda hasta que vuelva a detectar el color negro.
              OnRev(OUT_C,50);
             }
         if (Sensor(IN_2) >SONIDO) //el sensor de sonido detecta el sonido.
             {
             Off(OUT_BC);                  //detenemos el robot.
            PlayTone(865,400);          //sirena.
            Wait(400) ;
            PlayTone(100,400);
            Wait(400) ;
            PlayTone(865,400);
            Wait(400) ;
            PlayTone(100,400);
            Wait(400) ;
            Robo++;                                                      //registar y va sumando las veces de robo.
                TextOut(0,60,"intentos de robo:");           //muestra en pantalla el intento de robo.
                     NumOut(0,50,Robo);
           Alerta2=Random(20)+30;                             //valor aleatorio entre 20 y 50.
                 Alerta=Alerta+Alerta2;                           //acumulador de alerta.
                     TextOut(0,40,"nivel de alerta:");
                        NumOut(0,30,Alerta);                      //muestra en pantalla el nivel de alerta.
           Energia2=Random(50)+10; //valor aleatori entre 50 y 60.
                 Energia=Energia-Energia2; //acumulador de energia(resta).
                      TextOut(0,20,"Energia restante:");
                         NumOut(0,10,Energia); //muestra en pantalla la energia restante.
             }
     }
sub Modo_Guardian()                       //segunda sub rutina.
     {
     OnRev(OUT_C,50);                      //girar hacia la izquierda a media potencia, hacer siempre.
     OnFwd(OUT_B,50);
        if (Sensor(IN_2) >SONIDO)       //Sensor detecta sonido.
             {
             Energia2=Random(50)+10;
                 Energia=Energia-Energia2;               //Resta el valor aleatorio al la energia.
                     TextOut(0,20,"Energia restante:");
                          NumOut(0,10,Energia);            //muestra en pantalla la energia restante.
            }
     }
sub Modo_Ataque()                           //tercera sub rutina.
      {
      Off(OUT_BC);                               //apagar motores.
         if(SensorUS(IN_3)<=CERCA)     //Si el sensor detecta un objeto cerca.
           {
           OnFwd(OUT_BC,100);             //avanzar a toda potencia.
          Wait(1000);
          OnRev(OUT_BC,100);              //Retroceder a toda potencia.
          Wait(1000);
           }
       }
task main()
  {
  SetSensorTouch(IN_1);            //sensor touch.
  SetSensorSound(IN_2);            //sensor de sonido.
  SetSensorLowspeed(IN_3);      //sensor de distancia.
  SetSensorLight(IN_4);              //sensor de luz.
  while (Energia>0)                   // mientras la energia sea menor a "0"
      {
      Modo_Patrulla();
         if(alerta>=100)                 //si la alerata es igual o mayor a 100
           {
           OnRev(OUT_C,70);         //entra al circulo
           OnFwd(OUT_B,70);
           Wait(200);
           OnFwd(OUT_BC,70);
           Wait(1000);
           }
  while (alerta>=100 && Energia>0)
       {
       Modo_Guardian();           //segunda sebrutina,
  while (Energia<=0)              //mientras la Energia es menor o igual a 0
      {
       Modo_Ataque();              //tercera dubrutina,
       }// del ultimo while
     } //del segundo while
  } //del primer while.
} //del main.

Video

 

Mi primer programa en nxc

Autor: Rodrigo Andres Soto Parra.
Competencia: Desarrollo de Software (Nivel 1).

Descripcion de la actividad


Circuito simple programando el robots NXT

Este circuito simple y a la vez la programación del robots es fundamental a la hora de poner en práctica nuestras habilidades de programación, mi rol en el grupo fue más que nada armar el robots, calibrar las ruedas delanteras y rueda timón (ya que estaban sueltas las ruedas y doblaba hacia un lado. Cuando nuestro grupo se juntaba era siempre para algo específico por EJ: nos juntábamos un dia para programar, otro día para ponerlo en práctica.

      El Trabajo en  el laboratorio fue muy grato ya que por grupo se creaba un espacio para trabajar en una mesa y así facilitar el armado del robots. El armado fue un poco complejo ya que ensamblar pieza por pieza era algo un poco enredado, sin embargo el día que armamos el robots el profesor que estaba a cargo nos felicito ya que habíamos terminado el robots por completo en una sola clase. La siguiente clase teníamos que programar el robots para que hiciera un circuito que se asimilara a la de un “tren” haciendo un tour por un parque de diversiones, esta parte del trabajo fue muy divertida ya que teníamos que sacar cuentas de cuantos segundos se demoraba por estación (“esto será demostrado en el video que grabamos mientras recorría el circuito”)y los segundos que necesitaba para doblar en cada esquina.
Pseudocódigo 
Las instrucciones en el robot se programan mediante una serie de “códigos”, por esto primero se realiza la programación mediante un pseudocódigo, es decir escribir y describir las instrucciones  de lo que se va a programar mediante el “lenguaje humano” en un borrador y luego traspasarlas al robot mediante el lenguaje de programación NXC.

Aquí se presenta el pseudocódigo del programa “Robot turista”
Encender los motores;
            Avanzar 5,3 segundos hasta la primera estación; ;
            Detenerse  por 2,0 s.;
            Avanzar 1,2 s.;
            Girar hacia la izquierda durante 0,3 s.; // la idea es que en 0,3 s. gire en 90º
            Avanzar  2,05 s.;
            Detenerse en la segunda estación durante 2,0 s.;
            Girar hacia la izquierda durante 0,6 s.; // la idea es que  en 0,6 gire un poco mas de 90º
            Avanzar durante 3,5 s.;
           Girar hacia la derecha durante 0,13 s.; //  en 0,13 s. gire 45º aprox.
            Avanzar 1,2 s.;
            Girar hacia la izquierda durante 0,12 s.; //en 0,12 s. gire 45º grados
           Avanzar 2,7 s;
Detenerse en la tercera estación durante 2,0 s.
Girar hacia la izquierda durante 0,5 s.; // en 0,5. s. gire 90º
Avanzar 1,2 s.;
Gira hacia la izquierda durante 0,6 s; //aquí llega al inicio y en 0,6 s. gire 90º
Como la actividad propone realizar dos veces el recorrido se repite todo lo anterior.


Código del programa
Luego de realizar el pseudocódigo se realiza el traspaso  al lenguaje de programación NXC.
 He aquí presente el código NXC completo del programa “Robot turista”:

task main()
    {
       repeat(2) // hace el recorrido 2 veces.
      {
         OnFwd(OUT_BC, 75); //Avance recto
         Wait(5300);
         Off (OUT_BC);
         Wait (2000);       // Estacion Nº 1.
         OnFwd(OUT_BC, 75); // Avance recto
         Wait (1200);
         OnRev(OUT_C, 75);  //Giro Nº 1 hacia la izquierda.
         Wait (310);        
         OnFwd(OUT_C, 75);  //Avance recto
         Wait (2050);
         Off (OUT_BC);
         Wait (2000);       //Estacion Nº 2
         OnRev(OUT_C, 75);  // Giro Nº2 hacia la izquierda.
         Wait (600);       
         OnFwd(OUT_BC, 75); // Avance recto
         Wait (3500);
         OnRev(OUT_B, 75);  // Giro Nº3 hacia la derecha.
         Wait (130);
         OnFwd(OUT_B, 75);  //Avance recto
         Wait (1200);
         OnRev(OUT_C, 75);  //Giro Nº4 hacia la izquierda.
         Wait (120);
         OnFwd(OUT_C, 75);  //Avance recto
         Wait (2700);
         Off (OUT_BC);      //Estacion N°3
         Wait (2000);
         OnFwd (OUT_B, 75); //Giro Nº5 hacia la izquierda.
         Wait (500);
         OnFwd (OUT_BC, 75); //Avance recto
         Wait (1200);
         OnRev(OUT_B, 75);  //Giro Nº3 hacia la izquierda.
         Wait(600);         //Final e inicio.  
      }
      Off(OUT_BC);          // apagado de motores.
}                           // Fin de la programación y fin del tour.
 
A continuación les dejare el link del video en donde el robots hace el circuito del “parque de diversiones”