Construye tu propio rover teledirigido con Raspberry Pi y WebIOPi

Para aprender cómo funciona la GPIO (General-purpose input/output) de Raspberry Pi he montado un pequeño rover motorizado que captura vídeo en tiempo real mediante una cámara USB y que puede ser controlado remotamente.

Quiero advertir que ya existen trabajos similares y productos prefabricados mejor acabados y seguramente con mayor rendimiento, pero si te interesara diseñar y hacer funcionar tu propio robot casero entonces te invito a que sigas leyendo :D

Eligiendo el hardware y conectando todo

La base es un viejo coche de control remoto por radiofrecuencia que compré hace años en un bazar chino. Sobre éste gira el proyecto: dos motores de corriente continua (DC) moviendo dos ejes para las ruedas de marcha adelante/atrás y dirección derecha/ izquierda:

Para mover los motores necesitamos un controlador H-Bridge o puente en H que no es más que un circuito electrónico que permite aplicar un voltaje a través de una carga en cualquier dirección, es decir, invertir la polaridad a nuestra elección para mover el motor en una dirección u otra. Además estos puentes en H permiten cortocircuitar para frenar en seco el motor o desconectar hasta su detención libre (free-run).

En este caso he elegido el módulo L298N, un controlador dual H-Bridge bastante popular y económico (4,35€) pero lo suficientemente potente como para impulsar motores de 5 a 35V y de hasta 2A. 

Además proporciona un regulador de 5V integrado que puede ser utilizado para alimentar otras partes de la circuitería del robot:

En la base del coche de control remoto encastamos los dos módulos. 

La Raspberry Pi es alimentada a través del conector micro USB con una batería SWPKPOWER SW-A22617 (6,20€) que ofrece una salida de 5V/800mA y una capacidad de 2600mAh y el controlador L298N recibe el suministro eléctrico mediante una pila de petaca Duracell de 9V alcalina (2,55€) con 565 mAh conectada al pin VCC y a GND. También es necesario conectar el pin 6 de la RPi a tierra.

Después conectamos los motores del coche a los pines de las salidas correspondientes: Motor A o izquierdo y Motor B o derecho e interconectamos los pines IN1, 2, 3 y 4 a las salidas digitales de la GPIO de la RPi (17, 27 y 10, 9 respectivamente).

El siguiente paso es puentear con jumpers los pines ENA y ENB a 5V para activar cada uno de los canales. 

Una opción interesante sería no usar los jumpers y conectar 2 pines de la GPIO de la Raspberry Pi a los pines ENA y ENB del controlador y configurarlos como PWM (modulación por ancho de pulsos) para regular el consumo y la velocidad de los motores. Si bien lo he descartado en este proyecto porque con los motores actuales al disminuir la cantidad de energía apenas podían arrancar y llevar la carga (mover el robot).

El esquema físico queda entonces de la siguiente manera:

Fijaros también que aprovecharemos los dos puertos USB para conectar un nano adaptador inalámbrico modelo RaLink RT5370 (6,75€) mediante el cual controlaremos nuestro rover y una webcam de 1,3M con micrófono integrado (6,20€) para el stream de video.

Si sumamos cables y la carcasa para la pila de petaca, el coste total aproximado del hardware utilizado ronda los 80€. El resultado final es este:

Configurando la red inalámbrica de nuestro robot

Damos un giro a la parte del software. El sistema operativo de la Raspberry Pi para este proyecto es Raspbian con un kernel 3.6:

pi@escorial ~ $ uname -a
Linux escorial 3.6.11+ #538 PREEMPT Fri Aug 30 20:42:08 BST 2013 armv6l GNU/Linux

Lo primero que vamos a hacer es configurar la red inalámbrica para poder controlar nuestro rover remotamente por ssh. Para ello conectamos el dongle USB y comprobamos que se detecta correctamente:

pi@escorial ~ $ lsusb
Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp.
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp.
Bus 001 Device 004: ID 148f:5370 Ralink Technology, Corp. RT5370 Wireless Adapter

[root@escorial ~]# lsusb -vs 001:004

Ahora, para conectarnos a nuestra red WiFi, tenemos que editar el fichero  wpa_supplicant.conf y configurar el SSID con la clave compartida correspondiente:

pi@escorial ~ $ sudo vi /etc/wpa_supplicant/wpa_supplicant.conf
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1


network={
        ssid="WLAN_AB"
        psk="****************"
}

Después paramos el interfaz inalámbrico y volvemos a levantarlo para recargar la configuración:

pi@escorial ~ $ sudo wpa_action wlan0 stop
wpa_action: ifdown wlan0
Configuring interface wlan0=wlan0 (inet)
run-parts --verbose /etc/network/if-down.d
run-parts: executing /etc/network/if-down.d/upstart
run-parts: executing /etc/network/if-down.d/wpasupplicant
run-parts --verbose /etc/network/if-post-down.d
run-parts: executing /etc/network/if-post-down.d/wireless-tools
run-parts: executing /etc/network/if-post-down.d/wpasupplicant
wpa_supplicant: terminating wpa_supplicant daemon via pidfile /var/run/wpa_supplicant.wlan0.pid
Stopped /sbin/wpa_supplicant (pid 1755).
wpa_supplicant: removing /run/sendsigs.omit.d/wpasupplicant.wpa_supplicant.wlan0.pid
wpa_action: removing sendsigs omission pidfile: /run/sendsigs.omit.d/wpasupplicant.wpa_supplicant.wlan0.pid
pi@escorial ~ $ sudo ifup wlan0

A continuación comprobamos la conectividad:

pi@escorial ~ $ sudo wpa_cli status
Selected interface 'wlan0'
bssid=d0:71:33:21:d3:c6
ssid=WLAN_AB
id=0
mode=station
pairwise_cipher=CCMP
group_cipher=CCMP
key_mgmt=WPA2-PSK
wpa_state=COMPLETED
ip_address=192.168.1.39
address=7c:de:70:42:6f:38
do

Preparando el streaming de video

Para el streaming de vídeo con la webcam USB utilizamos MJPG-streamer, una aplicación que captura JPG de webcams compatibles con Linux-UVC, sistema de archivos u otros plugins de entrada y los distribuye como M-JPEG a través de HTTP para navegadores web, VLC y otros programas. Es el sucesor de uvc-streamer, una aplicación de streaming de Linux-UVC con Pan/Tilt.

La instalación sólo requiere unos sencillos pasos:

apt-get install libjpeg8-dev imagemagick subversion
cd /usr/src/
svn checkout svn://svn.code.sf.net/p/mjpg-streamer/code/ mjpg-streamer-code
cd mjpg-streamer/mjpg-streamer
make

Para probarlo ejecutamos el siguiente comando:

pi@escorial /usr/src/mjpg-streamer-code/mjpg-streamer $ sudo ./mjpg_streamer -i "./input_uvc.so -y -n " -o "./output_http.so -n -w ./www"
MJPG Streamer Version: svn rev: 3:172
 i: Using V4L2 device.: /dev/video0
 i: Desired Resolution: 640 x 480
 i: Frames Per Second.: 5
 i: Format............: YUV
 i: JPEG Quality......: 80
 o: www-folder-path...: ./www/
 o: HTTP TCP port.....: 8080
 o: username:password.: disabled
 o: commands..........: disabled

Ahora configuramos un pequeño script para cuando queramos lanzar el stream de video en background:

#!/bin/sh

PLUGINPATH=/usr/src/mjpg-streamer-code/mjpg-streamer
STREAMER=$PLUGINPATH/mjpg_streamer
DEVICE=/dev/video0
RESOLUTION=320x240
FRAMERATE=25
HTTP_PORT=8001

# check for existing webcam device
if [ ! -e "/dev/video0" ]; then
  echo "stream.sh: Error - NO /dev/video0 device" 2>&1 | logger
  exit 2
fi

#PLUGINPATH=/usr/local/lib

$STREAMER -i "$PLUGINPATH/input_uvc.so -y -n -d $DEVICE -r $RESOLUTION -f $FRAMERATE" -o "$PLUGINPATH/output_http.so -n -p $HTTP_PORT" -b

Controlando la GPIO de Raspberry Pi con WebIOPI

Webiopi es un API escrita en Python para controlar, depurar y utilizar la GPIO de la RPi localmente o de forma remota, desde un navegador o desde cualquier aplicación. 

La utilizaremos porque nos permite ejecutar el proyecto muy rápidamente sin necesidad de tener demasiados conocimientos.

Su licencia es Apache License 2.0 y sus características son:

- API REST a través de HTTP y COAP (draft-14) con soporte multicast
- Servidor escrito en Python con cero dependencias
- Soporta GPIO, Serial, I2C, SPI, 1-Wire con cero dependencias
- Soporta más de 30 dispositivos, incluyendo DAC, ADC, sensores ...
- Completa biblioteca de Python para el servidor, GPIO, I2C, SPI, conductores y dispositivos de serie
- Compatible con Python 2 y 3
- Extensible y altamente personalizable
- Incluye protección de Usuario / clave
- Compatible con dispositivos móviles
- Incluye las aplicaciones web de depuración
        . GPIO Header
        . Lista GPIO
        . Monitor Serial
        . Monitor Dispositivos
- Biblioteca cliente Javascript construida sobre jQuery
- Biblioteca cliente Python con HTTP y soporte CoAP

Para instalarlo sólo necesitaremos Python, ya sea la versión 2.7 o la 3.2. Simplemente hay que descargar y extraer el paquete. El script de instalación se encargará automáticamente de descargar e instalar las dependencias requeridas usando apt-get. 

Si no utilizas Raspbian es posible que tengas que instalar los encabezados de desarrollo de  GCC y Python.

$ wget http://webiopi.googlecode.com/files/WebIOPi-0.6.0.tar.gz
$ tar xvzf WebIOPi-0.6.0.tar.gz
$ cd WebIOPi-0.6.0
$ sudo ./setup.sh

Ahora podemos llamar a webiopi directamente desde la línea de comandos:

$ sudo webiopi [-h] [-c config] [-l log] [-s script] [-d] [port]

    Options:
      -h, --help           Display this help
      -c, --config  file   Load config from file
      -l, --log     file   Log to file
      -s, --script  file   Load script from file
      -d, --debug          Enable DEBUG

    Arguments:
      port                 Port to bind the HTTP Server

Sin embargo perderemos el servidor y el estado de la GPIO tan pronto como paremos el script (CTRL-C) o cerremos el terminal.

Por ello es necesario iniciar el servicio en background mediante:

$ sudo /etc/init.d/webiopi start
y
$ sudo /etc/init.d/webiopi stop

Si queremos que webiopi se inicie automáticamente cuando arranque de la RPi podemos utilizar el siguiente comando:

$ sudo update-rc.d webiopi defaults

La base del código fuente se basa en dos artículos publicados en la revista MagPI (Cambot). Primero modificaremos su script en Python en /home/pi/cambot/cambot.py en el que definiremos el estado inicial de los pines de la GPIO y las macros que podrán ser llamadas externamente:

#imports
import webiopi

# Libreria GPIO
GPIO = webiopi.GPIO

# -------------------------------------------------- #
# Definicion constantes                           #
# -------------------------------------------------- #

# GPIOs motor izquierdo
L1=17  # H-Bridge 1
L2=27 # H-Bridge 2

# GPIOs motor derecho
R1=10 # H-Bridge 3
R2=9 # H-Bridge 4

# -------------------------------------------------- #
# Funciones motor izquierdo                          #
# -------------------------------------------------- #

def left_stop():
    GPIO.output(L1, GPIO.LOW)
    GPIO.output(L2, GPIO.LOW)
    

def left_forward():
    GPIO.output(L1, GPIO.HIGH)
    GPIO.output(L2, GPIO.LOW)
    
def left_backward():
    GPIO.output(L1, GPIO.LOW)
    GPIO.output(L2, GPIO.HIGH)

# -------------------------------------------------- #
# Funciones motor derecho                            #
# -------------------------------------------------- #

def right_stop():
    GPIO.output(R1, GPIO.LOW)
    GPIO.output(R2, GPIO.LOW)

def right_forward():
    GPIO.output(R1, GPIO.HIGH)
    GPIO.output(R2, GPIO.LOW)

def right_backward():
    GPIO.output(R1, GPIO.LOW)
    GPIO.output(R2, GPIO.HIGH)

# -------------------------------------------------- #
# Definicion macros                               #
# -------------------------------------------------- #

@webiopi.macro
def go_forward():
    left_forward()

@webiopi.macro
def go_backward():
    left_backward()

@webiopi.macro
def turn_left():
    right_forward()

@webiopi.macro
def turn_right():
    right_backward()

@webiopi.macro    
def stop():
    left_stop()
    right_stop()
    
# -------------------------------------------------- #
# Iniciacializacion                                  #
# -------------------------------------------------- #

def setup():
# Instalacion GPIOs
    GPIO.setFunction(L1, GPIO.OUT)
    GPIO.setFunction(L2, GPIO.OUT)

    GPIO.setFunction(R1, GPIO.OUT)
    GPIO.setFunction(R2, GPIO.OUT)


def destroy():
    # Resetea las funciones GPIO
    GPIO.setFunction(L1, GPIO.IN)
    GPIO.setFunction(L2, GPIO.IN)

    GPIO.setFunction(R1, GPIO.IN)
    GPIO.setFunction(R2, GPIO.IN)

Como podéis ver en el código la configuración es sumamente sencilla. Se inicializan en OUT un par de pines para controlar cada motor y simplemente cambiando su estado (HIGH o LOW) es posible definir macros para cada movimiento.

Para que este script sea llamado al iniciar el servidor webiopi tendremos que especificarlo en el fichero de configuración /etc/webiopi/config. Para ello vamos al fichero config y especificamos la ruta en la sección de scripts:

[SCRIPTS]
# Load custom scripts syntax :
# name = sourcefile
#   each sourcefile may have setup, loop and destroy functions and macros
#myscript = /home/pi/webiopi/examples/scripts/macros/script.py
cambot = /home/pi/cambot/cambot.py

Y aprovechando en este mismo fichero revisaremos el document root y el fichero index e indicaremos que se utilicen las credenciales del fichero passwd:

[HTTP]
# HTTP Server configuration
enabled = true
port = 8000

# File containing sha256(base64("user:password"))
# Use webiopi-passwd command to generate it
passwd-file = /etc/webiopi/passwd

# Use doc-root to change default HTML and resource files location
#doc-root = /home/pi/webiopi/examples/scripts/macros
doc-root = /home/pi/cambot

# Use welcome-file to change the default "Welcome" file
welcome-file = index.html

Para ello posteriormente generaremos el fichero passwd mediante el comando webiopi-passwd:

$ sudo webiopi-passwd
WebIOPi passwd file generator
Enter Login: webiopi
Enter Password: 
Confirm password: 

Hash: e70c940a189251e9cd4515b3a1a6c6f02aa05c744a456ce360fe14bf2c5c0353
Saved to /etc/webiopi/passwd

Una buena idea teniendo en cuenta que de esta manera no almacenaremos  en claro la contraseña de acceso…

Finalmente creamos el fichero index.html en el document root especificado con los controles correspondientes usando jQuery y todas las funciones de javascript para a llamar a las macros escritas en Python. Fijaros que también incrustaremos (IMG) el streaming de video:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <meta name="viewport" content = "height = device-height, width = 420, user-scalable = no" /> 
    <title>CamBot</title>
    <script type="text/javascript" src="/webiopi.js"></script>
    <script type="text/javascript">
    function init() {
        var button;
            
        button = webiopi().createButton("bt_up", "/\\", go_forward, stop);
        $("#up").append(button);
        
        button = webiopi().createButton("bt_left", "<", turn_left, stop);
        $("#middle").append(button);
        
        button = webiopi().createButton("bt_stop", "X", stop);
        $("#middle").append(button);
        
        button = webiopi().createButton("bt_right", ">", turn_right, stop);
        $("#middle").append(button);
        
        button = webiopi().createButton("bt_down", "\\/", go_backward, stop);
        $("#down").append(button);
    }
    
    function go_forward() {
        webiopi().callMacro("go_forward");
    }
        
    function go_backward() {
        webiopi().callMacro("go_backward");
    }
        
    function turn_right() {
        webiopi().callMacro("turn_right");
    }
        
    function turn_left() {
        webiopi().callMacro("turn_left");
    }
        
    function stop() {
        webiopi().callMacro("stop");
    }
    
    webiopi().ready(init);
        
    </script>
    <style type="text/css">
        button {
            margin: 5px 5px 5px 5px;
            width: 50px;
            height: 50px;
            font-size: 24pt;
            font-weight: bold;
            color: black;
        }
    </style>
</head>
<body>
    <div id="content" align="center">
        <img width="320" height="240" src="http://192.168.1.37:8001/?action=stream"><br/>
        <div id="up"></div>
        <div id="middle"></div>
        <div id="down"></div>
    </div>
</body>
</html>

 Y ya está. Sólo nos queda reiniciar el servidor webiopi para cargar la nueva configuración:

$ sudo /etc/init.d/webiopi restart

¡A jugar!

Antes de empezar os animo a ver la aplicación GPIO Header que permite visualizar y controlar cada uno de los pines de la RPi. Para ello abrimos en el navegador la URL: 

http://raspberry:8000/app/gpio-header

Como podéis comprobar es posible cambiar el estado de cada pin sólo mediante un clic.

Ahora abriremos la url principal de nuestro frontal web:

http://raspberry:8000/ 

Y bueno, aquí os dejo un breve vídeo con el resultado:

Carencias, mejoras y próximos pasos

Como comentaba al principio quien decida basarse en esta entrada o similares para crear un rover de estas características tendrá que tener como objetivo principal el aprendizaje y no un rendimiento demasiado excelso.

Primero, las limitaciones de la webcam y del interfaz USB mediante el cual se conecta a la RPi harán que el streaming de vídeo denote un retardo que degradará en parte la experiencia del usuario. Si se quiere mejorar en este aspecto se tendría que pensar en la compra de la cámara por hardware que se conecta internamente y directa al procesador sin hacer uso de ningún chipset intermedio, utilizando el interfaz CSi dedicado que trae de serie. Con esto se mejorará ostensiblemente la tasa de fps (imágenes por segundo).

A parte del streaming de vídeo también se podría añadir al frontal web un botón para realizar una instantánea (a mayor resolución) y una opción para respaldar estas capturas (video y fotos) a algún servicio de almacenamiento en la nube tipo Dropbox.

Segundo, los motores del coche de radiocontrol reciclados son algo "vagos" y en cuanto la capacidad de las baterías disminuye sufren para mover la carga.
En este caso también podrían sustituirse y se podría modular por pulsos para controlar la velocidad del giro.

Si os dais cuenta en la protoboard delantera he realizado algunas conexiones para poner en serie la pila de 9V con las tres pilas AA (4,5V) que originalmente tenía el coche para ganar algo de potencia.

Por último, aunque eso ya será en otras entradas, tengo pendiente añadir más funcionalidades mediante sensores de ultrasonidos, detección de movimiento, leds, laser y reconocimiento por voz. 

Por supuesto, se admiten sugerencias... ;)