jueves, 7 de abril de 2011

SIGUE LINEAS ROJA

Hemos abandonado a toppyto y lo hemos cambiado por un simulador llamado gacebo, en la que simularemos como un robot debe seguir una linea roja.

El algoritmo para hacer seguir al robot la linea roja, se basa en la división de la imagen en 3 regiones.
Hemos dividido las regiones de la siguiente manera:
si el ancho total de la imagen son 320 pixels dividiremos los lados en 130 pixels cada uno para tomar el centro con 60 pixels y así tener una buena precisión en el código.

El algoritmo iterativo lo que realiza es lo siguiente:
recogemos la imagen mediante la función:
-cogerImagen1(&image);
despues mediante las funciones detectaRojo: detectaRojoIzq,detectaRojoCent,y detectaRojoDer sabremos hacia adonde tenemos que girar o avanzar. Estas funciónes se han programado fuera de la función navega. DetectaRojo mira en aquella region todos los pixels rojo que vea para luego devolverlos.
Aqui dejamos nuestro cogido de navega.cpp.

int detectaRojIzq(unsigned char *image1)
    {
        int i,j;
        int pixelRojos=0;
        for (i=0;i<240;i++)
            for (j=1;j<130;j++)//[(i*320*3)+j*3]
                if ((image1[(i-1)*320*3+(j-1)*3]>250) &&
                   (image1[(i-1)*320*3+(j-1)*3+1]<50)&&
                   (image1[(i-1)*320*3+(j-1)*3+2]<50))
          
                    pixelRojos++;
        return pixelRojos;
    }
    int detectaRojCent(unsigned char *image1)
    {
        int i,j;
        int pixelRojos=0;
        for (i=0;i<240;i++)
            for (j=130;j<190;j++)
                if ((image1[(i-1)*320*3+(j-1)*3]>250) &&
                   (image1[(i-1)*320*3+(j-1)*3+1]<50)&&
                   (image1[(i-1)*320*3+(j-1)*3+2]<50))
                    pixelRojos++;
        return pixelRojos;
    }
    int detectaRojDer(unsigned char *image1)
    {
        int pixelRojos=0;
        int i,j;
        for (i=0;i<240;i++)
            for (j=190;j<320;j++)
                if ((image1[(i-1)*320*3+(j-1)*3]>250) &&
                   (image1[(i-1)*320*3+(j-1)*3+1]<50)&&
                   (image1[(i-1)*320*3+(j-1)*3+2]<50))
                    pixelRojos++;
        return pixelRojos;
    }
    void Navega::iteracionControl () {
            int i;
        int izq,cent,der;
        // example: how to get pioneer position
        CvPoint3D32f myPoint;
        this->navegacion->cogerPosicion (&myPoint);
        //printf ("encoders: X=%f mm, Y=%f mm, Theta=%f (grados)\n", myPoint.x, myPoint.y, myPoint.z);

        // example: how to get laser readings
        std::vector<float> laser;
        this->navegacion->cogerLaser(&laser);  
        //printf("laser: %f (mm)\n",laser[90]);

        // example: how to get image stream
        unsigned char *image1;
        this->navegacion->cogerImagen1 (&image1);
        izq=detectaRojIzq(image1);
        cent=detectaRojCent(image1);
        der=detectaRojDer(image1);
        if((der>izq)&&(der>cent))
        {
            printf("Gira Derecha\n");
            printf("(IZQ,CENT,DER)=(%d,%d,%d)\n",detectaRojIzq(image1),detectaRojCent(image1),detectaRojDer(image1));
            this->controller->setV(100.); // mm./s.
            this->controller->setW(-10.);
        }
        if((cent>izq)&&(cent>der))
        {
            printf("Centro\n");
            printf("(IZQ,CENT,DER)=(%d,%d,%d)\n",detectaRojIzq(image1),detectaRojCent(image1),detectaRojDer(image1));
            this->controller->setV(100.); // mm./s.
            this->controller->setW(0.);
        }  
        if((izq>cent)&&(izq>der))
        {
            printf("Gira Izquierda\n");
            printf("(IZQ,CENT,DER)=(%d,%d,%d)\n",detectaRojIzq(image1),detectaRojCent(image1),detectaRojDer(image1));
            //giraIzquierad
            this->controller->setV(100.); // mm./s.
            this->controller->setW(+10.);
        }
  

        /* TODO: ADD YOUR ITERATION CODE HERE */  

        CvPoint2D32f destino;
        this->navegacion->cogerDestino (&destino);
        // example of pantilt movement:
        //this->controller->setPT1 (-15.,0.);
        //this->controller->setPT2 (-15.,0.);
    }

Aqui un video de Toppyto virtual:

jueves, 17 de marzo de 2011

Toppyto equilibrista :D :D

Y sin más dilación la práctica en su esplendor, se nos pide hacer que Toppyto se mantenga en equilibrio usando para ello la teoría del equilibrio mecánico.



Usamos la estabilización mediante PID dado en la teoría de clase, la estabilización PID se trata de usar un controlador proporcional, un controlador de la integral y un controlador de la derivada. Hemos tenido que calcular cada fórmual por separado y unirlas para conseguir el resultado óptimo lo que nos llevo más tiempo fue sin duda calibrar perfectamente a Toppyto ajustando las tres constantes (una para cada controlador) de la manera más optima y adaptandola a los pesos de Toppyto consiguiendo que no se mantuviera en pie.



FOTO: vemos como el sensor de luz está muy próximo al suelo.

 La combinación de los 3 controladores que usamos es la siguiente fórmula:



Adaptamos cada constante de cada controlador pues en momentos Toppyto se nos iba más hacia adelante que para atrás... por lo que nos llevo mucho tiempo ajustar pero los resultados fueron satisfactorios, consiguiendo como vereis en este video que Toppyto estuviera en pie 4 minutos!!







Toppyto cambia de aspecto :D :D :D

De nuevo estamos con todos ustedes para seguir contandoles nuestros avances con Toppyto, en esta ocasión se nos pide que Toppyto sea equilibrista es decir que se mantenga en pie con dos ruedas como lo hacemos las personas.
Pues bien antes de llegar al funcionamiento pleno de la práctica tuvimos que adaptar a Toppyto para las nuevas características que se le requería, por lo que tuvimos que cambiar su aspecto:


Y así es como nos quedo Toppyto como obsevais dista mucho del antiguo Toppyto que estaba lleno de cosas, este Toppyto es más sencillo.. más elegante además para que se mantenga bien en equilibrio hemos asujetado todos los cables perfectamente con gomas y así no se mueve nada.


 
Como última observación detallar una foto más de como hemos asujetado a Toppyto el sensor de luz y otra mención especial para decir que si se fijan bien en las fotos verán un papel encima del sensor de luz este papel lo hemos puesto para que no le entre luz de fuera y así Toppyto no falle en su equilibrio :D


miércoles, 9 de marzo de 2011

Comportamiento ir hacia la luz evitando obstáculos

Y finalmente presentamos nuestro último apartado, una vez realizados el apartado uno (comportamiento evitar obstaculos mediante sensores de contacto), dos (comportamiento evitar obstaculos mediante ultrasonidos) y tres (comportamiento ir hacia la luz).




Pues bien en este apartado tenemos que entre mezclar dos comportamientos (luz+ultrasonidos) o bien (luz+contacto), con ellos conseguimos que Toppyto vaya hacia la luz y a la vez pueda evitar los obstaculos que se encuentre con el camino, no ha sido un apartado muy dificil de realizar ya que teniendo los dos comportamientos anteriores perfectamente funcionando este último simplemente había que intercalarlos de manera óptima, el resulta ha sido lo mejor posible y funciona a la perfección.




Mostramos otro video de como Toppyto realiza este ejercicio, hemos usado en el video el sensor de ultrasonidos porque nos parece más espectacular que con el sensor de contacto, aunque funciona con los dos.



Sencillamente para que vaya uno u otro hay que conectar el cable con el sensor de contacto o conectarlo con el sensor de ultrasonidos.

Y ya está hasta aqui todo lo que nos ha aportado esta tercera práctica, sin duda la más dificil de realizar pero la más gratificante a la hora de ver como funcionaba todo :D, sigan atentos a novedades frescas frescas que no tardaremos en mostrarles como siempre ha sido un placer haberles contado todo y volverles a recordar nuestro correo para cualquier duda o sugerencia rbotica2011@gmail,com

Comportamiento ir hacia la luz

En esta ocasión Toppyto debe ir hacia la luz, este apartado no ha resultado demasiado complicado, en primer lugar tenemos que calibrar la luz que hay en el ambiente, es decir, ejecutamos el programa y nos pide calibrar la luz ambiente y despues nos pide calibrar la luz de nuestra linterna.
El programa es muy sencillito nos usamos de dos sensores de luz (RCX), cuando sientes la misma intensidad de luz pues Toppyto sigue de frente, en cambio, cuando siente más intensidad de uno que de otro se desvia hacia el lado en que ha sentido más luz y hasta que no se equilibren (teóricamente) las intensidades de ambas Toppyto no deja de girar hacia el lado de mayor intensidad.



Colocamos los dos sensores de luz en un ángulo de 45º y -45 º en la parte trasera de Toppyto ya que no nos queda mucho más hueco para colocar cosas del Lego, para conseguirlo tuvimos que pensar también un buen poco para ver donde los poníamos.




Y finalmente un video demostración de como Toppyto iba hacia la luz de nuestra linterna en la oscuridad, se observa perfectamente como se orienta constantemente hacia la luz:








Comportamiento de evitación de obstáculos usando el sensor de ultrasonidos

Para este apartado a Toppyto le hemos tenido que incorporar varias novedades entre ellas cabe destacar un motor unido al sensor de ultrasonidos mediante el cual Toppyto se va moviendo en línea recta y realizando giros de 60º con la cabeza de ultrasonidos para un lado y para otro (sería rotar de -60º a 60º).
Ha sido un apartado bastante dificil con muchas comeduras de cabeza, pero finalmente lo hemos conseguido, Toppyto evita obstaculos con el sensor de ultrasonidos.
Toppyto va de frente mirando a su alrededor cuando ve algo se para y analiza el angulo interior y exterior que detecta, una vez conseguido esto Toppyto analiza para que lado debe de irse si puede seguir libremente sin miedo a chocarse o si necesita desviarse un poco a un lado u otro... En la teoría es super fácil de entender su comportamiento pero vuelvo a recalcar la dificultad a la hora de implementarlo, sin duda el apartado más dificil.



Hemos usado varios comportamientos, entre ellos el andar hacia adelante, el girar la cabeza (sensor de ultrasonidos),..., numeros calculos matemáticos hemos usado para su realización con vectores ya que cada medida que coge Toppyto nosotros metemos su valor en un vector (un array), por lo que según cada caso hace algo especifico.



Hasta aqui todos estabamos contentos menos Jaime, en verdad tenía razon con su cabezoneria pero era complicar las cosas pero bien al final tiramos para adelante con su idea, su idea era que una vez realizara el movimiento de evitar obstaculo si en su transcurso veía otro obstaculo también lo evitara y si lo conseguimos y Toppyto realiza perfectamente su labor de evitar obstaculos mediante el sensor de ultrasonidos.



En el video anterior vemos como Toppyto detecta un par de latas y es capaz de evitarlas sin problema alguno y seguir hacia adelante.

Comportamiento de evitación de obstáculos usando sensores de contacto

Este apartado es el más simple de la práctica en el simplemente se nos pide que Toppyto usando los sensores de contacto cuando choque con algo evite el obstaculo para ello cuando choca con algo se echa un poco para atrás y realiza un angulo para un lado, el lado depende del sensor de contacto que choque, si se presiona el sensor de la derecha Toppyto va hacia la izquierda; mientras que si presiona el sensor de la izquierda Toppyto va hacia la derecha.



Hemos realizado dos comportamientos, uno que es de avanzar hasta que se choque con algo que inmediatamente salta otro comportamiento que es de realizar el ángulo (através de un steer).

Tenemos esta situación:




Y en movimiento mediante un video hace lo siguiente:


Y esto ha sido todo del primer apartado, no tardaremos mucho en mostrarles el siguiente apartado mucho más complicado e interesante :D

Comenzando la práctica 3

Hola, hola aquí estamos de nuevo para presentarles las últimas novedades sobre Toppyto, lo primero de todo hay que decir que esta práctica si ha supuesto un verdadero desafío para nosotros ya que por ahora ha sido sin duda la más complicada.
Esto no ha servido más que para motivarnos y lograr conseguir los 4 apartados que se compone esta práctica, hay que resaltar que ha Toppyto le ha crecido el pelo!! Es una forma de expresar que para esta práctica hemos usado más cables que en ninguna otra.
Hemos usado más cables porque en esta ocasión hemos tenido que poner tres motores en funcionamiento y los puertos de los sensores están todos ocupados.. por lo que no hay ningún hueco más!!
Como siempre digo mejor que tanta palabra es mejor ver que hablar.. así que sin más dilación unas fotos del nuevo aspecto de Toppyto!!








martes, 22 de febrero de 2011

Toppyto sigue pared que parece un F1

Este apartado de la práctica sin duda es el que más nos ha costado, debido a la cantidad de cuentas matemáticas que hemos tenido que hacer y perfeccionamiento del código para la perfecta ejecución del sigue pared.



En Toppyto simplemente nos hemos ayudado del sensor de ultrasonidos para mantenerse a una distancia considerable de la pared, la misión de este ejercicio es que Toppyto siga una pared todo el tiempo siendo esto un método muy eficaz para salir de un laberinto.



Y que mejor entrada en esta ocasión que demostrarlo con un par de videos, en ellos observamos como perfectamente Toppyto sigue la pared.



Ese fue una primera grabación de Toppyto en la que iba correctamente por la pared y de un modo muy tranquilo.. en cambio en el siguiente video convertimos a Toppyto en un autentico F1 por la rapidez con la que recorría la pared así que mirar mirar por favor el resultado :D


viernes, 18 de febrero de 2011

Calibración del sensor de ultrasonidos

Volvemos de nuevo con Toppyto en esta ocasión al apartado que nos vamos a referir es el apartado más puramente matemático, se trataba de usar el sensor de ultrasonidos como ya lo teníamos montado del apartado anterior simplemente tuvimos que introducir un programita sencillo para que nos mostrara en todo momento la distancia que había de Toppyto a cierto objeto.



Y nos llevamos una grata sorpresa y es que el sensor de ultrasonido de Toppyto es bastante exacto por no decir casi perfecto, ¿cómo nos dimos cuenta de esto?
Pues bien pusimos a Toppyto frente a una pared y ayudados de un metro fuimos viendo con las medidas reales del metro la que nos indicaba Toppyto en su pantalla.
Resultó curioso porque Toppyto media en todo momento exactamente lo que era excepto cuando en el metro indicaba 222 - 223 cm que Toppyto no encontraba esa distancia y nos indicaba que estaba a 255 cm. Algo parecido ocurria cuando estaba Toppyto situado a menos de 19-20 cm que la distancia que nos indicaba no era la correcta.

Que sacamos entonces de conclusión de esto:

    - Menos de 20-21 cm mide mal 

    - Más de 222-223 cm se pierde y marca 255 cm

A continuación situamos a Toppyto a 40 cm de la pared y empezamos a hacer giros de 10º en 10º para ver cuando Toppyto dejaba de darnos la distancia correcta, el resultado que nos deparó esto fue que a 45º Toppyto marcó 45 cm en su pantalla y con mayor cantidad de grados Toppyto no mostraba correctamente la distancia que requeria. Por lo que el máximo grado para que los valores fueran correctos era 45º.






A continuacíon muestro la tabla que nos generó Toppyto tras hacer varias mediciones y ver si nos marcaba el valor correcto por pantalla:

            DISTANCIA REAL (con el metro)                  DISTANCIA TOPPYTO (por pantalla)

                                20 cm                                                             22 cm
                                30 cm                                                             30 cm
                                40 cm                                                             40 cm
                                50 cm                                                             50 cm
                                60 cm                                                             60 cm
                                70 cm                                                             70 cm
                                80 cm                                                             80 cm
                                90 cm                                                             90 cm
                               100 cm                                                           100 cm
                               110 cm                                                           111 cm
                               120 cm                                                           120 cm


Por lo que podemos dedudir que el error es mínimo y el sensor de Toppyto funciona de manera más que correcta.


A continuación vamos a proceder a calcular la incertidumbre tanto en el eje x como en el eje y, para ello colocamos a Toppyto a distintas distancias de la pared (ver tabla anterior), tras hacer los calculos vemos que la incertidumbre en el eje x es practicamente nula ya que para esas medidas siempre da la distancia correcta.
Para ver la incertidumbre en el eje y colocamos a Toppyto en un sitio fijo al suelo y usando el carton de la caja de nuestro robot, lo movemos de tal manera que vemos cual el objeto es percibido por el robot.

                            EJE X                                 EJE Y
                                                           
                             20 cm                               6.5 cm
                             30 cm                                  7 cm
                             40 cm                               7.5 cm
                             50 cm                                  8 cm
                             60 cm                               8.5 cm
                             70 cm                             11.5 cm
                             80 cm                                15 cm
                             90 cm                             22.5 cm
                           100 cm                                29 cm
                           110 cm                             39.5 cm
                           120 cm                                55 cm


Tras llevar a cabo las operaciones que nos aparece en la guía de la práctica para lo cual en algunos casos necesitabamos la media de X, nos resultó lo siguiente:

 - Para nuestra primera operación que resultaba de restar nuestra (Xi - media de X)^2 y así con los datos de nuestras 11 iteraciones nos dió lo siguiente: 0.5454
 - Para nuestra segunda operación que resultaba de (Xi - media de X)*(Yi - media de Y) todo esto con nuestras 11 iteraciones nos dió lo siguiente: 4.7727
- Para nuestra tercera operación que resultaba de (Yi - media de Y)* (Xi - media de X) todo esto con nuestras 11 iteraciones nos dió lo siguiente: 4.7727
 - Para nuestra cuarta operación que resultaba de restar nuestra (Yi - media de Y)^2 y así con los datos de nuestras 11 iteraciones nos dió lo siguiente: 597.59

EN RESUMEN:
(  0.4545                 4.7727  )    
(  4.7727                   597.59 )      

Esta sería nuestra matriz general, si nos pusieramos a particularizar en cada caso tendríamos 11 matrices distintas:
1ª Matriz (20cm):

             (4      13)
             (13   42.5)

2ª Matriz (30cm):

             (0      0)
             (0     49)

3ª Matriz (40cm):

             (0      0)
             (0    56.25)

4ª Matriz (50cm):

             (0     0)
             (0    64)

5ª Matriz (60cm):

             (0      0)
             (0    72.25)

6ª Matriz (70cm):

             (0      0)
             (0   132.25)

7ª Matriz (80cm):

             (0     0)
             (0   225)

8ª Matriz (90cm):

             (0      0)
             (0   506.25)

9ª Matriz (100cm):

             (0    0)
             (0   841)

10ª Matriz (110cm):

             (1               39.5)
             (39.5        1560.25)

11ª Matriz (120cm):

             (0        0)
             (0     3025)













Ya no se choca!! :D

Hola, hola, aqui estamos de nuevo con Toppyto si recordamos la última entrada Toppyto parecía loco y se chocaba con las paredes ya que usabamos el sensor de choque.
En esta ocasión vamos a usar el sensor de ultrasonidos:




Este sensor lo hemos puesto en la parte superior de Toppyto, en un primer momento lo colocamos de la misma manera del manual siguiendo las instrucciones pero tras varias comprobaciones observamos que hacia falta que estuviera más alto para tener mayor visión.
Este sensor se encarga de enviar ultrasonidos, estos ultrasonidos se reflejan en la pared y le vuelven a llegar a nuestro sensor en tal caso de que no reciba señal Toppyto nos marcará 255.



En la anterior imagen se observa perfectamente el sensor, como se ve tiene dos agujeros por uno envia la señal y por otro la recibe.
En esta ocasión Toppyto debe seguir el mecanismo que usamos el de choque pero sin chocarse, es decir, Toppyto se mueve libremente por el espacio yendo hacia el frente pero cuando el sensor de ultrasonidos detecta una pared o un objeto con una distancia inferior a 20 cm retrocede un poco gira cierto número de grados aleatorios (para ello usamos el random) y sigue su camino al frente.



Es el mismo mecanismo que cuando Toppyto hacia el choque pero en esta ocasión sin llegar a colisionar ya que con el sensor de ultrasonido es capaz de detectar si tiene algún objeto enfrente o sin embargo puede seguir sin curso sin temor a chocarse.

A continuación acompaño esta entrada con un par de videos que grabamos de Toppyto, para ello introdujimos a Toppyto en una especie de laberinto que se encuentra en los laboratorios, es el mismo laberinto que en la entrada de choque pero si observamos como Toppyto se choca con las paredes en esta ocasión evita el choque todo el tiempo ya que detecta la pared que tiene al frente.




Parece que se ha vuelto loooocooooo!!

En esta ocasión trastearemos con el sensor de contacto que le hemos añadido a Toppyo en su parte delantera (donde en anteriores entradas observamos que pusimos el sensor de luz).



¿En que consiste este apartado? En que Toppyto deambule por su entorno todo el tiempo hacia adelante hasta que se encuentre frontalmente y se choque con algo, una vez se ha chocado Toppyto retrocederá un poco girara un número de grados totalmente al azar y seguira con su marcha hacia adelante y así sucesivamente.





El número de grados que Toppyto gira una vez ha retrocedido tras chocarse con algo es totalmente al azar para ello usamos la función random para que aleatoriamente eligiera un número de grados.





Como la vida misma es mejor ver que explicar.. para ello incorporamos dos videos en los cuales se ve como Toppyto constantemente va hacia adelante hasta chocarse con un obstaculo y cada vez que esto pasa y tras retroceder gira un determinado número de grados totalmente al azar como podemos ver.




Y para terminar un video que teníamos en la galeria y aunque no sea perfecto (ver el final), ponemos para que puedan ver un video más de Toppyto en acción y como se vuelve loco chocando con las paredes :D







Toppyto detecta sonido!!

Seguimos con los sensores de Toppyto, ahora vamos a juguetear con el sensor de sonido que le hemos incorporado a Toppyto en un lateral.



La misión de este apardado consiste en que cada vez que demos una palmada Toppyto ande y cuando demos otra palmada Toppyto se pare... a priori parece sencillo pero nos llevo bastante tiempo hacerlo con total efectividad ya que lo hemos adaptado para cualquier tipo de ambiente porque no es igual ponerlo en tu casa que no hay ruido a ponerlo por ejemplo en clase de prácticas..



Por lo tanto tuvimos que incorporar al código de Toppyto una función que nos hiciera 5 medidas del sonido ambiente y sacara la media de estos.. por lo tanto el siguiente paso es dejar actuar a Toppyto. Aqui presentamos una foto de Toppyto con el sensor de choque y el sensor de ultrasonidos, incorporados al igual que el sensor de sonido:





En primer lugar Toppyto esta parado y no se va a mover hasta que alguien de una palmada, una vez Toppyto oye la palmada va hacia adelante y no va a parar hasta que oiga otra y así sucesivamente.. Para que a nuestro queridos seguidores les quede más clara la actuación de Toppyto ofrecemos un video a continuación:




Y hasta aquí nuestra prueba de Toppyto de dar palmadas.. en posteriores entradas mostraremos el sensor de choque..

Comenzando la práctica 2

Ya estamos de vuelta con Toppyto!! Hemos tardado un poco en aparecer debido al trabajo que nos está dando Toppyto pero aquí estamos dispuestos a contar todo.
En esta segunda práctica  la función principal es introducirnos al mundo de los sensores que rodea a Toppyto, sensores de contacto, de ultrasonidos, de luz, de ultrasonidos...

Pero sin dar más vueltas vamos a empezar por el apartado primero, este primer apartado trata de mostrarnos por la pantalla de Toppyto cierta información, esa información es la siguiente:

                                                   - Nombre del robot
- Valor del sensor de ultrasonidos en mm
                                                   - Valor del sensor de luz
                                                   - Tensión de la bateria en Milivoltios
                                                   - Memoria disponible en bytes

Este primer apartado es bastante sencillo simplemente hay que introducir las llamadas a cada sensor para que nos muestra por pantalla los resultados. Así que sin más dilacion añadimos a Toppyto dos nuevos sensores a su estructura el de luz y el de ultrasonidos por lo que su imagen cambio un poco...








Para que nos muestre de forma adecuada el sensor de luz sus valores (su %), en primer lugar Toppyto nos pide que calibremos el sensor pidiendonos que primero calibremos el negro y posteriormente el blanco:



Le ponemos debajo del sensor de luz algo negro, en este caso un archivador negro:



Posteriormente cuando nos pide calibrar el blanco, hemos puesto debajo del sensor una hoja blanca:


Y así una vez efectuado esto por pantalla se nos muestran todos los valores que se nos piden en este apartado y así concluye este primer apartado. Acontinuación más.. sigan atentos :D



martes, 8 de febrero de 2011

Cálculo de la matriz de covarancia

Una vez más y para facilitar al usuario y hacerlo de modo más claro como este punto de la práctica es algo extenso lo separamos en una entrada nueva.
Para este apartado de la práctica volvimos a usar el lápiz con el que Toppyto nos dibujo el cuadrado, pero en esta ocasión programamos un programa pequeñito para que en esta ocasión nuestro robot recorriera en línea recta 100 centímetros.
Una vez hecho esto pintamos en un papel una línea recta perfecta de 1 metro, a continuación pusimos a Toppyto sobre tal línea para ver si conseguía seguir la línea perfectamente.. los resultados no fueron así se desviaba poco a poco y no lograba llegar 100% al final de nuestra línea.
La anterior acción de recorrer con Toppyto ese metro la hicimos 10 veces lo que nos llevo a crear una serie de recopilaciones tanto en X como en Y. Teniendo en cuenta que la X es lo que se desviaba respecto a la recta original (la hecha por nosotros), la Y en cambio era la distancia recorrida por Toppyto hasta pararse.
A continuación muestro los datos que recogimos:

EJE Y:                                                                       EJE X:

 Prueba 1 - 98 cm                                                           Prueba 1 - 1.49 cm
 Prueba 2 - 97.7 cm                                                        Prueba 2 - 2.65 cm
 Prueba 3 - 98.8 cm                                                        Prueba 3 - 1.8 cm
 Prueba 4 - 99.2 cm                                                        Prueba 4 - 1.25 cm
 Prueba 5 - 98.6 cm                                                        Prueba 5 - 1.26 cm
 Prueba 6 - 98.4 cm                                                        Prueba 6 - 1.3 cm
 Prueba 7 - 99 cm                                                           Prueba 7 - 1.5 cm
 Prueba 8 - 99.1 cm                                                        Prueba 8 - 2.445 cm
 Prueba 9 - 99.1 cm                                                        Prueba 9 - 2.1 cm
 Prueba 10 - 98.8 cm                                                      Prueba 10 - 1.6 cm

MEDIA TOTAL Y = 98.67 cm
MEDIA TOTAL X = 1.7395 cm

Tras llevar a cabo las operaciones que nos aparece en la guía de la práctica para lo cual en algunos casos necesitabamos la media tanto de X como de Y, nos resultó lo siguiente:

 - Para nuestra primera operación que resultaba de restar nuestra (Xi - media de X)^2 y así con los datos de nuestras 10 iteraciones nos dió lo siguiente: 0.22621225
 - Para nuestra segunda operación que resultaba de (Xi - media de X)*(Yi - media de Y) todo esto con nuestras 10 iteraciones nos dió lo siguiente: -0.045415
- Para nuestra tercera operación que resultaba de (Yi - media de Y)* (Xi - media de X) todo esto con nuestras 10 iteraciones nos dió lo siguiente: -0.045415
 - Para nuestra cuarta operación que resultaba de restar nuestra (Yi - media de Y)^2 y así con los datos de nuestras 10 iteraciones nos dió lo siguiente: 0.2261

EN RESUMEN:

(  0.22621225                   -0.0045415  )    
(  -0.045415                      0.2261  )      

Falta por añadir que seria una matriz de 2x2, pero aqui en el blog no aparece modo alguno de señalizarlos correctamente por lo que en la posicion 1x1 = 0.22621225. En la posición 1x2 = -0.045415.
En la posición 2x1 = -0.045415. En la posición 2x2 = 0.2261. Teniendo en cuenta que siempre tenemos en cuenta en una matriz las filas por las columnas (filas x columnas).

Y para tener bien completita nuestra reciente entrada de Toppyto un par de imagenes desde dónde Toppyto empezó a dibujar sus líneas rectas como vemos todas parten desde el mismo punto pero las llegadas distan bastante unas de otras:








Aqui se observa bastante bien como nuestra línea roja era nuestra línea perfecta la cual debía seguir Toppyto, al lado se aprecian las distintas rectas en lápiz que efectuó Toppyto.



A continuación un video muy cortito de como colocabamos todo el tiempo a Toppyto con total precisión en su punto exacto para que siempre partiera del mismo punto, para ello teniamos pintadas en el papel la posición inicial de las ruedas y del lápiz.



Y como no, un vídeo de la recta efectuada por Toppyto desde su inicio hasta su final incluida la preparación previa para cada recorrido, como se observa traza una línea prácticamente perfecta:




Pues esto a sido todo amigos aquí concluimos nuestra serie de entradas de blog para la práctica porque ya hemos efectuado todos los apartados. Esperamos que les haya gustado, prometemos seguir con la siguiente práctica mejorar día a día y poder mostrar nuestros procesos con Toppyto.