Raspberry Pi Python Rover

RaspberryPi Robot
Autor: Manuel Fernández de Ginzo Muñoz
Tutor: José Antonio Carrasco Díaz
I.E.S. Francisco Romero Vargas (Jerez de la Frontera)
Administración de Sistemas Informáticos en Red
Curso: 2015/16

Proyecto Integrado. ASIR 15/16. Manuel Fernández de Ginzo Muñoz.
Tabla de contenido
Introducción.
Introducción.
Finalidad.
Objetivos.
Medios necesarios.
Planificación.
Realización del Proyecto.
Trabajos realizados.
Problemas encontrados.
Modificaciones sobre el proyecto planteado inicialmente.
Posibles mejoras al proyecto.
Bibliografía.
RaspberryPi Robot. Página 1

Introducción.
Introducción.
Construir un robot que sea controlado remotamente a través de una página web, en
dicha web aparecerán los controles y un video streaming por el cual podemos ver el
camino que va siguiendo el robot a través de una webcam.
Finalidad.
Controlar un robot remotamente a través de una página web desde cualquier
dispositivo que tenga navegador web. También se puede utilizar como cualquier otro
juguete tipo coche teledirigido para niños.
Objetivos.
Controlaremos un robot incorporando una RaspberryPi2 en la cual hay un servidor
web, a través de una página web en la que utilizaremos el framework “webiopi”, esto
nos ayuda a controlar los “GPIO” de la Raspberry a través de una página web,lo que
realmente hace es llamar a funciones escritas en python a través de macros, las cuales
hacen que el robot se mueva, también es posible mover el robot diagonalmente, por
ejemplo, para girar en diagonal hacia la izquierda se debe de reducir la velocidad del
motor derecho y en el motor izquierdo dejar la velocidad por defecto. Podremos ver
un streaming de video en la página web, el cual es ejecutado por la cámara web
incorporada al robot.

Medios necesarios.
Que se va a necesitar para realizar este proyecto, hay que indicar los medios físicos
(hardware) y los medios lógicos (software). Ejemplo: Para la realización de este
proyecto se necesita lo siguiente:
● RaspberryPi2 con caja acrílica.
● 2 motores DC con 2 ruedas
● Interruptor
● Chasis del robot
● Puente H (L298N)
● 6 Pilas AA Alcalinas con su respectivo soporte.
● Cámara para RaspberryPi 2
● PowerBank de 5000mAh, Salida: 5V 2.1A
● Soporte de madera para la RaspberryPi
● ServoMotor
● Raspbian, Webiopi Framework, Python
Planificación.
● Investigación sobre componentes necesarios para llevar a cabo el proyecto: 6
horas.
● Instalación de Raspbian y puesta a punto de la RaspberryPi: 1 hora.
● Montaje del chasis y conexionado con los dos motores: 2 horas.
● Instalación de webiopi y configuración con parcheado para RaspberryPi2: 4
horas
● Comprobación del framework webiopi con RaspberryPi2, manejando los pines
“GPIO”: 1 hora.
● Montaje de la cámara web: 1 hora.
● Montaje del servo y soporte para la cámara: 1 hora.
● Estudiar la manera de controlar nuestro servo con Webiopi, modificar el código
fuente del framework para que pueda trabajar con nuestro servo: 2 horas
● Montaje de los drivers de la cámara en la RaspberryPi, modificación de
parámetros del streaming, comprobación que todo funciona y se puede
gestionar perfectamente: 4 horas.
● Montaje de la tarjeta WiFi USB y puesta a punto: 1 hora.
● Conexionado de todos los cables y proceso de soldar: 2 hora.
● Crear punto de acceso con la tarjeta WiFi USB con servidor DHCP: 3 horas.
● Investigar sobre el envío de pulsos(PWM) a través de los pines “GPIO” a
nuestros motores: 5 horas.
● Aprender a controlar los pines “GPIO” a través de Python: 4 horas.

● Estudiar la estructura de Webiopi para poder crear los botones de dirección y el
“slider” para controlar el servo: 5 horas.
● Planificar las acciones de todos los botones de dirección, por ejemplo, si se le
da hacia delante, enviar un pulso “HIGH” al motor “A” y “B” en la patilla
positiva y establecer la velocidad máxima: 5 horas.
● Pruebas comprobando que funcionan todos los botones de direcciones: 3
horas.
● Pruebas comprobando que funciona el servo a través de la página web: 1 hora.
● Prueba de todo el proyecto en condiciones reales: 8 horas.
● Preparación de la documentación del proyecto: 6 horas.
Horas totales que se planifican para el proyecto: 61
Trabajos Realizados.
Una vez tengamos el chasis del coche con los motores y cables, empezaremos con el
montaje del mismo.
Montamos los soportes de los motores, necesitaremos dos tornillos y dos tuercas. Sólo
pondremos una parte del soporte ya que la otra parte se monta con el chasis. Hacemos
lo mismo con el otro motor.
Añadimos el motor con la otra parte del soporte al chasis. Debemos de introducir los
dos tornillos a través del soporte y del motor hasta sobrepasar el otro soporte. Lo
encajamos con la mueca que trae el chasis. Lo mismo con el otro motor.

Una vez tengamos los dos motores encajados perfectamente en el chasis, pondremos
las ruedas a los motores. Solamente es encajarlas haciendo un poco de fuerza.
Debemos asegurarnos que las dos ruedas están a la misma distancia del chasis.
Ahora instalaremos la rueda delantera en el chasis. Debemos de tener a mano ocho
tornillos, cuatro roscas y la rueda.

Atornillamos primero los cuatro tornillos con las roscas.

A continuación ponemos la rueda y la atornillamos.
Lo próximo que vamos a hacer es colocar el puente H encima del chasis mediante una
presilla.
Antes de ello colocaremos los cables que van hacia los motores a las entradas OUT1 y
2 para el motor A y OUT3 y 4 para el B.

Agarramos el puente H al chasis pasando la presilla por uno de los agujeros del mismo.

También pondremos presillas en la mitad del cable a modo de guía con el fin de no
sobresalir del chasis.

Ahora conectamos los cables del puente H a los motores, el orden es indiferente, ya
que después si queremos, lo podemos manipular mediante software en el caso de que
estén puestos al revés y hacer que la rueda gire hacia delante en vez de al contrario.
Fabricaremos un soporte de madera a medida para soportar la RaspberryPi. Solo
debemos medir las dimensiones de la RaspberryPi y dejarle un poco a cada lado para
que luego no sobresalga tanto el cable de alimentación de la RaspberryPi del soporte.
Tiene dos tornillos altos para dejarle espacio al soporte de pilas que instalaremos
después debajo. Los tornillos estarán sujetos mediante tuercas, en total usaremos 8
tuercas para los dos tornillos.

Instalamos el botón que se utilizará para alimentar los motores.
Soldamos los cables de la siguiente manera al interruptor. Uno de esos cables va al
puente H a la entrada de +12v y el otro cable al positivo del soporte de las pilas.

Ahora colocamos los cables para la parte lógica que se encargará la RaspberryPi.
El pin ENA se utiliza para controlar la velocidad del motor A, IN1 y IN2 se utiliza para
hacer funcionar al motor A. IN3 y IN4 se utiliza para el motor B. ENB se utiliza también
para controlar la velocidad, pero en éste caso, del motor B.
Antes de colocar todos los cables debemos de eliminar los jumpers que están en ENA y
ENB.
Estos jumpers serían útiles en el caso en el que no controlemos la velocidad.
Introducimos dos cables a la entrada GND(Tierra) del puente H. Un cable se utilizará
para el lado negativo del soporte de las pilas y otro iría a un GPIO GND de la
RaspberryPi
En la salida +5V metemos el cable que iría para alimentar el servomotor.

Montamos la RaspberryPi en el soporte de madera. La sujetamos mediante dos
gomillas para facilitar el desmontaje en el caso de que queramos acceder mejor a ella.
El servomotor lo montaremos encima del puerto USB en el cual está el adaptador WiFi
conectado de la RaspberryPi. Está sujeto mediante un alambre que se agarra al
soporte de madera. Debemos de darle forma hasta que quede de una manera que
sujete bien el servomotor.
Para la cámara web vamos a construir un pequeño soporte de madera y pegarlo al
servomotor con cualquier pegamento de fuerte fijación. La cámara es soportada
mediante fiso, ya que no es necesario un soporte tan fijado para el uso que le vamos a
dar.
Conectaremos la cámara a la entrada llamada “camera” de la RaspberryPi. Con un
destornillador plano podemos levantar la parte blanca del conector para luego
introducir el cable de la cámara. Una vez esté fijado apretamos la parte blanca.
Comprobaremos que el cable está correctamente introducido.

Sujetamos la batería para alimentar a la RaspberryPi mediante una presilla en la parte
trasera del chasis.

La batería para alimentar a los motores la colocaremos debajo del soporte de madera
sujetándola mediante otra presilla. Debemos de colocar la presilla de manera que pase
entre pila y pila para después cambiarlas en el caso de que se agoten.

Para ayudarnos a identificar los GPIO podemos utilizar el siguiente esquema.
Las conexiones son las siguientes del puente H a los GPIO:
● ENA => GPIO20
● ENB => GPIO21
● IN1 => GPIO17
● IN2 => GPIO27
● IN3 => GPIO5
● IN4 => GPIO6
Para conectar el servomotor debemos tener en cuenta lo siguiente.
El cable rojo de enmedio es para alimentarlo, tenemos que conectarlo a la salida de
+5V del puente H.
El cable marrón es el GND (Tierra) , debemos conectarlo a un pin de la RaspberryPi
GND.
Y por último, el cable naranja es para controlarlo mediante la RaspberryPi, lo
conectaremos al GPIO4.

Esquema de conexión de los componentes.
Observemos más detalladamente las conexiones lógicas del puente H a los GPIO. De
color verde tenemos las conexiones ENA y ENB, empezando por la izquierda, ENA se
conecta a GPIO20 y ENB a GPIO21. De color naranja tenemos IN1 e IN2, IN1 se conecta

a GPIO17 e IN2 a GPIO27. De color amarillo tenemos IN3 e IN4, IN3 se conecta a GPIO5
e IN4 a GPIO6.
Ahora continuaremos instalando el sistema operativo “Raspbian Jessie” , lo
descargamos en https://www.raspberrypi.org/downloads/raspbian/.
Descargamos también “Win32 Disk Imager” para grabar la imagen en la tarjeta SD.
https://sourceforge.net/projects/win32diskimager/
Ejecutamos “Win32 Disk Imager” , seleccionamos nuestra imagen, la tarjeta SD en la
que se va a grabar y le damos a “Write”.
Conectamos nuestra Raspberry a una pantalla con HDMI para la realizar la
configuración más cómodamente. Nos aparecerá el programa “Raspi-Config”
automáticamente al iniciar, debemos de expandir nuestra tarjeta SD para que
tengamos toda la capacidad de la tarjeta SD ya que si no lo hacemos sólo tendremos
de almacenamiento 4GB. Para ello seleccionamos la opción “Expand Filesystem”.

Si queremos también podemos cambiar la contraseña del usuario “pi”.
Aprovechamos para habilitar la cámara seleccionando “Enable Camera”.
En “Internationalisation Options” configuraremos el idioma del sistema.
Una vez hayamos terminado con la configuración le damos a “Finish”.
A continuación vamos a empezar a hacer los scripts para controlar el robot.
Podemos hacerlo todo mediante SSH o con el cable HDMI conectado a un monitor.
Si queremos controlarla mediante SSH, en “raspi-config” tenemos una opción para
habilitar el servidor SSH, “Advanced options/A4 SSH”.
Nos aseguramos que estamos conectados a Internet mediante la tarjeta Ethernet de
nuestra Raspberry ya que nos va a hacer falta para actualizar y configurar varias cosas.
Ejecutamos “sudo apt-get update” y “sudo apt-upgrade”.
Lo primero que debemos hacer es instalar el framework webiopi, ya que lo
utilizaremos para desarrollar nuestro programa.
Descargamos este archivo:
http://sourceforge.net/projects/webiopi/files/WebIOPi-0.7.1.tar.gz/download
Ahora lo instalamos metiéndonos en el directorio en donde esté y ejecutando el script
de instalación “./setup.sh”.
Ésta versión de webiopi no funciona con nuestra “RaspberryPi2”, pero no hay porque
preocuparse, alguien se encargó de desarrollar un parche para solucionar el problema,
por lo que tendremos que parchearlo con los siguientes comandos:
$wget
https://raw.githubusercontent.com/doublebind/raspi/master/webiop
i-pi2bplus.patch
$ patch -p1 -i webiopi-pi2bplus.patch
$ sudo ./setup.sh

Una vez ejecutados esos comando ya tendremos “Webiopi” compatible para nuestra
RaspberryPi 2.
Ahora establecemos el inicio automático de webiopi cada vez que se inicie el sistema.
$ sudo update-rc.d webiopi defaults
Una vez tengamos webiopi funcionando continuamos con los scripts para controlar el
robot.
Crearemos un nuevo archivo con el nombre que queramos acabado en “.py” ya que
será un script en Python.
# Importamos la librería “webiopi” y “os”
import webiopi
import os
# Le asignamos un alias para trabajar más cómodo.
GPIO = webiopi.GPIO
# GPIOs motor izquierdo
L1=17 # H-Bridge 1
L2=27 # H-Bridge 2
ENB=20 # Velocidad
# GPIOs motor derecho
R1=5 # H-Bridge 3
R2=6 # H-Bridge 4
ENA=21 # Velocidad
Servo=4 # GPIO Servo
# Definición de Macros

# Ir hacia atrás.
@webiopi.macro
def go_backward():
GPIO.pulseRatio(ENA, 0.5)
GPIO.pulseRatio(ENB, 0.5)
GPIO.output(R1, GPIO.HIGH)
GPIO.output(R2, GPIO.LOW)
GPIO.output(L2, GPIO.HIGH)
GPIO.output(L1, GPIO.LOW)
# Ir hacia atrás verticalmente a la derecha.
@webiopi.macro
def go_backwardr():
GPIO.pulseRatio(ENA,0.5)
# Ir hacia atrás verticalmente a la izquierda.
@webiopi.macro
def go_backwardl():
# Ir hacia delante.
@webiopi.macro

def go_forward():
# Ir hacia delante verticalmente hacia la derecha.
@webiopi.macro
def go_forwardr():
# Ir hacia delante verticalmente hacia la izquierda.
@webiopi.macro
def go_forwardl():
# Girar a la izquierda.
@webiopi.macro

def turn_left():
# Girar a la derecha.
@webiopi.macro
def turn_right():
# Detenerse.
@webiopi.macro
def stop():
@webiopi.macro
def shutdown():
os.system(“halt”);

Esta función se utilizará para capturar fotos del streaming.
Se utiliza el método “strftime” para obtener la fecha y hora actual, después la utilizo
para el nombre de la foto.
A continuación se descarga mediante el comando “wget”.
@webiopi.macro
def foto():
tiempo=time.strftime("%d-%m-%y.%I:%M:%S")
ruta="/var/www/fotos/imagenes/"+tiempo+".jpeg"
os.system("wget
http://192.168.1.1:8080/stream/snapshot.jpeg?delay_s=0 -O
"+ruta)
# -------------------------------------------------- #
# Iniciacializacion #
# -------------------------------------------------- #
def setup():
# Instalación GPIOs
GPIO.setFunction(L1, GPIO.OUT)
GPIO.setFunction(L2, GPIO.OUT)
GPIO.setFunction(R1, GPIO.OUT)
GPIO.setFunction(R2, GPIO.OUT)
GPIO.setFunction(ENB, GPIO.PWM)
GPIO.setFunction(ENA, GPIO.PWM)
GPIO.setFunction(Servo, GPIO.PWM)
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)
GPIO.setFunction(ENB, GPIO.IN)
GPIO.setFunction(ENA, GPIO.IN)
GPIO.setFunction(Servo, GPIO.IN)
Una vez tengamos el script creado y guardado, editamos el archivo
“/etc/webiopi/config” y en la parte de scripts introducimos la ruta de nuestro script.
[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
robot = /home/pi/scripts/robot.py
Aprovechamos para cambiarle la contraseña de acceso a la web de control del robot.
Con el comando “webiopi-passwd” generamos un fichero “passwd”.
En el fichero “/etc/webiopi/config” podemos introducir la ruta de nuestro archivo
“passwd”
# File containing sha256(base64("user:password"))
# Use webiopi-passwd command to generate it
passwd-file = /etc/webiopi/passwd
Ahora creamos el “.html” en el que aparecerán todos los controles del robot.
Llamamos al framework webiopi para poder usarlo en nuestro html.
<script type="text/javascript" src="/webiopi.js"></script>
Empezamos a crear los botones con la ayuda de webiopi y el
método “createButton”.

Los parámetros que recibe éste método son (“ID html con el que
aparecerá el botón”,”valor del botón”,función a la que llama
cuando hacemos click, función a la que llama cuando dejamos de
hacer click).
También hemos creado un botón para apagar el robot, para ello
utilizamos la función “shutdown” que llama a una macro en python
que se encarga de ejecutar el comando “halt” en el sistema.
<script type="text/javascript">
function init() {
var button;
button = webiopi().createButton("bt_upr", "/",
go_forwardr, stop);
$("#up").append(button);
button = webiopi().createButton("bt_up", "/",
go_forward, stop);
button = webiopi().createButton("bt_upl", "/",
go_forwardl, stop);
button = webiopi().createButton("bt_left", "<",
turn_left, stop);
$("#middle").append(button);
button = webiopi().createButton("bt_right", ">",
turn_right, stop);
$("#middle").append(button);
button = webiopi().createButton("bt_downl", "/",
go_backwardl, stop);
$("#down").append(button);

button = webiopi().createButton("bt_down", "/",
go_backward, stop);
button = webiopi().createButton("bt_downr", "/",
go_backwardr, stop);
button = webiopi().createAngleSlider(4);
$("#servo").append(button);
button = webiopi().createButton("shutdown", "O",
shutdown);
}
function go_forward() {
webiopi().callMacro("go_forward");
}
function go_forwardr() {
webiopi().callMacro("go_forwardr");
}
function go_forwardl() {
webiopi().callMacro("go_forwardl");
}
function go_backward() {
webiopi().callMacro("go_backward");
}
function go_backwardr() {
webiopi().callMacro("go_backwardr");
}
function go_backwardl() {

webiopi().callMacro("go_backwardl");
}
function turn_right() {
webiopi().callMacro("turn_right");
}
function turn_left() {
webiopi().callMacro("turn_left");
}
function stop() {
webiopi().callMacro("stop");
}
function shutdown() {
alert(“Apagando...”);
webiopi().callMacro(“shutdown”);
}
function foto() {
webiopi().callMacro(“foto”);
}
webiopi().ready(init);
</script>
</head>
<body>
Creamos los div para los botones y el servo.
Añadimos una etiqueta “IMG” con la ruta
“http://192.168.1.1:8080/stream/video.mjpeg” para el streaming
que instalaremos más adelante.
<div id="content" align="center">

<img class=”streaming” onclick=”foto()”
src="http://192.168.1.1:8080/stream/video.mjpeg"/>
<div id="up"></div>
<div id="middle"></div>
<div id="down"></div>
<div id="servo"></div>
<a href=”http://galeria.robot”>Galería de Imágenes</a>
</div>
</body>
</html>
Ahora empezaremos a configurar el streaming de video.
Para ello debemos de tener instalado los paquetes “libjpeg8-dev”, “imagemagick”
,”subversion”.
Ejecutaremos los siguientes comandos:
wget http://www.linux-projects.org/listing/uv4l_repo/lrkey.asc
&& sudo apt-key add ./lrkey.asc
echo "deb
http://www.linux-projects.org/listing/uv4l_repo/raspbian/ wheezy
main" | sudo tee -a /etc/apt/sources.list
sudo apt-get update
sudo apt-get install uv4l uv4l-raspicam uv4l-raspicam-extras
uv4l-server uv4l-uvc uv4l-xscreen uv4l-mjpegstream
sudo reboot
Una vez introducidos estos comandos, tendremos listo nuestro servidor de streaming.
Ahora configuraremos nuestra raspberry para que cree una red WiFi a la que nos
podamos conectar para controlar el robot.
Lo primero que debemos hacer es instalar un servidor DHCP para que de IP a los
clientes con el comando “apt-get install isc-dhcp-server”.
Después editamos el siguiente archivo "/etc/dhcp/dhcpd.conf” , buscamos estas lineas
y las comentamos.

# option domain-name "example.org";
# option domain-name-servers ns1.example.org, ns2.example.org;
Ahora buscamos estas lineas y descomentamos la parte de “authoritative”.
# If this DHCP server is the official DHCP server for the local
# network, the authoritative directive should be uncommented.
authoritative;
Ahora abajo del todo introducimos nuestra configuración para dar IP a los clientes de
la siguiente manera.
subnet 192.168.1.0 netmask 255.255.255.0 {
range 192.168.1.2 192.168.1.3;
option broadcast-address 192.168.1.255;
option routers 192.168.1.1;
default-lease-time 600;
max-lease-time 7200;
option domain-name-servers: 192.168.1.1;
}
Guardamos los cambios y nos vamos ahora a editar el archivo
“/etc/default/isc-dhcp-server”. En la parte que aparece “INTERFACES” pondremos
“wlan0” y guardamos.
Ahora en “/etc/network/interfaces” establecemos una IP estática para nuestra
raspberry.
iface wlan0 inet static
address 192.168.1.1
netmask 255.255.255.0
Ya tenemos configurado nuestro servidor DHCP. Ahora vamos a configurar el punto de
acceso.
Creamos un archivo aquí “/etc/hostapd/hostapd.conf”.
Introducimos lo siguiente dentro de él.
interface=wlan0
driver=rtl871xdrv
ssid=Pi_AP
hw_mode=g
channel=6
macaddr_acl=0

auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_passphrase=Raspberry
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP
Ahora le diremos a la raspberry donde esta el archivo de configuracion, entramos en
“/etc/default/hostapd” y en la parte que aparece “#DAEMON_CONF=""” introducimos
la ruta del archivo que creamos anteriormente. Quedaría de la siguiente manera.
DAEMON_CONF="/etc/hostapd/hostapd.conf"
Reiniciamos la Raspberry y ya tendremos nuestro punto de acceso funcionando.
Ahora configuraremos nuestra Raspberry para que redireccione las peticiones al
puerto 80 de Apache al 8000 de Webiopi, para ello necesitamos hacer un proxy inverso
con apache.
Debemos de tener en cuenta de que el servidor web de webiopi está escuchando en el
puerto 8000, para comprobarlo nos vamos a “/etc/webiopi/config” y en la línea donde
aparece “port” debe de aparecer “8000”.
Comenzamos con la instalación de Apache, para ello ejecutamos el comando “apt-get
install apache2”
Para que apache haga de proxy inverso debemos de tener los siguientes módulos:
● proxy
● proxy_ajp
● proxy_http
● rewrite
● deflate
● headers
● proxy_connect
● proxy_html
Los habilitaremos de la siguiente manera “a2enmod [nombre_módulo]”.
En nuestro caso nos hace falta instalar el módulo “proxy_html” ya que por defecto no
se encuentra instalado, para ello ejecutamos “apt-get install
libapache2-mod-proxy-html”. Ahora lo habilitamos con el comando “a2enmod”.
Una vez estén todos los módulos activados comenzamos con el archivo de
configuración, nos vamos a “/etc/apache2/sites-availables” ,borramos el sitio por
defecto y creamos uno nuevo con lo siguiente:
<VirtualHost *:80>
ProxyPreserveHost On

ServerName controles.robot
ProxyPass / http://192.168.1.1:8000/
ProxyPassReverse / http://192.168.1.1:8000/
</VirtualHost>
Ahora tenemos que instalar “bind9” para tener nuestro servidor DNS, ejecutamos
“apt-get install bind9”.
Nos vamos a “/etc/bind/” y creamos el archivo “db.robot” con lo siguiente:
; BIND reverse data file for empty rfc1918 zone
;
; DO NOT EDIT THIS FILE - it is used for multiple zones.
; Instead, copy it, edit named.conf, and use that copy.
;
$TTL 86400
@ IN SOA robot. root.robot. (
1 ; Serial
604800 ; Refresh
86400 ; Retry
2419200 ; Expire
86400 ) ; Negative Cache TTL
;
@ IN NS ns1.robot.
ns1 IN A 192.168.1.1
controles IN A 192.168.1.1
galeria IN A 192.168.1.1
Editamos el archivo “named.conf.local” y añadimos una nueva zona:
//
// Do any local configuration here
//
// Consider adding the 1918 zones here, if they are not used in
your
// organization

//include "/etc/bind/zones.rfc1918";
zone "robot"{
type master;
file "/etc/bind/db.robot";
};
Configuramos la página web que mostrará las fotos realizadas con el robot. Para ello
creamos también un host virtual en apache para que pueda trabajar con nuestro DNS.
<VirtualHost *:80>
ServerName galeria.robot
DocumentRoot /var/www/fotos
</VirtualHost>
Aquí tenemos el código PHP que he utilizado para mostrar las fotos. Lo primero que
hago es mediante “scandir” meter todos los nombres de los ficheros que se
encuentran en el directorio en un array. A continuación compruebo si se encuentra
“.jpeg” en el nombre de esos ficheros, si es así, los muestro.
También es posible descargar la foto haciendo click sobre ella mediante el atributo de
HTML5 “download”.
<?php
$directorio = "imagenes/";
$ficheros = scandir($directorio);
for ($i = 0; $i<=count($ficheros); $i++){
if (strrpos("$ficheros[$i]",".jpeg") > 0)
echo "<a href='imagenes/$ficheros[$i]'
download='$ficheros[$i]'><img title='$ficheros[$i]' src='image$
}
?>
Una vez configurado todo el DNS reiniciamos Apache y Bind.
Ya está todo listo para funcionar, para entrar en la página web de controles del robot
nos conectamos a la red WiFi que crea y introducimos en nuestro navegador web la

dirección “controles.robot” y entraremos en la página web que creamos
anteriormente con todos sus controles junto al streaming.
Problemas encontrados.
Tuve que cambiarle las pilas a unas alcalinas con más amperaje y añadirle dos más, ya
que no tenía suficiente fuerza para realizar el PWM (control de pulsos) a los motores.
Al instalar WebioPi no pude controlar los GPIO del todo bien ya que, hasta la fecha,
WebioPi no ha sacado ninguna versión para la RaspberryPi2, tuve que bajarme un
parche hecho por un desarrollador en Github.
La tarjeta de red WiFi no es compatible del todo para establecerla como punto de
acceso mediante los archivos de configuración de Raspbian. Tuve que investigar sobre
ello y encontrar los archivos de configuración de Adafruit.
Tuve que sustituir la “PowerBank” que alimenta la Raspberry ya que la que tenía
inicialmente no ofrecía los suficientes amperios que necesitaba la Raspberry para
trabajar con todos los componentes conectados.
Modificaciones sobre el proyecto planeado inicialmente.
Al principio tenía pensado en controlar el robot mediante Python sin ayuda de ningún
framework, pero investigando encontré WebioPi y ví que tendría menos problemas.
También quería controlarlo mediante un adaptador Bluetooth, sin embargo decidí
hacerlo mediante WiFi ya que su cobertura es mejor.

La cámara inicialmente no tenía pensado de que se pudiera controlar su posición
mediante un servo, sería fija, pero más adelante investigué sobre el control de servos
mediante WebioPi.
Posibles mejoras del proyecto.
Como principal mejora, sería interesante implementar el control remoto desde
Internet mediante VPN. También, sería una buena opción tener la misma aplicación
pero desarrollada en Android.
No sé si RaspberryPi 2 puede implementar la tecnología WOW (Wake On Wifi), he
estado investigando sobre ello y solo he encontrado que es posible mediante WOL
(Wake On Lan), esta opción no sería interesante para éste proyecto porque tendría
que estar conectado por Ethernet.
A modo de asistencia remota, sería interesante la opción de comunicarse mediante el
robot remotamente desde Internet a la casa como si de una llamada se tratase.
Bibliografía.
http://webiopi.trouch.com/
https://www.digitalocean.com/community/tutorials/how-to-use-apache-http-server-as-reverse-pr
oxy-using-mod_proxy-extension
http://www.home-automation-community.com/surveillance-with-raspberry-pi-noir-camera-howto
/
http://www.linux-projects.org/modules/sections/index.php?op=viewarticle&artid=14
https://learn.adafruit.com/setting-up-a-raspberry-pi-as-a-wifi-access-point/install-software
https://sourceforge.net/p/raspberry-gpio-python/wiki/Home/
https://www.raspberrypi.org/help/

Raspberry Pi Python Rover

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (16)

Similar a Raspberry Pi Python Rover

Similar a Raspberry Pi Python Rover (20)

Último

Último (20)

Raspberry Pi Python Rover