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”.


https://www.raspberrypi.org/downloads/raspbian/

https://sourceforge.net/projects/win32diskimager/


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/webiopi-pi2bplus.patch $ patch -p1 -i webiopi-pi2bplus.patch $ sudo ./setup.sh


http://sourceforge.net/projects/webiopi/files/WebIOPi-0.7.1.tar.gz/download


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-proxy-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/


http://webiopi.trouch.com/





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

Technology