Fuente: www.elladodelmal.com
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.
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... ;)
