= Construyendo y Programando RoboTitos =

[[PageOutline(2-5, Table of Contents, floated)]]
'' ^Departamento de Ingenieria de Computadoras^ ''

Documentacion de "Frankestito", construido en nuestra facultad.

== Introducción ==

En la Facultad de Informática estamos desarrollando un prototipo de robot (real) autónomo, compatible con [http://wiki.roboteducation.org/Myro_Development Myro]. Además, a diferencia de la mayoría de los robots existentes compatibles con Myro, nuestra implementación cuenta con Linux embebido dentro del robot. Esto posibilita ejecutar, por ejemplo, python o prolog directamente dentro del robot.

'''Myro''' ('''My Robotics'''), es un proyecto open source que tiene como objetivo enseñar ciencias de la computación a través de la programación de robots con Python. Mas información en [http://wiki.roboteducation.org/Introduction_to_Computer_Science_via_Robots Introduction_to_Computer_Science_via_Robots]

'''Noticias! ''' : El código fuente en desarrollo, para todas las capas de software, se encuentra ahora versionado en github :
https://github.com/zrafa/se_uncoma/tree/master/robotitos

[[Embed(youtube=10ki6rStntk,w=400,h=300)]]



== Hardware ==

El prototipo actual utiliza un microcontrolador [http://www.atmel.com/devices/atmega8.aspx AVR Atmega8]  (en una board diseñada para nuestros fines, compatible con arduino uno) para controlar un L293D el cual tiene conectado ambos motores. También contamos con un prototipo utilizando un [http://www.atmel.com/devices/atmega328.aspx AVR Atmega328], desde un arduino uno. Los motores son antiguos motores de robots Legos.

 * El prototipo que cuenta con una plaquita controlada por un Atmega8 (freeduino armada en la Facultad) se comunica con una placa TL-MR3020 de 5.7cm x 5.7cm con Linux embebido, a traves de una conexion serial. La board Linux utiliza wireless para comunicarse con Myro, y el usb host para la conexion con la camara de visión.
 * La vision actual es a traves de una camara controlada por Linux. Actualmente el robot distingue objetos con colores uniformes, ideal para hacer practicas de vision basica.
 * Para comunicarse con el mundo, el robot cuenta con dos leds y un parlante. Desde Myro se puede "encender" o "apagar" estas salidas para realizar acciones de comunicacion visual y sonora.

Equematicos : POR SUBIR. 

=== Hardware Linux embebido ===

Utilizamos la board TP Link 3020. Con uboot, kernel Linux, y OpenWRT instalado. Documentación de referencia : http://wiki.openwrt.org/toh/tp-link/tl-mr3020

==== Wireless ====

Nos comunicamos con Myro a traves de una conexion TCP.
Myro, nativamente, intenta utilizar un dispositivo serial (que en los robots importados es un BT). Nosotros modificamos levemente Myro, para que en vez de utilizar un dispositivo serial utilice una conexion TCP/IP via la wireless del Linux embebido en el robot.


== Software ==

Hay varios niveles de software. 

[[Image(http://lti.fi.uncoma.edu.ar/trac/chrome/site/myro.png, 480px, right)]]

El software del robot (firmware para el Atmega8) está escrito en C, y utilizamos el ambiente arduino para crosscompilar y flashear el AVR ATMEGA. Con el firmware actual podemos mover el robot.

Utilizar un AVR Atmega, como microcontrolador para controlar los motores y sensores, permite desarrollar todo el software del robot utilizando las herramientas GNU GCC (the GNU Compiler Collection). 

El software en el Linux embebido son varios programas (ser2net, mjpeg_stream, firmware para comunicaciones, scripts, etc), configurados de diferentes maneras para diferentes experimentos.


=== Flashing via Wireless ===

A través del Linux embebido con el que cuenta el robot podemos transferir el firmware desarrollado para el Atmega8 via wireless. Se logra a través de ser2net en el LInux embebido, y a través de socat en la PC origen.

{{{
En tplink:
# cat /etc/ser2net.conf
2000:raw:0:/dev/ttyATH0:19200 8DATABITS NONE -XONXOFF -RTSCTS
Iniciar ser2net.

Desde la PC :
socat pty,raw,echo=0 tcp:192.168.1.201:2000

Reiniciar el atmega8, y rapidamente desde PC (antes que el bootloader finalice la espera):
avrdude -C/etc/avrdude.conf -v -v -v -v -patmega8 -carduino -P/dev/pts/5 -b19200 -D -Uflash:w:eco_serial.hex:i
}}}
=== Flash the Bootloader en Atmega8 Usando Arduino UNO como ISP ===

Seguir las instrucciones en : 
http://arduino.cc/en/Tutorial/ArduinoISP
Y utilizar el IDE ARDUINO 1.0.1 o superior ('''OJO: si se utiliza el IDE Arduino 1.0 FALLA!!!. Intenté mil veces :) ''')
=== Controlando el Robot ===

Hay varias maneras posibles de controlar al robot por software (todas ellas via wireless o bluetooth). Tres formas que hemos testeado son :
 * a través de Myro y cualquier lenguaje en que Myro esté implementado. Acualmente puede ser Python, C, C++, Java.
 * a través de sockets y un programa en cualquier lenguaje (se necesita ser2net), 
 * utilizando un Gamepad y Myro


==== Ejemplo utilizando Python y Myro ====

El software Myro es utilizado desde la PC y controla el robot de forma remota a través de programas escritos en Python, Java o C++.
Nuestro prototipo actual es compatible con Myro y robot Scribbler. Esto significa que con solo 3 líneas de código de programación en lenguaje Python ya puede controlar el robot.

{{{
# python
>> from myro import *
>> robotito = Scribbler("/dev/ttyACM0", 9600)
>> robotito.forward(1, 3)
}}}

En el ejemplo anterior el robot avanzaría a máxima velocidad durante tres segundos.



==== Ejemplo utilizando C ====

Si no queremos utilizar myro y python podemos utilizar simplemente ser2net con 
un programa que envie mensajes al robot a traves de sockets. El siguiente [[wiki:EnviarMjs-via-sockets.c Programa Ejemplo en lenguaje C]] mueve el robot via sockets. Download : http://lti.fi.uncoma.edu.ar/trac/chrome/site/getname-socket.c

==== Ejemplo utilizando un Gamepad ====

A traves de Myro y Python tambien se puede manejar el robot con un control de videojuegos ('''gamepad''').

{{{
import time
from myro import *

robotito = Scribbler("/dev/rfcomm0", 9600)
time.sleep(5)
robotito.stop()
while 1: robotito.move(*getGamepad("robot"))
}}}

=== Vision ===

El prototipo cuenta con una camara. La vision debería ser posible (una vez completado el desarrollo de las primitivas graficas del firmware) a través de Myro.

Existen muchisimos ejemplos de como programar el robot para "ver" y actuar en consecuencia (leer los libros de Myro!).

Tambien contamos con primitivas graficas similares, desarrolladas en C como una biblioteca. La integramos temporariamente para que pueda utilizarse via CIAO PROLOG, y que el departamento de Inteligencia Artificial pueda realizar practicas para darle mayor vida.

=== Downloads ===

'''Nuevo! ''' : El código fuente en desarrollo, para todas las capas de software, se encuentra ahora versionado en github :
https://github.com/zrafa/se_uncoma/tree/master/robotitos

  * Firmware (codigo fuente) del robot : 
    * http://lti.fi.uncoma.edu.ar/trac/chrome/site/faiduino-firmware/faiduino-0.1.tar.gz
    * http://lti.fi.uncoma.edu.ar/trac/chrome/site/faiduino-firmware/faiduino-0.2.tar.gz
    * http://lti.fi.uncoma.edu.ar/trac/chrome/site/faiduino-firmware/faiduino-0.3.tar.gz
  * Myro : http://wiki.roboteducation.org/Linux_Setup
    * Instalar myro de la pagina anterior. Luego copiar http://lti.fi.uncoma.edu.ar/trac/chrome/site/myro/scribbler.py en /usr/local/lib/python2.7/dist-packages/myro/robots
  * Myro C++ y C, levemente modificados para nuestro robot :
    * Version C++ 2.3.0 : http://lti.fi.uncoma.edu.ar/trac/chrome/site/myro/myro-cpp.tar.gz
    * Version C++ 2.3.0 : http://lti.fi.uncoma.edu.ar/trac/chrome/site/myro/myro-cpp-2.3.0-0.2.tar.gz
    * Version C : http://lti.fi.uncoma.edu.ar/trac/chrome/site/myro/myro-c.tar.gz
    * Version C : http://lti.fi.uncoma.edu.ar/trac/chrome/site/myro/myro-c-0.2.tar.gz
    * '''Version C con ejemplos de "minima inteligencia"''' : http://lti.fi.uncoma.edu.ar/trac/chrome/site/myro/myro-c-0.3.tar.gz
    * '''Biblioteca de vision basica, necesaria para los ejemplos''' : http://lti.fi.uncoma.edu.ar/trac/chrome/site/extras/faivision.tar.gz


== Documentación y Libros para Leer ==

 * Instrucciones de instalación de Myro : http://wiki.roboteducation.org/Myro_Installation_Manual#Myro_Installation_and_Setup
 * '''Libro para Controlar los Robots con Python y Myro''' : [http://wiki.roboteducation.org/Introduction_to_Computer_Science_via_Robots Learning Computing with Robots]
   * '''Capitulos en ESPAÑOL : '''
   * [http://robots.linti.unlp.edu.ar/img_auth.php/1/15/Capitulo01.pdf  1 El Mundo de los Robots ]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/6/64/Capitulo02.pdf  2 Robots Personales]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/1/10/Capitulo03.pdf  3 Construyendo Cerebros de Robot]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/a/a3/Capitulo04.pdf  4 Percibiendo desde adentro]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/f/f0/Capitulo05.pdf  5 Percibiendo el Mundo]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/5/5c/Capitulo06.pdf  6 Comportamientos de Insecto]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/6/60/Capitulo07.pdf  7 Control de Comportamiento]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/7/7e/Capitulo08.pdf  8 Vistas & Sonidos]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/a/a1/Capitulo09.pdf  9 Procesamiento de Imágenes]
   * [http://robots.linti.unlp.edu.ar/img_auth.php/3/3e/Capitulo10.pdf  10 Inteligencia Artificial]
   * [http://cs.brynmawr.edu/~dkumar/Myro/Text/June09/PDF/Chapter11.pdf  11 Computadoras & Computación]
   * [http://cs.brynmawr.edu/~dkumar/Myro/Text/June09/PDF/Chapter12.pdf  12 Rápido, Barato & Fuera de Control]
 * Manual de referencia de Myro : http://wiki.roboteducation.org/Myro_Reference_Manual
 * El software.

== Próximas Tareas ==

Algunas tareas se dividiran en tareas mas pequeñas obviamente.

 * Gamepad : Funcionando
 * Placa MR3020 con Linux Embebido : Funcionando
 * Portar python a mips (mips: arquitectura de la board embebida) : Realizado
 * Portar prolog o ciao prolog : Pendiente
 * Documentar el prototipo y realizar esquematicos y boards finales : Pendiente
 * Sensores : Sólamente contamos con camara en la board con Linux embebido (funcionando). Faltarian sensores IR y de ultrasonidos?
 * Firmware del robot : En marcha (Tenemos implementado el control de los motores y bluetooth. Tambien una vision minima con primitivas graficas en C)
 * Ejemplos de código en C, C++ y Java para controlar el robot : Parcialmente. En esta wiki mostramos como utilizar C y sockets con ser2net y el robot. Uno puede tomar ese ejemplo para cualquier lenguaje.
 * Portar ser2net a la board Linux embebida : Hecho
 * Documentar como logramos que Myro pueda aceptar un dispositivo serial virtual (/dev/pts/#).
 * Documentar como enviamos


== Detalles de Configuracion temporal ==

Wifi del tplink : "OpenWrt"
ip del tplink : 192.168.2.100

{{{
root@OpenWrt:/etc/config# cat /etc/config/network 

config interface 'loopback'
        option ifname 'lo'
        option proto 'static'
        option ipaddr '127.0.0.1'
        option netmask '255.0.0.0'

config interface 'lan'
        option ifname 'eth0'
        option type 'bridge'
        option proto 'static'
        option ipaddr '192.168.1.201'
        option netmask '255.255.255.0'

config interface 'wifi'
        option proto 'static'
        option ipaddr '192.168.2.100'
        option netmask '255.255.255.0'
}}}

==== Serial con la placa Atmega8 ====

{{{
# cat /etc/ser2net.conf
2000:raw:0:/dev/ttyATH0:9600 8DATABITS NONE -XONXOFF -RTSCTS
# 2000:raw:0:/dev/ttyATH0:19200 8DATABITS NONE -XONXOFF -RTSCTS
}}}

EL arduino quiere 8DATABITS sin control de flujo de ningun tipo.
Ademas es importante el raw:0: porque el 0 hace que nunca libere el serial.

==== Wireless ====

Habilitamos la wifi con 

{{{
root@OpenWrt:~# cat /etc/config/network
config interface 'wifi'
	option proto 'static'
	option ipaddr '192.168.2.100'
	option netmask '255.255.255.0'

root@OpenWrt:~# vi /etc/config/wireless
# option disabled 0
config wifi-iface
	option device   radio0
	option network  wifi
	option mode     ap
	option ssid     OpenWrt
	option encryption none
}}}

==== Iniciar el generador de fotos via web ====

{{{
# cat /root/mjpg-streamer.sh
mjpg_streamer -b -i "input_uvc.so -f 1 -r 160x120" -o "output_http.so -p 8080"
}}}

Tomar una foto desde la PC :

{{{ http://192.168.2.100:8080/?action=snapshot }}}


==== Como iniciar la visualizacion y el serial ====

Iniciar ambas placas pero sin iniciar el mjpg-streamer y ser2net.
Luego, una vez que la red Linux esté funcionando, iniciamos mjpg-streamer y ser2net.
{{{
ssh -l root 192.168.2.100 /root/mjpg-streamer.sh
ssh -l root 192.168.2.100 /usr/sbin/ser2net
}}}

=== Como usar una PC para controlar el robot ===

 * Instalar Myro
 * Encender el robot :
   1. Encender el clon de arduino. Esperar a que los motores realicen un giro hacia atras y adelante (indicacion de que inició correctamente el firmware del AVR).
   2. Encender la placa embebida, y esperar a que Linux inicie el hardware del robot (nos damos cuenta cuando cuatro de los leds de la placa Linux esten encendidos (algunos titilando).
 * Configurar la wireless en nuestra PC para conectarnos al robot :
{{{
# /etc/init.d/network-manager stop
# iwconfig wlan0 essid OpenWrt
# ifconfig wlan0 192.168.2.101
}}}
 * Compilar alguno de los programas ejemplos y testear. Ej:
{{{
gcc -o detectar-bordes-rojos -L/usr/local/lib -lmyro-cpp /usr/local/lib/MyroC.o -lfaivision detectar-bordes-rojos.c 
./detectar-bordes-rojos
}}}

 * Si se utiliza '''Python''' :

{{{
>>> # Faivision
>>> import ctypes
>>> l = ctypes.CDLL('/usr/local/lib/libfaivision.so')
>>> l.faivision_init()
146168264
>>> l.detectar_objetos (1, 1, 160, 120)
 i=0, objetos count : 1
 i=1, objetos count : 1
 i=2, objetos count : 1
 i=3, objetos count : 3836
 i=4, objetos count : 14
-1218739264
>>> l.objeto_porc(3)       # Consultamos color blanco
83                      # 83% de color blanco
>>> l.objeto_x(3)       # Consultamos el "centro" del color blanco
120                     # El centro en X es el pixel 120 

>>> # Moviendo el robot
>>> from myro import *
>>> robo = Scribbler("/dev/pts/23")
>>> robo.getName()
Frankestito
>>> robo.forward(2, .5)
>>> quit()
}}}

=== Instalacion de la Biblioteca de Vision Basica ===

{{{
# Tener instalado libsdl libsdl libsdl-image y libcurl. 
# Tambien los archivos para programacion de esas bibliotecas (cabeceras, etc).
# En mi sistema tengo instalado :
#    libcurl3, libcurl3-gnutls, libcurl3-nss, libcurl4-nss-dev
#    libsdl1.2-dev, libsdl1.2debian, libsdl-image1.2 libsdl-image1.2-dev
#

wget http://lti.fi.uncoma.edu.ar/trac/chrome/site/extras/faivision.tar.gz
tar xvzf faivision.tar.gz
cd faivision
make
sudo cp libfaivision.so /usr/local/lib

# Listo, ya podemos utilizar la biblioteca como en el ejemplo de python
}}}

==== Utilizacion de la Vision Basica ====


{{{
# Funciones
void detectar_objetos(int x1, int y1, int x2, int y2);
void faivision_init(void);
int objeto_x(int c);
int objeto_y(int c);
int objeto_porc(int c);
}}}

 * El robot puede toma fotos de 160x120 pixels.
 * En primer lugar inicializamos SDL con faiviosion_init()
 * Luego, tomamos una imagen de la camara y detectamos los objetos con : detectar_objetos(x1, y1, x2, y2)      # x1, y1, x2, y2 es la seccion de una foto que queremos analizar.
 * Luego, una vez detectado los objetos (los colores), podemos consultar :
    * la posicion central en X de un color con : objeto_x(color)
    * la posicion central en Y de un color con : objeto_y(color)
    * el porcentaje que ocupa un color en la vision actual : objeto_porc(color)
    * rojo=0, verde=1, azul=2, blanco=3, negro=3
    * Los colores que "mejor" observa el robot son el blanco, negro y el rojo

{{{
# Ejemplo en python
>>> import ctypes
>>> l = ctypes.CDLL('/usr/local/lib/libfaivision.so')
>>> l.faivision_init()
146168264
>>> l.detectar_objetos (1, 1, 160, 120)  # Tomamos una foto y detectamos los colores en los 160x120 pixels
 i=0, objetos count : 1
 i=1, objetos count : 1
 i=2, objetos count : 1
 i=3, objetos count : 3836
 i=4, objetos count : 14
-1218739264
>>> l.objeto_porc(3)       # Consultamos el porcentaje que ocupa el color blanco
83                         # 83% de color blanco
>>> l.objeto_x(3)          # Consultamos el "centro" del color blanco
120                        # El centro en X es el pixel 120 
}}}

===== Cómo Obtener y Ver Fotos Tomadas por el Robot =====

http://192.168.2.100:8080/?action=snapshot


== Año 2013 - Notas recordatorias ==

 * ''' NUNCA! ''' utilizar o encender el robot encima de una mesa.
 * EL piso debe ser completamente llano.
 * El robot tiene menos peso este año. Con lo cual admite avanzar mas despacio, '''y ver paredes!!''' (antes las veía, pero tarde; y se estampaba contra la pared pobre)
 * Las baterías y la conexion serial no deben ser manipuladas de manera brusca. Son lo mas delicado del robot.
 * Siempre tomar el robot desde la base. No aplastar.
 * Cuando no haya sincronizacion, o el robot se comporte de manera muuy extraña, es porque seguramente hay que recargar baterias.
 * Se configuró una wifi especial para la red de robots. Se llama (essid) : '''robotsfai''' (10.0.20.0/24)
 
== Fotos y Videos ==

Estos modelos fueron nuestros primeros prototipos. Se mantienen aquí como una manera de recordar la historia.

[[Image(http://lti.fi.uncoma.edu.ar/trac/chrome/site/IMG_9734.JPG, 120px)]] [[Image(http://lti.fi.uncoma.edu.ar/trac/chrome/site/IMG_9735.JPG, 120px)]] [[Image(http://lti.fi.uncoma.edu.ar/trac/chrome/site/version2.jpg, 120px)]] [[Image(http://lti.fi.uncoma.edu.ar/trac/chrome/site/version22.jpg, 120px)]]  


[[Embed(youtube=10ki6rStntk,w=400,h=300)]]

Anteriores :
http://www.youtube.com/watch?v=kn4rZZxcDi0
http://www.youtube.com/watch?v=5xkeqvugC2Y



== Enlaces de Interes ==

http://www.ludep.com/blog/
http://ludep.com/wp-content/uploads/links/20110831_MasterProject_FinalReport_Depoyant_Ludmann.pdf