Pitfinder

 Título de la Entrada : Pitfinder

Autor: Martin Berkhoff Jerez

Competencia (Nivel):

     Ciencias de la ingenieria 

Palabras clave: archivo, arreglo.

Descripción de la actividad:

Un robot recorre la meseta de una montaña, y su misión es detectar las alturas de los precipicios de ésta, información que servirá para escaladores, paracaidistas, deportes extremos en genera

• La meseta de la montaña estará dada por la mesa de competición sin paredes.
• Cada vez que el robot detecte el fin de la mesa, deberá detenerse, y medir la altura del “precipicio”. Este dato será registrado y guardado en un ARRAY de enteros.
• Después de medir, debe (al azar) buscar otro borde de la mesa, y realizar la misma operación.
• El robot finaliza su trabajo de búsqueda cuando registró la medición del 4to “precipicio”.
• Finalizada la búsqueda genera un reporte que guardará en un archivo (WriteLnString)

Estrategia de trabajo

 Presentada la actividad, divisamos que la principal complejidad se encuentra en el almacenamiento de un arreglo en un archivo, haciendo uso de punteros. Si bien la implementación de arreglos no resulta ser la primera vez, se debe estudiar el como asignar los valores a este.

. En la busqueda de aclarar la implementación de un archivo, tanto su creación como escritura y lectura, dimos con varios manuales, en donde mediante ejemplos, se explicaba el uso de esta instrucción. Al ser esta actividad una de las más complejas de abordar decidimos dilatar la creación de código, hasta tener el resto de la actividad completa.
. 
Aplicando Subrutinas realizamos el pseudocódigo de la búsqueda de Pit y el almacenaje de las mediciones hechas por el sensor de ultrasonido.
. 
Una vez abordado el resto de tareas, guiandonos por ejemplos dimos con la creación de una subrutina capaz de crear un archivo en donde se almacenaran los datos del arreglo y posteriormente creamos una subrutina que pudiera mostrar por pantalla los datos del archivo.

El pseudocódigo es el siguiente:

Subrutina Mide()
{
. . . Almacenar en Arreglo valor del SensorUS
. . . Retroceder
. . . Giro Aleatorio
}

Subrutina TraspasaArchivo()
{
. . . Crear Archivo "profundidad.txt"
. . . Escribe linea "Rep. PitFinder"
. . . Escribe linea "------------------"
. . . Escribe linea "Precipicio ", NumeroPrecipicio, ValorArreglo
. . . Cierra Archivo
}

Subrutina MuestraArchivo()
{
. . . Abrir Archivo "Profundidad.txt"
. . . Recorrer Archivo
. . . {
. . . . . . Leer Linea Puntero
. . . . . . Mostrar Linea
. . . }
}

Tarea Main()
{
. . . Mientras(i<4)
. . . {
. . . . . . Avanza
. . . . . . Si SensorUS > Suelo
. . . . . . {
. . . . . . . . . Apaga Motores
. . . . . . . . . Mide()
. . . . . . }
. . . }
. . . TraspasaArchivo()
. . . MuestraArchivo()
}

Una ves terminado eso, espesamos a implementar la programación en NXC quedando finalmente así:

Código fuente:

int Prof[4];  //Arreglo para almacenar dato
int i=0;
int j=0;
int k=0;   //i,j,k variables usadas para el arreglo y almacenamiento.
int l=6;  //permite mostrar 6 lineas del archivo.
int gr=0;  //usada para giro random
#define SUELO 20  //definido como la distancia máxima entre el sensor y suelo antes de considerar un pit.

sub Mide()
{
     Prof[i] = SensorUS(IN_2); //profundidad almacenada en arreglo
     i++;
     OnRev(OUT_AC,40);
     Wait(800);  //retrocede 
     gr=Random(500)+200;
     OnFwd(OUT_A,75);
     Wait(gr);
     OnRev(OUT_C,75);
     Wait(gr);
} // subrutina que calcula y almacena la profundidad

sub TraspasaArchivo()
{
    byte fileHandle;
    short fileSize;
    short bytesWritten;
    string read;
    string write;
    DeleteFile("Profundidad.txt"); //para borrar el archivo si es que fue creado antes
    CreateFile("Profundidad.txt", 512, fileHandle); //creación de archivo
    WriteLnString(fileHandle,"REP. PITFINDER", bytesWritten); //escribe una linea al archivo
    WriteLnString(fileHandle,"--------------", bytesWritten);
    for(j=0; j<i; j++ )
    {
        string tmp = NumToStr(Prof[j]);
        string numprecipicio = NumToStr(j+1);
        write = StrCat("Precip. ",numprecipicio, ">", tmp ,"cm");
        WriteLnString(fileHandle,write, bytesWritten);
    } //recorre el arreglo y lo almacena en un archivo
    CloseFile(fileHandle);
} //usada para almacenar el arreglo en un archivo

sub MuestraArchivo()
{
    byte fileHandle2;
    short fileSize2;
    short bytesWritten2;
    string texto;
    OpenFileRead("Profundidad.txt", fileHandle2, bytesWritten2);
    for(k=0; k<6; k++)
    {
        ReadLnString(bytesWritten2, texto);
        TextOut(0,l*10,texto);
        l--;
    }//escribe de arriba hacia abajo 
    Wait(4000); //tiempo por el cual se muestra el archivo.
}

task main()
{
     SetSensorLowspeed(IN_2);
     while(i<4)
     {
               OnFwd(OUT_AC, 40);

               if  (SensorUS(IN_2) > SUELO) //si el sensor recibe una distancia mayor a suelo
               {
                   Off(OUT_AC);
                   Mide();
               }
     }
     TraspasaArchivo();
     Off(OUT_AC);
     MuestraArchivo();
}

El video de la actividad :

Reflexión 

El armado de el robot fue sencillo, porque este solo tenia que tener el armado básico mas un sensor ultrasonido para medir las distancias. Por eso no hubieron mayores inconvenientes al realizar el armado de el robot.

Con respecto al código, en un principio nos costo un poco generar de buena manera el archivo, por un tema de poca costumbre ya que era algo relativamente nuevo para nosotros. Pero finalmente generamos bien el archivo siendo esto una tarea que tampoco dio mayor complejidad.

En términos generales fue una actividad bastante sencilla aprendimos bastante, como guardar todos los datos en el arreglo mostrarlos luego en el archivo etc.