sábado, 8 de octubre de 2011

Robot Patrullero

Autor: Felipe Andres Lagos Morapasten
Competencia: Desarrollo de Software (Nivel 1)
Palabras Clave: Programación de Robot,NXC, Robótica,Kit Lego.

Descripción de la Actividad
Quiero compartirles con ustedes mi grata experiencia, como estudiante de informática, correspondiente a la actividad número 4 del Curso de Robótica, donde se tuvo que realizar un codigo fuente en NXC.
El problema consistió en hacer que el robot sea capaz de convertirse en patrullero, velando por la seguridad de una casa, recorriendo alrededor de ella, donde cada sonido es señal de que el peligro se aumenta y debe ser superior la preocupación de vigilancia hacia la casa, al momento de tener una alta vigilancia por los sonidos, el robot embiste al objetivo.

Solución

  Lo primero que se debe realizar, analizar para que esta actividad se simplifique y facilite llegar a un buen resultado es la realización del pseudocódigo, para luego hacer el código fuente en el lenguaje NXC.

Nivel de alerta =0
Energía restante = 500
Intentos de robo =0
Modo patrulla
  Mientras (el nivel de alerta sea menor que 100)
     {
         mostrar texto
         {  Mostrar en la pantalla nivel de alerta
            mostrar en la pantalla energía restante
            mostrar en la pantalla intentos de robo    }
       Si el (sensor de luz detecta blanco)
          {Girar levemente hacia el circulo negro}
       Sino
          {Avanzar}
       Si (el sensor de sonido detecta un ruido)
          { Detener el robot
            Tocar la sirena
              {reproducir un sonido  }
           Sumar uno a los intentos de robo
           Restar a energía restante un valor al azar entre 50 y 60
           Sumar a nivel de alerta un valor al azar entre 20 y 50
           }
   }
Modo Guardián
Cuando (el nivel de alerta supere 100 y la energía restante sea positiva entrar modo guardián)
    {
          Mostrar texto
        { Mostrar en la pantalla nivel de alerta
          Mostrar en la pantalla energía restante
          Mostrar en la pantalla intentos de robo}
     Si (el nivel de alerta es mayor que 100)
       { Entrar en el círculo
        Girar sobre su eje a potencia media    }
     Si (el sensor de sonido detecta un ruido)
        { Sumar uno a los intentos de robo
          Restar a energía restante un valor al azar entre 50 y 60
          Sumar a nivel de alerta un valor al azar entre 20 y 50}
   }
Modo Ataque
Cuando (la energía restante es menor o igual que 0)
     {
         Si (El robot detecta algo enfrente suyo a menos de 10 cm)
              {Embestirlo durante un segundo a máxima potencia
               Retroceder a máxima potencia durante un segundo}
      }

El código fuente del programa en NXC es el siguiente: 

int nivel_alerta=0;  // El nivel de alerta es importante para cambiar entre los 3 modos
int energia_res=500; // Energía que le queda al robot por cada intento de robo disminuye
int intentos_robos=0;// Cada sonido representa un intento.

#define UMBRAL 40//  Rango de luz para considerar que es blanco
#define UMBRAL_SONIDO 60 // Se usa para considerar el sonido con el Sensor.
#define MIC // Activación del microfono para el Sensor.
#define DISTANCIA 10 // Medida en cm, usado para que el Sensor detecte.
 
sub texto()      // Muestra en pantalla los intentos de robo, nivel de alerta y energia restante con sus respectivos valores.

{TextOut(0,40,"Int. de robos");
NumOut (85,40,intentos_robos);
TextOut(0,60,"Nv de alerta " );
NumOut (80,60,nivel_alerta);
TextOut(0,50,"Energia res");
NumOut (80,50,energia_res); }

sub modo_guardian()

{OnRev(OUT_C, 75);// Las 2 instrucciones permite que se de una vuelta para
  OnFwd(OUT_A, 75);//  posicionar su entrada al ovalo
  Wait(250);
  OnFwd(OUT_AC, 50); // Avanzar
  Wait(1800);
  Off(OUT_AC);// Apaga los motores
  Wait(500);

 
while (nivel_alerta > 100 && energia_res > 0) // Mientras las 2 condiciones se cumplan.
    {if(Sensor(IN_2) > UMBRAL_SONIDO) // Si el sensor de sonido detecta un ruido mayor
                                                                        // que el umbral de sonido  
    {++intentos_robos; // Sumar uno a intentos de robos
        energia_res-=(Random (11)+50); // Resta a energia res un valor entre 50 y 60
        nivel_alerta+=(Random(31)+20); // Suma a nivel de alerta un valor entre 20 y 50}

    texto();  // Muestra el sub modo texto
    OnRev(OUT_C, 50); //  Estas 2 instrucciones hace que gire sobre su eje
    OnFwd(OUT_A, 50);}
    Off(OUT_AC); // Apagar motores}
sub modo_ataque()
while(true)   
  {texto();                                               // Muestra el texto
    Off(OUT_AC);                             // Apagar motores
      if (SensorUS(IN_1) < DISTANCIA) // El sensor funciona si se detecta algo entre la distancia
                                                            // especificada antes
     {++intentos_robos;                 // Sigue la suma en los intentos de robos.
     nivel_alerta+=(Random(31)+20); // el nivel de alerta suma valores entre 20 y 50
    OnFwd(OUT_AC, 100);  // Ir hacia adelante embistiendo
     Wait(1000);
     OnRev(OUT_AC, 100); //  Retroceder
     Wait(1000);
     Off(OUT_AC);  // Apagar motores}  // Cierre del if
    
}  // Cierre del while
     } // Cierre modo ataque

sub sirena()
{PlayTone (1000,100); // Tonos de la sirena
Wait (250);
PlayTone (2000,200);
Wait (250);}


sub modo_patrulla()
{while (nivel_alerta<100) // Mientras el nivel de alerta es menor que 100
 {texto(); // Muestra el sub modo texto
  if (Sensor(IN_3) > UMBRAL) / Si el  sensor de luz detecta un rango mayor que el umbral
  { OnRev(OUT_C, 75);// Al detectar el color blanco se dobla hacia el circulo negro
    Wait(25);}
  else
  { OnFwd(OUT_C, 75); // Si no va hacia adelante
    OnFwd(OUT_A, 80);  }

  if(Sensor(IN_2) > UMBRAL_SONIDO) // Si el sensor de sonido es mayor que el //umbral_sonido
  {  Off (OUT_AC); // Se apaga los motores por 2 segundos
    Wait (2000);
    sirena(); // Hace lo que está dentro del sub modo sirena donde reproduce un tono
    ++intentos_robos;// Esto hace que cada vez que detecte un sonido se le sume uno
                                   // al intento de robo
    energia_res-=(Random (11)+ 50);// Se resta un valor entre 50 y 60 a energia restante
    nivel_alerta+=(Random(31)+20); // Se suma un valor entre 20 y 50 a nivel de alerta
    }     // Cierra if
}    //  Cierra while
}   // Cierra el modo patrulla
 
task main ()

{SetSensorLight(IN_3); // Encender Sensor de Luz

  SetSensorSound(IN_2);// Encender Sensor de Sonido

  SetSensorLowspeed (IN_1);// Encender Sensor de Ultrasonido
  modo_patrulla(); // Llamado del modo patrulla
  modo_guardian(); // Al terminar el modo anterior, se activa este modo
  modo_ataque(); // Luego de terminar el modo guardian pasa a este ultimo 
}
 
En resumidas cuentas en el código existen muchas instrucciones donde se destaca el uso de subrutinas, que marca que la actividad se realice de forma óptima, además de órdenes para avanzar, girar, mostrar en pantalla, emitir sonidos y el uso de variado de los sensores como el de luz, sonido y proximidad.

El video de esta actividad es el siguiente:




Reflexión

   El uso de subrutinas al iniciar me resultó un poco dificultoso ya que mi pensamiento era algo diferente al que se debe tener. Al desarrollar la actividad cambió mi parecer por que debí pensar en todos los casos posibles que relata la actividad, analizando condiciones y cuando deben ocurrir ciertas cosas para hacer el buen uso de las rutinas.

   Te invito a que si tienes dudas o quieres complementar esta actividad mediante opiniones, otras informaciones no tengas miedo de emitir tus comentarios, a participar donde cada comentario hará que se haga más interactivo este espacio.

No hay comentarios:

Publicar un comentario