Quinta practica - Segway

Esta practica se basa en el equilibrio dinámico, el robot en reposo estaría caído.
Un control PID tiene que regular el equilibrio  del robot .

PID

El PID que significa Proporcional, Integral, Derivado es un tipo de control de lazo cerrado, esto significa que actúa teniendo en cuenta el control(valor) de la salida.

La señal menos el valor de la salida generan un valor llamado  Error
este se calibra  operando con los distintos componentes del PID para general un nuevo valor de señal de entrada al sistema( en este caso los motores del robot).
para medir la salida como necesitamos un sensor rápido se usa el de infrarrojos.

----------------------------------------------------------------------------------------------------------------------------------

Soluciones que han ido surgiendo

-El algoritmo no tiene mucho problema en si mismo, como trabajamos con valores puntuales la integral se convierte en suma y  la derivada en restas.
Hay que encontrar el valor P que lo mantenga en equilibrio, y luego con I y D hacerlo mas robusto y duradero.

-El diseño de hardware tiene mas trabajo, se debe buscar un punto que tenga el centro de gravedad lo mas bajo posible y  centrado con  su base.
conviene que  el sensor de infrarrojos no este muy alto para reducir interferencias externas.  Y colocado en una posición que  una pequeña variación  del eje de gravedad sea captado rápidamente.

-Una idea para  ir calibrandolo es  considerar el problema como un péndulo invertido  y  tener una estimación  de  mas o menos donde podría estar el valor Proporcional. Cuando ya consiga estar estable ir metiendo valores un poco por tanteo  de I y D  y estudiar como se va comportando.
También es recomendable  que los ciclos/ segundo del programa sean altos para que pueda  captar las variaciones lo antes posible.

-Y bueno una vez hecho lo "científico" lo mas importante es tener suerte  para dar con unas contantes buenas,  que lo mantengan lo mas robusto posible y ya entra un poco en el área de arte y suerte.
Haciendo que sea la practica mas  desesperante porque es difícil controlar todas las condicione  al 100%; Un  cambio en la inclinación de la posición origen, un cambio en la posición de los motores, la carga de la batería, la luz ambiente,  el  contacto con el suelo, el viento, una mota de polvo, la holgura de las piezas, pueden hacer que no sea fácil encontrar las constantes idóneas.

-Para intentar mejorar la superficie de equilibrio le hice una umbralización  con zona estable para que no estuviese vibrando, equilibrio con variaciones pequeñas, zona sensible que es donde  la regulación es decisiva, y alarma que pertenece ya al campo  de no  recuperación, también tuve una versión que diferenciaba adelante de atrás ya que el robot no estaba del todo equilibrado.

----------------------------------------------------------------------------------------------------------------------------------

 Vídeo de su comportamiento

 

 ----------------------------------------------------------------------------------------------------------------------------------

Si hubiese tenido mas suerte con  esta practica, y un sensor giroscopio  me habría atrevido a intentar hacer un ball-bot  como el de este vídeo

manual de ensamblado

 

OFF TOPIC

Experimentos con ROS

http://es.wikipedia.org/wiki/Sistema_Operativo_Rob%C3%B3tico

Java permite una cierta abstracción y portabilidad de programas entre distintos modelos de robots. Pero Lejos esta muy enfocado al NXT, La idea de ROS es que una implementación sea lo menos dependiente de la arquitectura del robot .
El traspaso de un algoritmo de un modelo de robot a otro no suponga empezar casi desde 0.
Instalarlo en linux no es demasiado difícil. lo malo es que necesitaba pisar el software  que interpreta java del NXT en el robot  y eso no lo he querido hacer .

esta es la pagina oficial: http://www.ros.org/wiki/
Tiene muchas librerías para distintos tipos de robots incluido el NXT.


Un poco de Visión Artificial

http://es.wikipedia.org/wiki/Visi%C3%B3n_artificial

Como cada día están mas metidas las cámaras en la robótica, me ha  pareció interesante profundizar un poco en el tema.
En sofware libre de lo mas importante es opencv
esta es la pagina oficial: http://opencv.willowgarage.com/wiki/
Lo bueno de opencv es que es compatible con ROS y  permite trabajar con filtros  y  bueno se puede trabajar sin necesidad de tener un robot físico, por lo que puedes separar la parte de procesamiento de imagen de la programación  del robot.

Andurino

Una paca madre muy simple, pero interesante para  hacer robots caseros

Ros cuenta con tutoriales para correr sobre este tipo de placas.

 

Realidad aumentada

 http://es.wikipedia.org/wiki/Realidad_aumentada

Muy relacionada con la visión artificial, y pudiendo dar mucho juego a las interfaces humano-maquinas, tenemos este área  dentro de la robótica.
En software libre de lo mas importante es  ARToolKit
esta es la pagina oficial:http://www.artoolworks.com/products/
Es también compatible con ROS



Y Bueno una cosa que me llama mucho la atención

Interfaz Cerebro Computadora

 http://es.wikipedia.org/wiki/Interfaz_Cerebro_Computadora

Ya están bastante  avanzadas las técnicas no invasivas para adquirir los impulsos neuronales, en la fotografía se esta controlando el iphone solo con la mente. A día de hoy ya hay juguetes que están explotando un poco la idea como Mind Flex 

 

http://en.wikipedia.org/wiki/Neuroinformatics

 

 

http://www.bbc.co.uk/mundo/ciencia_tecnologia/2009/07/090723_cerebro_artificial_rg.shtml

Un proyecto interesante seria tener una interfaz neuronal  y un robot que realizasen algunas acciones sencillas, mostrando en una pantalla el entrono con elementos de realidad aumentada para aumentar sus funcionalidades.

Cuarta practica - VFF

Esta practica pertenece a los algoritmos de navegación local.
El objetivo es llegar a un destino que generara en el robot una fuerza atrayente, mientras que los obstáculos generaran una fuerza repulsiva que alterara la trayectoria.  El robot  trazara un mini mapa  de su entorno, calculara las fuerzas repulsivas, calculara la fuerza atractiva, calculara la fuerza resultante, girara y avanzara un paso (distancia determinada) esto lo repite hasta  terminar en las proximidades del destino.

----------------------------------------------------------------------------------------------------------------------------------

Soluciones que han ido surgiendo

-La practica al principio la enfoqué partiendo desde la idea de unas coordenadas absolutas y  una pequeña corrección para la fuerza objetivo.
El mundo tendría unas coordenadas globales, el robot estaría referenciado frente a esas coordenadas globales y los obstáculos los iría calculando y pasándolos a las coordenadas globales.
Lo idee de esta forma porque mi  idea era ir fabricando un mapa  global.
Ventajas:
   Al tener los obstáculos en absolutas  podría en teoría corregir mi posición ya que la odometria mete una cierta incertidumbre.
   Construir un mapa global seria fácil. Iría almacenando en las celdillas las posiciones donde ha detectado un obstáculo.
Inconvenientes:
   Descubrí que el NXT usando Lejos no soporta la creación de ficheros  mediante las ordenes de java comunes.
   Se me complicaba un poco la navegación cuando las coordenadas estaban en negativo o el robot no giraba lo que debía.


-Primera idea,  Tipo de coordenadas de trabajo:

Cartesiana para todo.
Ventajas:
    Al tener todo en el mismo sistema de coordenadas  cartesianas y referencias desde el origen los cálculos son fáciles.
Inconvenientes:
    El sensor de ultrasonidos solo captaría obstáculos en linea recta. Usando tornillo sin fin y eje haría un barrido horizontal. No es fácil hacer el montaje con las piezas que tenia.

Cartesianas para origen, posición del robot y polares para obstáculos.
Ventajas:
    El sensor de ultrasonidos lo puedo acopar sobre un motor  y realizar  las medidas en un sistema natural.
Inconvenientes:
    Cambio de coordenadas obligatorio. Y el robot  siempre tiene que tener la misma orientación. Generando mas adelante movimientos  innecesarios de corrección.

Añadir angulo de orientación del  robot.
Ventajas:
    El robot ya tiene un apoyo  para controlar su orientación.
Inconvenientes:
    Deja de ser útil el sistema de coordenadas absolutas.


-Segunda idea, Olvidarme de mapa global y trabajar con coordenadas  relativas al robot:
Debido a problemas al intentar hacer un mapa  con la memoria desistí, consulte con mi profesor  como reorientar la practica. Me aconsejo que la enfocase  en trabajo en relativas. Esto supuso cambiar  el destino a coordenada relativas y usar los valores  de los obstáculos directamente.

----------------------------------------------------------------------------------------------------------------------------------

  Solución Final

- Particionado del problema en fases:

+Sonar:Se encargaría de generar un mapeado de los obstáculos.
Esto lo logra tomando 20 medidas en un arco de 180 grados, cada medida seria la media de 5 medidas en cada dirección.  Esto lo he hecho de esta forma para reducir los errores de medida que ofrecen los sensores y tener cubierto todo el campo bien.

+Calculo de Fuerza repulsiva: Una formula y trigonométria  permiten convertir  la posicion de los obstáculos en una fuerza |Fr|=Krepulsiva/distancia ør=øobstaculo+180
luego se  sumarían  todas para generar un único vector repulsivo.

+Calculo de Fuerza atractiva: Calcular la posición del objetivo  en coordenadas relativas   teniendo en cuenta la orientación del robot y la posición.|Fa|=Katractiva*distancia øa=øobjetivo-ørobot

+Calculo de la resultante: Suma de fuerzas  ya con sus limitaciones y conversiones, esto genera un vector que debe ser interpretado por  los motores.

+Conversión en magnitudes físicas y movimiento.

+Odometria para calcular la nueva posición y orientación.

-Pequeños parches:
Para evitar que obstáculos muy lejanos pero continuos como una pared tengan mucho peso he limitado la distancia a la que tiene en cuenta un obstáculo, cuando un obstáculo esta a mas de 60 cm lo ignora.

Para garantizar que no se haga el valiente golpeándose,  y no haya divisiones entre 0  cuando el obstáculo esta a una distancia menor del paso genera fuerza máxima. (Esto generaba el comportamiento que me tenia mosca, la superficie de la lata no le da una distancia correcta, se la daba un poco mayor por la forma redonda así que el podía avanzar hasta justo toparse pensando que  todavía tenia espacio).

Tiene un corrector para permitir usar las coordenadas desde el robot  de forma natural para el hombre x y, "y" adelante, "x" lados.
Los ángulos están en sentido anti horario para que el 0 estuviese en el mismo punto, y sea fácil la conversión entre el mundo real y el de fuerzas.

----------------------------------------------------------------------------------------------------------------------------------

 Vídeos de sus comportamientos

-coordenadas  y=160 x=-80  (Prueba de entrega)

-coordenadas y=-140 x=-80 (Prueba de robustez)

 

(use  140  en vez de 160  porque pensaba que consideraría el cuerpo)

Tercera practica - Victimas

En esta practica contamos con un escenario. Se debe seguir la linea negra, hay 2 tipos de victimas: verdes y plateadas y tramos sin linea.

----------------------------------------------------------------------------------------------------------------------------------

Soluciones que han ido surgiendo

- Esta practica tiene un trazado  complicado por lo que  la mejor idea es  afrontarlo con un algoritmo robusto aunque  lento basado en  la localización y búsqueda de la linea frente a la velocidad.

- Al principio enfoqué la practica  por umbrales, tome una medida de cada elemento; negro, verde,blanco,brillante y use un decisor ML ente cada medida.

Ventajas:

     Había un rango para cada  posible detección.

Inconvenientes:

     El nivel de verde debido a la naturaleza del sensor de infrarrojos se podía conseguir cuando detectaba negro y un poco de blanco.

-Ignorar victimas verdes, debido a que la probabilidad de falsa alarma detectando verdes es muy alta. Hay pocos verdes  y la detección de verdes le dificulta el seguir la linea, acabe optando por ignorar a las victimas verdes.

Ventajas:

    Los rangos están mejor definidos, ya no hay solapamiento. 

    Los nuevos rangos son negro, blanco y brillante.

Inconvenientes:

    Las victimas verdes ya no tienen comportamiento.

-Para enfrentarse  a los tramos  blancos, decidí realizar una búsqueda de incremental de lado a lado hasta  llegar al cuarto de giro.Si no encuentra la linea recupera su orientación original y avanza una pequeña cantidad y vuelve a buscar.

Ventajas:

    Aumenta en gran medida la recuperación frente a perdidas y salidas de linea.

Inconvenientes:

    En la rampa  el peso del culo le hacia salirse.

-Ademas de las adaptaciones del robot, hice unos pequeños retoques a la pista a ver si conseguía mejoras; Reduje la pendiente de la pista, y para aumentar el rozamiento y reducir el derrape le pegue cinta de carrocero a ambos lados de la rampa. En mi caso no soluciono el problema del derrape por el peso del culo. Pero si que ayudo en las practicas de mis compañeros.

 -Por ultimo añadir que la detección de los hombrecillos plateados esta hecha mediante unas pequeñas etapas de paro pitido avance y búsqueda de linea negra.

foto de falso positivo de verde

----------------------------------------------------------------------------------------------------------------------------------

vídeo del robot haciendo el circuito
-Esta acelerado a 4 veces la velocidad aproximadamente tardaba un poco mas de 7 min y solo pitaba en los plateado.

Segunda practica - Sigue lineas y pañuelo

Esta practica  no incluye novedades en cuanto  a los elementos de programación.
Sin embargo  cuenta con dificultades para su realización  como son la disponibilidad del circuito,  el peso de las latas.

circuito con la lata en posición,(la derecha tiene ventaja)

----------------------------------------------------------------------------------------------------------------------------------

nuevo elemento

<sensor de luz>
Es de funcionamiento similar al de ultrasonidos  y pertenece al grupo de sensores activos, emite un una luz roja y dispone de una cámara que mide  la cantidad de luz reflejada.

----------------------------------------------------------------------------------------------------------------------------------

Soluciones que han ido surgiendo

-Primero  empecé pensando  en detectar la linea con el sensor de luz. Cuando detectara negro fuese hacia adelante:
Esta solución  ha sido la que he terminado presentando. Y tiene una serie de ventajas y de inconvenientes.
Ventajas:
    El robot realmente sigue la linea.
    Realiza correcciones  hacia ambos lados de la linea.
    Es un poco mas fácil hacerle cambios de software.
Inconvenientes:
    Es bastante lento, ya que puede avanzar muy poco hasta perder la linea y tener que corregir.
    No permite el cambiar la dirección  del robot siempre debe ir hacia adelante.
    La velocidad tiene que ser baja ya que si  lleva demasiada inercia  no consigue  corregir.     <100 rpm

-Segunda solución un sigue bordes, y control directo sobre los motores. Un motor le echa de la linea y el otro le empuja hacia ella.
Ventajas:
    El robot al moverse mediante semicírculos consigue realizar los giros de forma muy fluida.
    Consigue velocidades bastante altas ya que tiene el doble de superficie para avanzar.
    Es capaz de avanzar y de retroceder.
    Con una linea bien marcada y y velocidades <300 rpm no pierde la linea.
    Código muy simple.
Inconvenientes:
    Solo corrige hacia un sentido,  lo que provoca que si pierde  la linea por el lado del motor que le empuja  hacia fuera, tenga que  realizar un giro completo.
    No permite fácilmente modificaciones de software para corregir perdidas.
    La lata se tiene que colocar un poco hacia un lado de la linea.

-Tercera solución sigue bodes con 2 sensores , la solución  tiene la simplicidad del sigue bordes con     el añadido de que ahora puede realizar correcciones en los 2 sentidos.
Ventajas:
    La navegación es fácil.
    Es muy rápido.
    Puede avanzar y retroceder.
    Tiene una corrección primaria hacia los 2 lados.
    Código bastante simple.
    Detecta comienzo y fin del circuito.
Inconveniente:
    Mayor  numero de sensores.
    Realmente no sigue la linea, para el es indiferente tener la linea en el medio o no tener la linea, nada le informa de eso.
    Si  perdiese  la linea  por  deterioro de esta podría perdería y después de realizar un giro completo  hacia el lado del ultimo sensor ;  terminaría girando  completamente o avanzando recto sin seguir una linea.

 

 

Primera idea de garra, luego me decidí por lazo por usar menos piezas y  movimiento mas rápido

Que me hizo volver a la primera solución.

La tercera solución me limitaba hacia posibles añadidos.  Gastaba una entrada y  supondia un teórico gasto a mayores.
La segunda en  circuitos con la linea en peor estado y con recorridos mas  complejos podría darse la vuelta, y no es fácil programarle  correcciones   hacia el otro lado.

Así que aunque la primera solución es la menos optima para este circuito en concreto, le dota de una robustez un poco mayor y facilita realizar posibles cambios.

Creo que si hubiese dispuesto de mas  pruebas habría creado un sigue bordes cambiante, que estuviese siguiendo el borde derecho un rato, después pasase a seguir el borde izquierdo de la linea y así todo el rato, esto en principio  podría ayudarme  a tener  la corrección  hacia los 2 lados,  aunque no tendría  exactamente la memoria del ultimo giro bueno realizado, tendría la fluidez de movimiento del sigue bordes que no pierde fácilmente la linea y una corrección similar a sigue lineas primera fase.

----------------------------------------------------------------------------------------------------------------------------------
vídeo de sigue bordes tomando una curva

Primera practica - Choca-gira v2

Máquina de estado finito

Modelo de programación basado en etapas y transiciones. El comportamiento  del robot ya no solo depende de los valores de entrada sino también de  sus estados internos.
Etapa: Donde se realizan las acciones. Una acción puede ser tan compleja como moverse, o tan simple como esperar.
Transición: Condiciones de cambio entre una etapa y otra. Suelen encargarse de  este paso sensores, contadores o temporizadores.
En el modelo reactivo las etapas tienen que ser cortas y pocas.

 ---------------------------------------------------------------------------------------------------------------------------------- 

Nuevo elemento

<Sensor de ultrasonidos>
Este sensor funciona como el sonar de los murciélagos, envía una señal de ultrasonido que rebota contra  los obstáculos. Calcula la distancia midiendo  el tiempo que tarda en volver la señal.
Su rango de trabajo va de  0 a 255 cm con una precisión de +/- 3 cm. Para  usarlo  se recomiendan distancias mayores de 4 cm.

---------------------------------------------------------------------------------------------------------------------------------- 

Cambios 

Aumento  del componente reactivo eliminando las esperas después  de movimientos.
Se le ha añadido sonido cuando retrocede.
Programado con  estructura de control mediante estados: Tiene 3 estados avanza, retrocede, gira.

 ----------------------------------------------------------------------------------------------------------------------------------

Vídeos

El primero, Chocagira v1.
Su movimiento es algo lento, y tiene parones después de completar los giros.

 

El segundo, Chocagira v2 . 
El vídeo no tiene sonido  y  la calidad es muy baja(esta grabado con el móvil y poca luz) 
Funcionamiento mas continuo y movimiento mas rápido. 
Esta versión  emitía pitidos.

 

El ultimo, Casichocagira.

La detección la hace el sensor de ultrasonidos (hay ruidos de fondo para demostrar que el ruido ambiente no afecta demasiado al sensor) 

Su comportamiento es  similar  al chocagira v2. 

Para comprobar la programación reactiva intento "pisarle", el robot reacciona retrocediendo inmediatamente.

 
Dejo unos enlaces que podrían ser de interés:
Un editor de  gráficos  y esquemas vía web.
 http://www.gliffy.com/
Un editor de vídeo vía web para convertir formatos, cortar escenas, poner subtitulos, etc.
 http://www.videotoolbox.com/

Primera practica - Choca-gira v1

Programación reactiva

La programación reactiva es muy buena en prácticas simples,  hace que el comportamiento del robot sea fluido, y adaptable al entorno.

La idea es que el programador  piense con que problemas se va a encontrar el robot y los separe  en decisiones excluyentes.

El robot capta la información y ejecuta  la tarea.

----------------------------------------------------------------------------------------------------------------------------------

Principales componentes

<Sensores>

El choca-gira tiene 2 sensores de contacto que le dirán  por que lado ha chocado.

<Actuadores>
Cuenta con 2 motores  para generar su movimiento.

<Procesador>
El ntx será el que tome las decisiones.

----------------------------------------------------------------------------------------------------------------------------------

Que se pide

 El robot avanza hasta chocar. Una vez ha detectado el choque deberá retroceder un poco. Y si el choque lo detecto el sensor derecho girar a la izquierda, si fue con el izquierdo girar a la derecha, el ángulo de giro será aleatorio.

_________________________________________________________________________________

 Solución

El primer problema viene del mundo físico:

¿Cuál sería la mejor posición de los sensores?

    --Una solución sería colocar cada uno  a un lado del robot apuntando hacia el frente.

 ¿Detectaría siempre?

    --La detección está limitada a la superficie del sensor. Para aumentarla he diseñado un parachoques.

¿Cómo se moverá?

    --Aquí teníamos libertad, pero lo más lógico era con 2 ruedas motrices por tracción diferencial y una rueda loca.

  -----------------

Una vez tenemos planteado el chasis, tenemos que programarlo:

El nxt tiene ya unos paquetes donde él considera que los motores servirán para el desplazamiento.(lejos.robotic.navigation.*)

Y en el paquete básico (lejos.nxt.*)  están los objetos que sirven para controlar los sensores.

Para configurar los sensores, primero se pone el tipo, después el nombre que va a tener, y finalmente, se llama al constructor para que haga el objeto pasándole como argumento el puerto que quieres que use.

Un ejemplo:
    TouchSensor sensorS1 = new TouchSensor(SensorPort.S1);

Para controlar el movimiento, al principio usamos la abstracción de

DifferentialPilot, que permite que el robot mediante un controlador interno calcule cuánto se ha movido.

 Un ejemplo:
    

DifferentialPilot p1 = new DifferentialPilot(diámetro_ruedas, distancia_ruedas,Motor.A,Motor.B);

La clase

DifferentialPilot permite calibrar la velocidad de desplazamiento. 

Un ejemplo:
    p1.setSpeed(400);

Así como controlar la dirección del desplazamiento recto o giro de forma no bloqueante 
Un ejemplo recto:
    p1.travel(10.0, true);
Un ejemplo giro:
   p1.rotate(90, true);

Ahora venía clasificar los casos, 2 sensores 2^2= 4 informaciones
    -si choca por la izquierda se le dice al robot que gire (0-180º) negativos.
    -si choca por la derecha se le dice al robot que gire (0-180º) positivos.
    -si no choca avanza.  
    Un último caso sería que chocase de frente, que se englobaría  en un choque  de algún lado  indistintamente según el punto en el que se halle  la ejecución.

  -----------------

Ya hecho el prototipo procedemos a probarlo:

Primero en un pasillo sin obstáculos:

    - Aquí funciona como lo esperado, los choques frontales activan uno de los sensores.

A continuación, se enfrenta a un entorno más agresivo como es el salón; hay mesas, sillas, sofás, una estantería, cables y una lámpara de pie.

   -Aquí muchos choques frontales no los detecta, tiene muchos obstáculos por debajo de la posición de los sensores, por  lo que rediseño el  parachoques para  que los choques frontales  los detecte mejor.

Esta nueva pieza permite que si se da contra una pata  de frente, alguno de los sensores se dé por enterado.

A continuación, intento hacerle fotofóbico, pero el sensor de luminosidad no funciona según lo esperado, y cuando Pilot se hace cargo de la navegación, pierde componente reactiva, se mueve solo con información interna (a ciegas del mundo).

Intentaré  realizar algunas mejoras a la programación. Será el Choca-gira v2

Dejo unos enlaces que podrían ser de interés:
Cad de diseño con las piezas de lego

       http://ldd.lego.com/
Manual sobre java
       http://docs.oracle.com/javase/tutorial/java/nutsandbolts/index.html
Manual sobre LeJOS
       http://lejos.sourceforge.net/nxt/nxj/tutorial/index.htm