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 -aLinux 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 ~ $ lsusbBus 001 Device 002: ID 0424:9512 Standard Microsystems Corp.Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hubBus 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.confctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdevupdate_config=1network={ 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 stopwpa_action: ifdown wlan0Configuring interface wlan0=wlan0 (inet)run-parts --verbose /etc/network/if-down.drun-parts: executing /etc/network/if-down.d/upstartrun-parts: executing /etc/network/if-down.d/wpasupplicantrun-parts --verbose /etc/network/if-post-down.drun-parts: executing /etc/network/if-post-down.d/wireless-toolsrun-parts: executing /etc/network/if-post-down.d/wpasupplicantwpa_supplicant: terminating wpa_supplicant daemon via pidfile /var/run/wpa_supplicant.wlan0.pidStopped /sbin/wpa_supplicant (pid 1755).wpa_supplicant: removing /run/sendsigs.omit.d/wpasupplicant.wpa_supplicant.wlan0.pidwpa_action: removing sendsigs omission pidfile: /run/sendsigs.omit.d/wpasupplicant.wpa_supplicant.wlan0.pidpi@escorial ~ $ sudo ifup wlan0
A continuación comprobamos la conectividad:pi@escorial ~ $ sudo wpa_cli statusSelected interface 'wlan0'bssid=d0:71:33:21:d3:c6ssid=WLAN_ABid=0mode=stationpairwise_cipher=CCMPgroup_cipher=CCMPkey_mgmt=WPA2-PSKwpa_state=COMPLETEDip_address=192.168.1.39address=7c:de:70:42:6f:38do
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 subversioncd /usr/src/svn checkout svn://svn.code.sf.net/p/mjpg-streamer/code/ mjpg-streamer-codecd mjpg-streamer/mjpg-streamermake
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/shPLUGINPATH=/usr/src/mjpg-streamer-code/mjpg-streamerSTREAMER=$PLUGINPATH/mjpg_streamerDEVICE=/dev/video0RESOLUTION=320x240FRAMERATE=25HTTP_PORT=8001# check for existing webcam deviceif [ ! -e "/dev/video0" ]; then echo "stream.sh: Error - NO /dev/video0 device" 2>&1 | logger exit 2fi#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 starty$ 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:#importsimport webiopi# Libreria GPIOGPIO = webiopi.GPIO# -------------------------------------------------- ## Definicion constantes ## -------------------------------------------------- ## GPIOs motor izquierdoL1=17 # H-Bridge 1L2=27 # H-Bridge 2# GPIOs motor derechoR1=10 # H-Bridge 3R2=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.macrodef go_forward(): left_forward()@webiopi.macrodef go_backward(): left_backward()@webiopi.macrodef turn_left(): right_forward()@webiopi.macrodef 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.pycambot = /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 configurationenabled = trueport = 8000# File containing sha256(base64("user:password"))# Use webiopi-passwd command to generate itpasswd-file = /etc/webiopi/passwd# Use doc-root to change default HTML and resource files location#doc-root = /home/pi/webiopi/examples/scripts/macrosdoc-root = /home/pi/cambot# Use welcome-file to change the default "Welcome" filewelcome-file = index.html
Para ello posteriormente generaremos el fichero passwd mediante el comando webiopi-passwd:$ sudo webiopi-passwdWebIOPi passwd file generatorEnter Login: webiopiEnter Password: Confirm password: Hash: e70c940a189251e9cd4515b3a1a6c6f02aa05c744a456ce360fe14bf2c5c0353Saved 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:
CamBot 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... ;)
View the original article here
This post was made using the
Auto Blogging Software from
WebMagnates.org This line will not appear when posts are made after activating the software to full version.
Hace poco se publicaron en un foro de 4chan instrucciones falsas para que la nueva consola Xbox One pueda cargar los juegos de la antigua 360. 
Este año hemos superado los 10.000 seguidores en Twitter y hemos conseguido un meritorio séptimo puesto en los premios Bitácoras 2013 (llegando incluso a alcanzar un tercer puesto en las votaciones parciales), pero sobretodo hemos vuelto a disfrutar con la (in)seguridad informática y el hacking a veces ético con cosas tan alucinantes que son hasta difíciles de enumerar. 
Seguro que habéis leído y os ha llamado la atención una noticia reciente en la que se decía que Amazon estaba pensando utilizar drones para repartir paquetes pequeños a sus clientes. La perspectiva de un enjambre pequeño de aviones no tripulados plantea sin embargo una nueva gama de problemas de seguridad... 
Si estás involucrado en la investigación de vulnerabilidades, ingeniería inversa o pruebas de intrusión, seguro que ya habrás utilizado Python porque cuenta con un rico conjunto de librerías y herramientas útiles para estos menesteres. 
Yo sé qué si estáis leyendo esta entrada en este blog teneis en especial consideración la seguridad informática y sois extremadamente cuidadosos con la configuración de la privacidad de vuestras cuentas como la de Facebook... 
