Telecomunicacióntauja.ujaen.es/bitstream/10953.1/6687/1/TFGSaraRiveroMartinderueda... · Arduino...
104
Escuela Politécnica Superior de Linares Grado en Ingeniería de Tecnologías de Telecomunicación UNIVERSIDAD DE JAÉN Escuela Politécnica Superior de Linares Trabajo Fin de Grado ______ DESARROLLO DE APLICACIÓN WIRELESS BASADO EN SISTEMAS DE RADIO INTEGRADA EASYRADIO Alumno: Sara Rivero Martín de ruedas Tutor: Prof. D. Raúl Mata Campos Depto.: Ingeniería de Telecomunicación Octubre, 2016
Transcript of Telecomunicacióntauja.ujaen.es/bitstream/10953.1/6687/1/TFGSaraRiveroMartinderueda... · Arduino...
1
Esc
uel
a P
oli
técn
ica
Sup
erio
r de
Lin
ares
Gra
do e
n In
geni
ería
de
Tec
nolo
gías
de
Tel
ecom
unic
ació
n
UNIVERSIDAD DE JAÉN
Escuela Politécnica Superior de Linares
Trabajo Fin de Grado
______
DESARROLLO DE
APLICACIÓN WIRELESS
BASADO EN SISTEMAS DE
RADIO INTEGRADA
EASYRADIO
Alumno: Sara Rivero Martín de ruedas
Tutor: Prof. D. Raúl Mata Campos
Depto.: Ingeniería de Telecomunicación
Octubre, 2016
2
UNIVERSIDAD DE JAÉN
Escuela Politécnica Superior de Linares
Trabajo Fin de Grado
DESARROLLO DE APLICACIÓN
WIRELESS BASADO EN
SISTEMAS DE RADIO INTEGRADA
EASYRADIO.
Alumno: Sara Rivero Martín de ruedas.
Tutor: Prof. D. Raúl Mata Campos.
Depto.: Ingeniería de Telecomunicación.
3
Índice General
PARTE I MEMORIA ............................................................... 12
CAPÍTULO 1 .............................................................................................. 13
1.1 Introducción .......................................................................................................... 13
1.2 Descripción. ........................................................................................................... 15
1.3 Objetivos. ............................................................................................................... 18
1.4 Estado del arte. ...................................................................................................... 20
1.4.1 Sistemas de radio integrados con microcontrolador. ....................................... 20
1.4.2 Dispositivos de corto alcance. .......................................................................... 21
1.5 EasyRadio. ............................................................................................................. 23
1.5.1 eRIC Radio Transceiver. .................................................................................. 23
1.5.1.1 easyRadio Operating System (eROS) ........................................................... 25
1.5.1.2 Antenas .......................................................................................................... 26
1.5.1.3 Temporización de datos en serie ................................................................... 26
1.5.1.4 Conjunto de comandos de configuración ...................................................... 28
1.6 Elementos empleados. ........................................................................................... 31
1.6.1 Kit de desarrollo eRIC. ..................................................................................... 31
1.6.2 Sensor de presencia PIR .................................................................................. 32
4
1.6.3 Arduino UNO Rev 3 ........................................................................................ 34
1.6.4 HD Webcam Logitech C270 ........................................................................... 37
1.6.5 Raspberry Pi 3 Modelo B ................................................................................ 38
CAPÍTULO 2 ........................................................................................ 41
2.1 Configuración y puesta en marcha. ..................................................................... 41
2.1.1 Radio de cobertura. ........................................................................................... 43
CAPÍTULO 3 .............................................................................................. 46
3.1 Definición, diseño e implementación del sistema Wireless. .............................. 46
3.1.1 Arquitectura del sistema. .................................................................................. 46
3.1.1.1 Conexión transmisor. ..................................................................................... 47
3.1.1.2 Conexión receptor.......................................................................................... 51
CAPITULO 4 .............................................................................................. 67
Resultados ..................................................................................................................... 67
CAPITULO 5 .............................................................................................. 73
Conclusiones ................................................................................................................. 73
CAPITULO 6 ....................................................................................... 76
Lineas Futuras ............................................................................................................... 73
PARTE II PRESUPUESTOS.................................................... 78
CAPÍTULO 7 .............................................................................................. 79
5
Recursos materiales: ..................................................................................................... 79
7.1 Presupuesto final ..................................................................................................... 80
PARTE III ANEXOS ................................................................. 82
CAPÍTULO 8 .............................................................................................. 83
8.2 Descripción de pines del transceptor eRIC. ............................................................ 89
8.3 Conjunto de comandos de configuración de Easyradio eRIC. ............................... 90
8.4 Instalación de los paquetes Python y Python serial. ............................................... 94
8.5 Instalación del servidor web LAMP. ...................................................................... 96
8.6 Script para la creación de un Daemon: ................................................................... 99
PARTE IV BIBLIOGRAFÍA ................................................ 102
6
7
Índice de figuras
Figura 1. Circuitos integrados Wireless EZRadio y EZRadioPro ....................................... 20
Figura 2. Diagrama de bloques de eRIC transceptor. .......................................................... 24
Figura 3. Diagrama de bloques del sistema. ........................................................................ 26
Figura 4. Modulación FSK ................................................................................................. 27
Figura 5. Diagrama de temporización. ................................................................................ 27
Figura 6. Software easyRadio Companion. ......................................................................... 29
Figura 7. Pantalla de comandos easyRadio. ........................................................................ 29
Figura 8. Parámetro modificado con easyRadio Companion. ............................................. 30
Figura 9. eRIC Development Kit. ........................................................................................ 32
Figura 10. Sensor piezo eléctrico. ....................................................................................... 33
Figura 11. Rango de funcionamiento sensor PIR ................................................................ 33
Figura 12. Sensor de presencia PIR. .................................................................................... 34
Figura 13. Estructura sensor PIR ......................................................................................... 34
Figura 14. Placa Arduino UNO Rev 3 ................................................................................. 35
Figura 15. Estructura Arduino UNO Rev 3 ......................................................................... 36
Figura 16. Software Arduino ............................................................................................... 37
Figura 17. HD Webcam Logitech C270 ............................................................................. 37
Figura 18. Raspberry Pi 3 Model B ..................................................................................... 38
Figura 19. Instalación eRIC Flash Programmer .................................................................. 42
Figura 20. Arquitectura del sistema. .................................................................................... 46
Figura 21. Conexión para prueba sensor PIR y Arduino. .................................................... 48
Figura 22. Monitor Serie Software Arduino ........................................................................ 49
Figura 23. Monitor serie prueba PIN. .................................................................................. 50
8
Figura 24. Conexión final del transmisor ............................................................................ 50
Figura 25. Descarga Win32 Disk Imager ............................................................................ 51
Figura 26. Descarga sistema operativo Raspbian ................................................................ 51
Figura 27. Introducción del sistema operativo Raspbian en trajeta SD............................... 52
Figura 28. Pantalla de configuración Raspberry Pi. ............................................................ 52
Figura 29. Cambio de contraseña de usuario Pi. ................................................................. 53
Figura 30. Elección del sistema de arranque. ...................................................................... 54
Figura 31. Opciones de internacionalización ...................................................................... 54
Figura 32. Configuracion tecla AltGr por defecto ............................................................... 55
Figura 33. Configuración Control+Alt+Retroceso .............................................................. 55
Figura 34. Correo electrónico generado por Raspberry PI .................................................. 58
Figura 35. Secciones disponibles en página web ................................................................ 59
Figura 36. Página principal web .......................................................................................... 60
Figura 37. Pestaña “Objetivos” web .................................................................................... 60
Figura 38. Manual de usuario web. ..................................................................................... 61
Figura 39. GPIOs RaspberryPi ............................................................................................ 62
Figura 40. Conexión Raspberry Pi – Módulo eRIC ............................................................ 63
Figura 41. Descarga de drivers Webcam Logitech ............................................................. 63
Figura 42. Montaje final sistema receptor. .......................................................................... 64
Figura 43. Sistema transmisor. ............................................................................................ 64
Figura 44. Sistema receptor ................................................................................................. 65
Figura 45. Activación sensor PIR prueba final.................................................................... 68
Figura 46. Monitor serie Arduino con intruso ..................................................................... 68
Figura 47. Envio de email desde Raspberry Pi .................................................................... 69
Figura 48. Correo electrónico recibido. ............................................................................... 69
9
Figura 49. Captura de imágenes de la webcam. .................................................................. 70
Figura 50. Guardado de imágenes tomadas ......................................................................... 70
Figura 51. Web creada para visualizar imágenes. ............................................................... 71
Figura 52. Módulo emisor facilitado al usuario. ................................................................. 83
Figura 53. Conexión fuentes transmisor. ............................................................................. 84
Figura 54. Descripción visual del módulo emisor para la configuración de usuario. ......... 84
Figura 55. Módulo receptor facilitado al usuario. ............................................................... 86
Figura 56. Conexión fuentes de alimentación ..................................................................... 86
Figura 57. Descripción visual del módulo receptor para la configuración de usuario ........ 87
Figura 58. Instalación Apache ............................................................................................. 96
Figura 59. Instalación PHP .................................................................................................. 97
10
11
Índice de tablas
Tabla 1. Presupuesto recursos materiales. ....................................................................................................... 79
Tabla 2. Presupuesto final ............................................................................................................................... 80
12
PARTE I
MEMORIA
13
CAPÍTULO 1
1.1 Introducción
Los grandes avances de la tecnología en conjunto con las necesidades de un mundo
que busca un permanentemente progreso, han promovido una forma de percibir los
distintos “sabores” de la naturaleza, tan importantes dentro del área laboral, industrial y
tecnológica de la humanidad, de manera menos dependiente de un medio físico, como lo es
el cableado, además, por supuesto, de la necesidad de que esté todo integrado en un mismo
módulo haciendo de esta manera que ocupen menos superficie.
Tras 50 años de evolución de la tecnología, el elemento base de la actual tecnología
electrónica es el circuito integrado debido a que incorporan un gran número de dispositivos
microelectrónicos, principalmente diodos y transistores, además de componentes pasivos
como condensadores o resistencias, en una superficie de pequeñas dimensiones.
La conectividad Wireless presenta también un auge elevado, ya que la mayoría de
dispositivos electrónicos creados, poseen controles e interfaces inalámbricos que facilitan
la conectividad, sin necesidad de cableado.
Debido a esto, han surgido gran variedad sistemas Wireless integrados que ofrecen
equilibrio en cuanto a consumo energético, cobertura inalámbrica, y flexibilidad se refiere.
Este tipo de sistemas permiten el desarrollo de variedad de aplicaciones en el marco
del Internet de las Cosas (IoT) incluyendo, por ejemplo pero no solamente, redes de
sensores inalámbricos, comunicaciones industriales M2M (machine-to-machine), control
remoto, sistemas de seguridad, y dispositivos de medición inteligentes.
A razón de estos factores, se pretende adquirir nuevos conocimientos en sistemas
integrados de radio con microcontrolador integrado, implementando una aplicación
wireless basada en sistemas de radio integrada easyRadio, en concreto el LPRS eRIC,
14
(Controlador integrado Easyradio), módulo que proporciona un subsistema de radio
inteligente, el cual detallaremos a lo largo de nuestro TFG.
Gracias al sistema LPRS eRIC y con ayuda de diferentes dispositivos que
conoceremos más adelante, será posible implementar una solución para ofrecer seguridad,
ya que el incremento de viviendas unifamiliares y chalets en la periferia de las ciudades ha
provocado, según los expertos, un importante aumento en la demanda de sistemas de
seguridad para domicilios.
.
15
1.2 Descripción.
Este Trabajo Fin de Grado tiene como objetivo adquirir nuevos conocimientos en
sistemas integrados de radio con microcontrolador integrado. Con el objetivo final del
diseño y la implementación de una aplicación Wireless que permita la comunicación entre
dos puntos utilizando como sistema radio el kit eRIC.
El kit de radio eRIC (easyRadio Integrated Controller) es un módulo que
proporciona un subsistema de radio inteligente. Fabricado en Reino Unido, opera en las
bandas reservadas internacionalmente para uso no comercial de radiofrecuencia
electromagnética (Industria, Ciencia y Médicina).
Entre sus características principales, el módulo eRIC ofrece una opción de cifrado
de datos AES de 128 bits permitiendo, de esta manera, una transmisión por aire segura,
además de unas frecuencias de funcionamiento seleccionables para permitir su uso en los
mercados mundiales.
También presenta una memoria programable que permite la partición de la misma,
una de las mitades contiene su sistema operativo “EROS”, dejando la otra mitad para la
programación de aplicaciones. De esta manera, elimina la necesidad de cualquier
microcontrolador adicional, ahorrando así el costo, espacio y energía.
Está desarrollado por la empresa LPRS (Low Power Radio Solutions), una de las
primeras en el mundo en suministrar una solución inalámbrica en un formato modular,
siendo líderes en el mercado de corto alcance, de licencia libre, y tecnología inalámbrica
sub-1GHz, desarrollando además el primer módulo de radio con un protocolo de software
de comunicación integrado,"Easyradio", que integra el software del sistema y los conjuntos
de protocolos de RF en un chip que se encuentra en el propio módulo de radio.
De esta manera, se va a desarrollar un sistema de seguridad, que nos permitirá
vigilar cualquier estancia, cuando no estemos en ella.
16
Nuestro sistema detectará al individuo, haciendo activar una cámara que realizará
instantáneas de la situación, enviándonos además un correo electrónico alertándonos de la
situación de nuestro inmueble.
Además de la ayuda que nos proporcionan los módulos eRIC para el desarrollo de
este sistema, haremos uso de un sensor PIR, una cámara USB Logitech HD C270, un
Arduino UNO rev3 y una Raspberry Pi 2 Model B.
Como ejemplo de uso, situaremos nuestro dispositivo en una nave de grandes
dimensiones, en la cual se encontrarán artículos de gran valor.
En la puerta de entrada conectaremos nuestro módulo transmisor con el sensor de
presencia y en una de las esquinas más alejadas, cubriendo todo el perímetro de la nave, se
enconará el módulo receptor, que será activado una vez detectada la presencia y
comenzando entonces a realizar instantáneas.
El proceso que se llevará a cabo es el siguiente:
Por un lado tendremos el Arduino, al cual conectaremos el sensor PIR y uno
de los módulos eRIC, éste será el encargado de transmitir si se detecta
presencia.
Por otro, tendremos la Raspberry Pi a la que ira conectada la cámara USB y
el segundo módulo eRIC, quien recibirá el aviso y comunicará que
comience el funcionamiento de nuestra cámara.
Una vez detectada la presencia, se enviará un correo electrónico al usuario
avisando de que hay un intruso en el inmueble, pudiendo éste, visualizar la
situación a través de las fotografías tomadas por la cámara, presentes en una
página web.
17
El resultado final de este Trabajo Fin de Grado será el de un servicio que realice
esta labor y que permita a los usuarios del mismo estar informados de que su hogar está
seguro.
En las sucesivas páginas de este documento, se supone que el lector dispone de
conocimientos mínimos de programación, ya que se hará uso de lenguajes orientados a
sistemas operativos, en concreto C++ y lenguajes orientados a objetos como es en nuestro
caso Python, entre otros.
18
1.3 Objetivos.
El objetivo principal de este Trabajo Fin de Grado, como hemos mencionado
anteriormente, es adquirir nuevos conocimientos en sistemas integrados de radio con
microcontrolador integrado.
En concreto, en este trabajo se pretende la implementación de un sistema Wireless
utilizando un dispositivo sub-1Ghz conocido como easyRadio, protocolo de software de
comunicación integrado, quien incluye una gama de módulos, entre los que se encuentran
los módulos de radiofrecuencia eRIC, que ofrecen un transceptor RF de bajo coste
destinado a aplicaciones de alto volumen.
Inicialmente se pondrá en funcionamiento el sistema easyRadio, en concreto el
LPRS eRIC (easyRadio Integrated Controller), verificando las funcionalidades y librerías
de comunicaciones, realizando medidas de alcance, comprobando sus capacidades de
transmisión, y definiendo las características necesarias que queremos que presenten.
Dado que el dispositivo se encuentra en fase de desarrollo, deberemos depurar
aspectos que presentan determinados problemas, este no era obviamente objetivo inicial,
pero dado el estado de progreso en que se encuentra nuestro módulo eRIC, “beta”, hubo
que incluir este punto durante el desarrollo del TFG.
Con posterioridad se seleccionará, diseñará e implementará una aplicación de
seguridad Wireless que permitirá la comunicación entre dos puntos de un inmueble,
utilizando como sistema radio, el kit eRIC, permitiéndonos tener video vigilada la zona
que más nos interese, desarrollando asimismo los manuales y programas tanto de
configuración del sistema como de desarrollo de la aplicación.
Deberemos para ello utilizar una serie de hardware que nos permitirán desarrollar,
junto con nuestro módulo eRIC, dicha aplicación, lo que nos llevará al estudio de estos
para realizar su conexionado y puesta en marcha.
19
Además, se establecerá como objetivo más específico, la creación de un servicio
web para los usuarios, de esta manera, se les ofrecerá una mayor comodidad a la hora de
utilizar la aplicación diseñada, permitiendo visualizarla desde cualquier dispositivo móvil.
20
1.4 Estado del arte.
A lo largo de este apartado, realizaremos un breve repaso sobre cómo se encuentran
en la actualidad los sistemas de radio integrados con microcontrolador haciendo alusión
además a los dispositivos de corto alcance.
1.4.1 Sistemas de radio integrados con microcontrolador.
Una de las aplicaciones más importantes de la electrónica en la actualidad es la
transmisión-recepción de datos vía radiofrecuencia, las cuales pueden efectuarse con
distintos tipos de modulaciones, como son:
QAM, modulación utilizada en enlaces de microondas.
QPSK, utilizada en comunicaciones móviles.
BPSK y DPSK, usada en módems satélites.
Todas ellas basadas en tres técnicas básicas: ASK (Amplitude Shift Keying), FDK
(Frecuency Shift Keying) y PSK (Phase Shift Keying).
Este tipo de sistemas cada vez son de mayor auge, por lo que, gran variedad de
empresas trabajan en su fabricación y mejora.
Por ejemplo, empresas como Silicon Laboratories Inc. han desarrollado una nueva
generación de sus circuitos integrados Wireless EZRadio y EZRadioPRO, los cuales
ofrecer un dispositivo equilibrado en cuanto a consumo energético, cobertura inalámbrica,
y flexibilidad.
Figura 1. Circuitos integrados Wireless EZRadio y EZRadioPro
Fuente: http://mms.businesswire.com/media/20141112005035/en/440564/5/EzRadioEzRadioPro-Press.jpg
21
Estos circuitos operan en la banda sub-GHz, ofreciendo soporte para una amplia
variedad de protocolos, proporcionando además, conectividad multiprotocolo versátil y de
alto rendimiento.
1.4.2 Dispositivos de corto alcance.
.Los SRD (Short Range Devices), son dispositivos de radio de corto alcance, que
ofrecen menor riesgo de interferencias debido a que transmiten a baja potencia.
Esta definición puede aplicarse a muchos tipos diferentes de equipos inalámbricos,
como pueden ser:
Alarmas y detectores de movimiento.
Dispositivos de audio inalámbricos, incluyendo micrófonos inalámbricos.
Implantes médicos.
Sensores y radares.
Telemetría.
Este tipo de dispositivos se benefician de un régimen regulador relajado en
comparación con otros equipos de comunicaciones de radio. Como principio general, el
usuario es libre de licencia para operar con dicho equipo y solo en algunos casos
específicos se requiere una licencia individual.
Sin embargo, al igual que todo tipo de equipos de radio, los dispositivos de corto
alcance tienen que cumplir con la Directiva de Equipos de Radio para ser instalados en el
mercado dentro de la Comunidad Europea.
El Instituto Europeo de Normas de Telecomunicaciones (ETSI) ha elaborado una
serie de normas para los dispositivos de corto alcance genéricos. Cada norma cubre los
dispositivos que funcionan dentro de un rango de frecuencias definido, estas normas son
las siguientes:
22
EN 300 220: norma que cubre los equipos que operan en el rango de frecuencias de
25 MHz a 1000 MHz.
EN 300 330: cubre los equipos de radio que operan en el rango de frecuencias de 9
kHz a 25 MHz.
EN 300 440: cubre los equipos de radio que operan en el rango de frecuencia de 1
GHz a 40 GHz.
23
1.5 EasyRadio.
En esta sección, explicaremos detalladamente de que trata el sistema sub-1Ghz
conocido como easyRadio, hablaremos de sus características y de su estructura, ya que será
el objeto principal de nuestro Trabajo Fin de Grado.
EasyRadio es protocolo de software de comunicación integrado, desarrollado por la
empresa LPRS (Low Power Radio Solutions) líder en el mercado de corto alcance y
primera en suministrar una solución inalámbrica en un formato modular.
LPRS, fabrica gran variedad de módulos, los cuales podemos encontrar en su
página web oficial.
Low Power Radio Solutions distribuye sus dispositivos a algunos de los fabricantes
más competentes del mundo en dispositivos electrónicos, como son Circuit Design Inc,
Airwave o Microrisc entre otros.
La gama de módulos Easyradio incluye a los módulos sub-1GHz eRIC (easyRadio
Integrated Controller) transceptores y los módulos eRA (easyRadio Advanced)
transmisores y transceptores.
Nosotros, a lo largo de nuestro TFG, trabajaremos con los módulos sub-1GHz
eRIC.
1.5.1 eRIC Radio Transceiver.
“eRIC” (easy Radio Integrated Controller), se trata de un módulo transceptor de
radio basado en el dispositivo de Texas Instruments CC430F5137, el cual, proporciona un
subsistema de radio inteligente que combina un transceptor de RF de alto rendimiento,
filtros de paso banda de RF (BPF), un microcontrolador MSP430, una memoria flash de
32Kb, un sensor de temperatura y un regulador de tensión.
Este módulo está fabricado en Reino Unido y presenta licencia internacional ISM
24
(Industria, Ciencia y Medicina), en la bandas de radio para Europa, América del Norte y
del Sur, India y China, de 804 - 940 MHz.
“easy Radio Integrated Controller” ofrece un mejor rendimiento de calidad, con un
transceptor RF de bajo coste destinado a las aplicaciones de alto volumen y adecuado para
el Internet de las Cosas (IoT).
Su forma compacta, la superficie de montaje y el conector de antena externa,
simplifica el diseño del producto proporcionando una colocación flexible del módulo
dentro de un producto final.
eRIC es un módulo transceptor en miniatura, de 15 x 20 x 2.2mm con opciones de
baja potencia, presenta además una encriptación de datos AES (Advanced Encryption
Standard) esquema de cifrado por bloques adoptado como un estándar de cifrado por el
gobierno de los Estados Unidos, de 128 bits y su sistema operativo permite las particiones
de las aplicaciones eliminando así la necesidad de un procesador externo.
Este tipo de módulos presentan una estructura interna como la que se muestra a
continuación:
Figura 2. Diagrama de bloques de eRIC transceptor.
Fuente: http://www.lprs.co.uk/assets/media/downloads/eRIC_Datasheet.pdf
25
Los pines enumerados en el diagrama de bloques anterior, se encuentran detallados
en el Anexo 7.2 de nuestro trabajo.
A continuación detallaremos los elementos que integran nuestros módulos así como
las funcionalidades principales de estos.
1.5.1.1 easyRadio Operating System (eROS)
“eROS” (easyRadio Operating System), es el sistema operativo con el que trabaja
Easyradio, el cual se utiliza dentro de eRIC, por ello, describiremos su estructura a
continuación.
La memoria del procesador Eric está divida en dos partes, una de ellas contiene un
sistema operativo protegido de Easyradio (eROS), encargado de todas aquellas funciones
complejas de radio, eliminando así, la necesidad de que el usuario tenga que programar los
registros de control del mismo.
La otra partición proporciona un área de código a la cual puede acceder el usuario
para modificar, si lo desea, parámetros como la frecuencia a utilizar, la potencia de salida y
la velocidad de los datos con los que se trabaja, llamando simplemente a funciones
predefinidas.
Además proporciona una sencilla API que sustituye al código específico con
comandos intuitivos que permiten el uso general de múltiples pines I / O y bloques de
funciones internas para ser configurados.
Por defecto, los datos se envían y se reciben de procesadores centrales o
dispositivos que utilizan datos en serie de nivel lógico 3.3V y paquetes con tamaños de
hasta 250 bytes.
26
1.5.1.2 Antenas
Se pueden utilizar diversos tipos de antenas, todas ellas con 50 Ω entrada/salida,
como por ejemplo antenas monopolo, antenas helicoidales, antenas de cuadro de PCB…
las cuales son resonantes con una longitud correspondiente a un cuarto de longitud de onda
eléctrica (Lambda/4).
1.5.1.3 Temporización de datos en serie
El tamaño del buffer interno de datos en serie se limita a un máximo de 250 bytes.
Si se envían más de 250 bytes los datos se perderán en la transmisión.
Figura 3. Diagrama de bloques del sistema.
Fuente: http://www.lprs.co.uk/assets/media/downloads/eRIC_Datasheet.pdf
La transmisión RF se inicia automáticamente cuando el buffer está lleno o cuando
se produce un final de datos, usando modulación FSK.
La modulación por desplazamiento de frecuencia, (Frequency-shift keying) o FSK
es una técnica de modulación donde la transmisión de información se realiza utilizando dos
o más frecuencias diferentes para cada símbolo.
La señal moduladora es digital y varía entre dos valores de tensión discretos,
formando un tren de pulsos representado con un uno o un cero el estado en el que se
encuentre.
Los dos valores binarios en la señal modulada, se representan con dos frecuencias
diferentes próximas a la frecuencia de la señal portadora. Normalmente estos valores de
27
frecuencias corresponden a desplazamientos de igual magnitud pero en sentidos opuestos
a la frecuencia de la señal portadora.
Figura 4. Modulación FSK
La trasmisión se realizará de la siguiente manera (Figura 3):
Figura 5. Diagrama de temporización.
Fuente: http://www.lprs.co.uk/assets/media/downloads/eRIC_Datasheet.pdf
A. El host (A) envía datos en serie a Eric (A). Los datos deben ser transmitidos de
forma continua (sin saltos) cargándose en el buffer de transmisión interna.
B. Después de detectar ya sea el "fin de datos" o la condición de "Buffer Full” el
controlador envía los datos dentro de la memoria intermedia junto con un preámbulo y
otros datos internos a través del enlace de RF.
Host (A) envía datos en serie a Eric (A)
Host (A) envía datos en serie a Eric (A) Eric (A) codifica los datos y los transmite.
Eric (B) los recibe y los decodifica.
Eric (A) codifica los datos y los transmite.
Eric (B) los recibe y los decodifica.
Eric (B) envía datos en serie a Host (B)
Eric (B) envía datos en serie a Host (B)
28
El transceptor operará en el modo recepción y dentro del rango de ‘escucha’
recibirá y codificará los datos, verificando la integridad de los mismos y colocándolos en
sus buffers de recepción.
C. Los datos dentro de la memoria intermedia de recepción de Eric (B) serán
enviados al Host (B) con la velocidad de transmisión seleccionada.
El host (A) debe esperar para que se produzca la transmisión y la recepción de
datos en el host (B) antes de enviar nuevos datos.
La transmisión y la recepción es bidireccional (half duplex) es decir, transmite y
recibe pero no al mismo tiempo.
1.5.1.4 Conjunto de comandos de configuración
Los parámetros de eRIC se pueden cambiar o modificar mediante un envío de
"texto" (caracteres ASCII). Estos comandos se pueden ejecutar utilizando el software
proporcionado ‘easyRadio Companion’.
Este software, es muy intuitivo y permite configurar nuestros módulos de forma
rápida y sencilla.
Los caracteres deben enviarse exactamente como se muestra en el Anexo 7.3 de
este Trabajo Fin de Grado, es decir, entre mayúsculas y minúsculas y sin espacios entre
caracteres. Cabe destacar que no se ejecutan hasta que la secuencia (ACK) es enviada y
procesada por el módulo.
A continuación se va a mostrar la utilización de dicho software.
En primer lugar ejecutaremos el programa, el cual nos mostrará una ventana para
que seleccionemos el tipo de módulo easyRadio con el que queremos trabajar.
29
Figura 6. Software easyRadio Companion.
En nuestro caso elegiremos eRIC Modules, ya que nuestros módulos de
radiofrecuencia trabajan con eRIC4.
Una vez dentro del software, elegiremos el puerto en el que se encuentra nuestro
módulo y los abriremos para proceder a enviar nuestros comandos.
Figura 7. Pantalla de comandos easyRadio.
30
Una vez elegida la característica que queremos modificar de nuestro módulo
pasaremos a clicar sobre “Send Command” y tras varios segundos de espera, esta habrá
sido cambiada.
Figura 8. Parámetro modificado con easyRadio Companion.
31
1.6 Elementos empleados.
Para el desarrollo de nuestro Trabajo Fin de Grado emplearemos elementos que
optimizan, agilizan y perfeccionan la capacidad de realizar muchas tareas.
Nuestro sistema constará de una amplia variedad de hardware, los cuales presentan
una serie de funcionalidades que se integraran en conjunto para su funcionamiento.
Necesitaremos un sensor PIR que se encargará de detectar al individuo y una vez
descubierto, este pulso llegará al módulo eRIC transmisor a través de la programación de
un Arduino.
El módulo receptor eRIC, irá acompañado de una Raspberry Pi que se dedicará a
activar una cámara web y enviar un correo electrónico cuando nuestro easyRadio
Integrated Controller reciba que se ha detectado presencia desde el transmisor.
A continuación los describiremos de forma más detallada:
1.6.1 Kit de desarrollo eRIC.
El kit de desarrollo eRIC proporciona una plataforma de prueba y evaluación para
los transceptores de radio eRIC permitiendo la transferencia de datos en serie a través del
enlace de radiofrecuencia.
Este kit consta de dos módulos transceptores de radiofrecuencia eRIC400,
integrados cada uno, en una de las placas de desarrollo eRIC.
Presenta además, dos antenas (400 MHz) con conectores SMA macho para poder
quedar integradas en los módulos.
Este kit también contiene dos pilas alcalinas de 9V, las cuales se encargarán de
alimentar cada una de nuestras placas.
32
Y dos conectores tipo A USB a tipo B microUSB, para realizar la conexión al
ordenador y hacer uso de su software.
Además de un lápiz de memoria USB de 4 GB "Wireless Mike” el cual, contiene
las hojas de datos y software.
Figura 9. eRIC Development Kit.
Fuente: http://www.lprs.co.uk/assets/media/downloads
1.6.2 Sensor de presencia PIR
Otro de los elementos a utilizar será un sensor PIR, estos sensores infrarrojos pasivos (PIR)
son dispositivos empleados para la detección de movimiento.
Están basados en la medición de la radiación infrarroja. Todos los cuerpos emiten
una cantidad de energía infrarroja, la cual aumenta con la temperatura del mismo.
Los dispositivos PIR constan de un sensor piezo-eléctrico, dividido en dos campos,
capaz de captar esta radiación y convertirla en una señal eléctrica. Cuando los dos campos
realizan una medición y reciben diferente cantidad de infrarrojo se genera una señal
eléctrica y el sensor emite una señal digital.
33
Figura 10. Sensor piezo eléctrico.
Fuente: http://www.prometec.net/sensor-pir/
Otro elemento necesario para su funcionamiento es la óptica del sensor. Se trata de
una cúpula de plástico formada por lentes de Fresnel, que divide el espacio en zonas, y
enfoca la radiación infrarroja a cada uno de los campos del PIR.
Figura 11. Rango de funcionamiento sensor PIR
Fuente: http://www.electrobiomedical.com.co/download/datasheet
La tensión de funcionamiento en corriente continua oscila entre los 4.5-20V,
presentando dos niveles de salida, en nuestro caso, cuando el sensor PIR detecte
movimiento mostrará un nivel alto de 3.3V, siendo 0V el nivel bajo referido a cuando este
no se active.
Nuestro sensor PIR, ocupa una pequeña superficie de dimensiones de 32mm x
24mm, con una lente de 23mm de diámetro haciendo que el ángulo del sensor sea menor
de 100º.
34
Presentando muy buena temperatura de operación, permitiendo trabajar entre
rangos de -15 a 70 grados.
Figura 12. Sensor de presencia PIR.
Fuente: http://mlb-s2-p.mlstatic.com
Posee además, dos resistencias variables de calibración, una de ellas destinada al
ajuste de la distancia de detección, permitiendo que esta varié desde los 3 metros a los 7 y
la otra que se encarga de establecer el tiempo que se mantendrá activa la salida del sensor.
Presenta un tiempo mínimo de 3 segundos, el cual, podríamos decrementar cambiando la
resistencia por una de 100K.
Figura 13. Estructura sensor PIR
Fuente: http://www.conectrolinformatica.com/arduino-modulos/3255-modulo-sensor-pir-hc-sr501-para-
arduino.html
1.6.3 Arduino UNO Rev 3
Arduino Uno es una placa electrónica creada a partir del microcontrolador
ATmega328.
Presenta una tensión de funcionamiento de 5V, un voltaje de entrada recomendado
de entre 7 a 12V, una memoria flash de 32KB, de los cuales, 0.5 KB están utilizados por el
35
gestor de arranque.
Figura 14. Placa Arduino UNO Rev 3
Fuente: http://files.tested.com/photos/2013/06/12/48912-arduinouno_r3_front.jpg
Esta placa posee 14 entradas/salidas digitales, de las cuales 6 pueden utilizarse
como salidas PWM (Modulación por ancho de pulsos) contando además con 6 entradas
analógicas.
Cada uno de los pines digitales, puede proporcionar o recibir un máximo de 40
mA., estos pueden utilizarse como entrada o salida, dependiendo de las funciones que
utilicemos, pinMode (), digitalWrite () o digitalRead ().
Las 14 entradas digitales, presenta unas funciones específicas para facilitar su
funcionamiento. Los pines 0 y 1 se utilizan para recibir y transmitir datos en serie TTL, los
pines 2 y 3 pueden ser configurados para provocar un flanco ascendente o descendente, o
un cambio en el valor, utilizando la función attachInterrupt (), los pines 5, 6, 9, 10, y 11
proporcionan una salida de PWM de 8 bits con la función analogWrite () siendo PWM una
modulación de ancho de pulso, en esta modulación se mantiene constante la frecuencia
mientras que se hace variar la anchura del pulso y por último, los pines 10, 11, 12, 13
utilizan el protocolo asíncrono SPI, (Serial Peripheral Interface) que trabaja en modo full
dúplex para recibir y transmitir información, permitiendo que dos dispositivos puedan
comunicarse entre sí al mismo tiempo utilizando canales diferentes o líneas diferentes en el
mismo cable.
36
Las 6 entradas analógicas van etiquetadas desde A0 hasta A5, cada una de cuales
proporciona 10 bits de resolución. Por defecto presentan un voltaje de 0 a 5 voltios, aunque
es posible cambiar su rango usando el pin AREF y la función analogReference ().
También, en su estructura, se encuentra un resonador cerámico de 16 MHz, un
conector USB, un conector de alimentación, un botón de reset y una cabecera ICSP la cual
sirve para programar el BootLoader del Microcontrolador ATmega y de esta manera poder
cargar los programas creados en el IDE directamente en el microcontrolador, sin tener que
hacer uso de programadores externos.
Arduino UNO puede ser alimentado a través de una conexión USB o con una
fuente de alimentación externa haciendo uso de su pin VIN que se encarga de suministrar
el voltaje de esta a la placa.
Figura 15. Estructura Arduino UNO Rev 3
Además, en la página oficial del producto, podremos descargarnos de forma
gratuita el software de Arduino, el cual nos permitirá programar nuestro script.
37
Figura 16. Software Arduino
1.6.4 HD Webcam Logitech C270
La webcam Logitech C270 ofrece muy buenas prestaciones, entre ellas
videoconferencias en alta definición, captura de vídeo de hasta 1280 x 720 píxeles, realiza
fotos de 3.0 megapíxeles y posee un micrófono integrado con reducción de ruido.
Figura 17. HD Webcam Logitech C270
Fuente: http://www.logitech.com/es-es/product/hd-webcam-c270
Para el correcto funcionamiento de la webcam, será necesario que nuestro PC
presente al menos 2GB de RAM, como mínimo 200MB de espacio libre en el disco duro,
un puerto USB 2.0 para poder realizar su conexión, una resolución de pantalla de 1280 x
38
720 que nos permitirá visualizar las imágenes con su máxima calidad, además de conexión
a internet.
1.6.5 Raspberry Pi 3 Modelo B
Raspberry Pi es una placa de ordenador reducida, desarrollada para fomentar y
ayudar en la enseñanza de la programación y la informática.
Es un producto con propiedad registrada pero de uso libre. Raspberry Pi usa
mayormente sistemas operativos basados en Linux, en concreto, Raspbian, una
distribución derivada de Debian que está optimizada para el hardware de Raspberry Pi,
aunque permite otros sistemas operativos, incluido Windows 10.
El diseño de Raspberry Pi 3 modelo B es la tercera generación de Raspberry Pi, en
su estructura incluye, un procesador central a 1.2GHz 64-bit quad-core y 1GB de memoria
RAM. Incorpora además LAN inalámbrica 802.11 b/g/n de 2.4 GHz, Bluethooth 4.1, un
coprocesador multimedia de doble núcleo Videocore, un conector micro USB para fuente
de alimentación de 2,5 A, un puerto Ethernet 10/100, un conector de vídeo/audio HDMI,
un conector de vídeo/audio RCA, un conector de cámara CSI, cuatro puertos USB 2.0, 40
pines GPIO, una antena de chip, un conector de pantalla DSI y una ranura para tarjeta
microSD.
Figura 18. Raspberry Pi 3 Model B
Fuente: https://www.raspberrypi.org/wp-content/uploads/2016/03/pi3.jpg
Al igual que Arduino, Raspberry PI presenta una serie de conexiones, los pines GPIO,
que pueden usarse como entradas o salidas, los cuales no disponen de buffers de protección
y presentan funciones diferentes.
39
Se trata de una serie de pines con conexiones configurables, dentro de los cuales
están los destinados a la alimentación, limitados a 50 mA y los destinados a una interfaz
UART, con conexiones TXD y RXD que sirven para comunicaciones en serie.
40
CAPÍTULO 1 -
41
CAPÍTULO 2
A lo largo de este capítulo describiremos los pasos a seguir que nos permitirán
poner en funcionamiento nuestros módulos eRIC.
Además realizaremos una serie de mediciones para determinar el radio de cobertura
de los mismos, y de esta manera, poder establecer la distancia máxima de separación, que
permiten.
2.1 Configuración y puesta en marcha.
A continuación detallaremos la configuración necesaria para que nuestros eRICs
nos permitan realizar una transmisión de datos entre ellos.
Comenzaremos configurando los módulos en modo demostración, para conocer la
distancia a la que se nos permite trabajar, entre ambos equipos.
Instalaremos el software ‘eRIC Flash Programmer V1_1 Setup’ disponible
en la memoria USB incluida en el kit.
Este software nos permitirá subir los archivos .hex al módulo eRIC.
Abriremos el software y conectaremos mediante el cable USB
proporcionado, uno de nuestros eRICs al ordenador con el ‘Jumper’
colocado, que sirve como puente entre el pin 12 y 13 para activar el modo
de gestor de arranque.
Veremos en la parte inferior de nuestro programa el mensaje ‘Scanning for
connection’ en rojo, el cual, desaparecerá una vez que encuentre nuestro
dispositivo y se establezca la conexión, cambiando a verde y mostrándonos
el mensaje ‘Connected’.
Además mostrará en la ventana disponible, el nombre de nuestro módulo,
con el número de versión y puerto COM al que lo tenemos conectado.
42
Seleccionaremos ahora, mediante el icono de la carpeta que se nos muestra
en el mismo, el archivo‘eRIC_Demo1.hex’, facilitado en el pen drive, que
nos permitirá convertir nuestros módulos en transmisor o receptor.
Clicaremos sobre el icono amarillo "flash" para transferir el archivo a
nuestro módulo eRIC y esperaremos hasta que este proceso haya finalizado.
Figura 19. Instalación eRIC Flash Programmer
Realizada la transferencia, desconectaremos nuestro eRIC del ordenador,
retiraremos el ‘Jumper’ y presionaremos durante unos segundos el botón
‘Reset’ para ejecutar, de esta manera, la aplicación recién cargada.
Este mismo proceso deberemos realizarlo para el otro módulo.
Para convertir nuestro primer módulo en transmisor, pulsaremos
momentáneamente el botón de ‘Reset’ y una vez soltado, pulsaremos el
SW2. De esta manera quedará configurado para transmitir.
Del mismo modo, para configurar el segundo módulo como receptor,
pulsaremos unos segundos el ‘Reset’ y seguidamente, en este caso, el SW3.
43
Una vez ambos eRICs configurados, pulsando cualquier interruptor (1-4) en
el módulo transmisor, el LED asociado con el conmutador se iluminará al
igual que el LED correspondiente en el receptor, así podremos estudiar la
máxima distancia a la que podremos mandar información sin que ésta se
pierda.
2.1.1 Radio de cobertura.
Debido a que no se especifica la distancia que ambos módulos permiten para una
transmisión sin pérdida de información, comprobaremos empíricamente esta característica,
sometiendo a ambos módulos a dos pruebas básicas.
La primera, consistirá en colocar la unidad transmisora en un punto de casa
mientras se camina por el resto del inmueble con el módulo receptor.
La segunda, la realizaremos en campo abierto, donde ambos módulos tendrán
visión directa.
Para la ejecución de la primera prueba, efectuaremos el siguiente procedimiento:
Situaremos el módulo receptor en una de las habitaciones de nuestra casa,
donde permanecerá otra persona que comprobará, si este, recibe la
información, acción que iluminará aquel LED que se presione en el
transmisor.
Nosotros portaremos el módulo transmisor, pulsando cualquiera de los
switch, para comprobar si se reciben en el receptor .
Incrementaremos la distancia, cada vez que nuestro compañero nos
comunique que ha recibido la información, viendo su led encenderse cada
vez que nosotros pulsemos el nuestro.
Tras varias repeticiones, podemos asegurar que nuestros dispositivos tienen un
alcance en interiores de unos 110 metros aproximadamente.
44
Para comprobar el alcance en campo abierto, repetiremos el procedimiento descrito
anteriormente, pero en esta ocasión, nos situaremos en un terreno sin construcciones
alejado de la ciudad.
En esta ocasión la distancia entre módulos se incrementa, obteniendo un alcance de
165 metros.
45
CAPÍTULO 2 -
46
CAPÍTULO 3
En el siguiente capítulo se profundizará en la programación y conexionado de los
elementos utilizados para la implementación del sistema propuesto.
3.1 Definición, diseño e implementación del sistema Wireless.
A continuación de detallará la estructura del sistema, la cual dividiremos en dos
bloques:
Conexionado del transmisor.
Conexionado del receptor.
Describiendo todo lo necesario para que el sistema funcione correctamente.
3.1.1 Arquitectura del sistema.
Nuestra aplicación, como se comentó, estará destinada a la creación de un sistema
de seguridad, haciendo uso del anteriormente mencionado, kit eRIC.
La infraestructura necesaria para el despliegue del sistema, estará estructurada
como se muestra a continuación:
Figura 20. Arquitectura del sistema.
1. El sensor detecta
presencia.
2. Ambos módulos se comunican.
3. La cámara se activa,
realizando instantáneas.
4. Envío de notificación al
dispositivo móvil.
5. Visualización de las
imágenes captadas.
47
Una vez fijada la estructura del mismo, procederemos a desarrollar paso a paso su
conexionado y describiremos de forma detallada el código realizado para poner en marcha
nuestro sistema.
3.1.1.1 Conexión transmisor.
El sensor PIR consta de tres terminales en su parte inferior, uno de ellos de
alimentación (5V), otro destinado a la salida digital y el último de tierra.
Presenta también un par de potenciómetros los cuales nos ayudaran a ajustar el
tiempo entre medición y a calibrar la sensibilidad de la misma.
Consta además de un Jumper con dos posiciones, la posición H o modo “Retrigger”
donde la salida permanece alta cuando el sensor se reactiva en repetidas ocasiones,
cambiando a baja cuando este está inactivo, y la posición L o modo “Normal” siendo la
salida un pulso alto-bajo siempre y cuando se detecte movimiento.
Una vez conocida la arquitectura eléctrica de nuestro dispositivo nos dispondremos
a conectarlo a Arduino y realizar las pruebas necesarias para su correcto funcionamiento.
La conexión con la placa de Arduino es sencilla. Conectaremos el terminal Vcc de
nuestro sensor PIR al pin 5V de la placa, el terminal OUT del sensor al pin 2 y el terminal
GND al pin GND de nuestro Arduino.
Además añadiremos un LED al pin 13, pin-test de la placa Arduino, el cual se
iluminará cuando detecte presencia y de esta manera podremos comprobar el correcto
funcionamiento de nuestro sensor.
48
Figura 21. Conexión para prueba sensor PIR y Arduino.
Una vez realizado todo el conexionado nos dispondremos a programar la placa de
Arduino para corroborar que todo funciona correctamente y podamos continuar con la
realización de nuestra aplicación.
Abierto el software de Arduino, procedemos a poner en funcionamiento nuestro
sensor con un código escrito en C que active el LED cuando este detecte movimiento
Tras comprobar el correcto funcionamiento del mismo, procederemos a la
realización de un experimento, el cual nos ayudará a determinar la distancia máxima a la
que nuestro sensor de presencia PIR es capaz de detectar movimiento.
Dicha prueba consistirá en distanciarnos poco a poco del sensor hasta que el LED
deje de encenderse, lo que significará que el sensor es incapaz de detectarnos.
Repetida en varias ocasiones y realizada con diferentes tipos de personas con
distinta complexión, podríamos decir que nuestro sensor es capaz de detectar presencia a
una distancia máxima de 7 metros.
Seguidamente nos dispondremos a configurar nuestro eRIC transmisor. Con ayuda
de los manuales facilitados en la memoria USB del kit, esta tarea es relativamente sencilla.
49
En primer lugar, conectaremos la pila al módulo y una vez que este esté encendido
procederemos a pulsar el SW1, seguidamente y sin soltar este último botón, pulsaremos
sobre el reset unos segundos y soltaremos ambos botones, de esta manera entraremos en el
modo de selección de nuestro eRIC, ya que aparecerán dos luces azules sobre el SW3 y el
SW4.
Como queremos que transmita el pulso que recibe del sensor, pulsaremos sobre el
SW4, seleccionando de esta manera la opción de transmisor.
Haciendo uso de la hoja de características de nuestro módulo eRIC, podemos
observar como el PAD destinado por defecto al envío de datos en serie es el número 4, por
tanto lo conectaremos mediante un cable al pin 1 de la placa de Arduino, pin serial usado
para transmitir.
Para comprobar que nuestro transmisor funciona correctamente, haremos uso del
software de Arduino, ya que permite enviar y recibir fácilmente información a través del
puerto serie con su opción “monitor serie”.
Figura 22. Monitor Serie Software Arduino
Una vez seleccionado el puerto donde está conectado nuestro módulo eRIC
(COM6), procederemos a abrir el monitor serie.
50
Cuando nuestro sensor detecte presencia, aparecerá en el monitor un 1, tal y como
programamos nuestro script, con ello podremos saber que transmite correctamente.
Figura 23. Monitor serie prueba PIN.
Finalmente nos quedaría un conexionado tal y como se muestra a continuación:
Figura 24. Conexión final del transmisor
51
3.1.1.2 Conexión receptor.
Para llevar a cabo nuestro sistema receptor, procederemos a la configuración de
nuestra Raspberry Pi.
1. Configuración e instalación del sistema operativo Raspbian:
En primer lugar para poner en funcionamiento nuestra Raspberry Pi, será necesario,
una tarjeta SD, un cable de red para poder conectarla a un router, una fuente de
alimentación y un equipo desde el que realizaremos su configuración.
Este sistema operativo lo introduciremos en nuestra tarjeta SD, para ello nos
descargaremos el software Win32 Disk Imager, el cual nos permitirá grabar archivos de
imagen en nuestra tarjera SD.
Figura 25. Descarga Win32 Disk Imager
Fuente: https://sourceforge.net/projects/win32diskimager
También nos descargaremos el sistema operativo de Raspbian, el cual podremos
encontrar en su página web oficial.
Figura 26. Descarga sistema operativo Raspbian
Fuente: https://www.raspberrypi.org/downloads/raspbian
52
Una vez concluida la descarga procederemos a instalar el programa, cuando este
proceso haya terminado, lo ejecutaremos como administrador.
Nos aparecerá una ventana en la cual seleccionaremos mediante el icono de la
carpeta, el sistema operativo descargado y la tarjeta SD en la que queremos cargar
Raspbian, clicaremos sobre “Write” y este será cargado en nuestra tarjeta.
Figura 27. Introducción del sistema operativo Raspbian en trajeta SD.
Seguidamente insertaremos la tarjeta SD en nuestra Raspberry Pi para comenzar la
instalación del sistema operativo.
Conectaremos la Raspberry Pi al ordenador y nos aparecerá una pantalla en la cual
comprobará todos los componentes que posee antes de inicializar la configuración del
sistema operativo Raspbian.
Una vez comprobado todo el Hardware se mostrará la pantalla de configuración con
una serie de opciones que configuraremos para poder utilizar nuestro Raspbian.
Figura 28. Pantalla de configuración Raspberry Pi.
53
Lo primero que haremos será seleccionar la primera opción “Expand FileSystem”,
nos permitirá la expansión del sistema operativo para que de esta manera se utilice todo el
espacio disponible en la tarjeta.
Para la instalación del sistema operativo Raspbian, la imagen copiada únicamente
ocupa 2 GB, por lo que ejecutaremos esta opción para que todo el espacio de la tarjeta SD
sea utilizado.
A continuación entraremos en la segunda opción “Change User Password”. En
Raspberry Pi vienen predeterminados por el sistema dos usuarios “root” y “pi”.
“Root” es el más importante ya que se trata del administrador del sistema, el cual
tiene acceso privilegiado a todos las configuraciones, archivos y carpetas.
El usuario “pi” viene predeterminado con la contraseña “raspberry” por lo que es
recomendable cambiarla ya que cualquier persona podría acceder a nuestro sistema.
En esta opción, el sistema nos solicitará que ingresemos una nueva contraseña y al
finalizar nos aparecerá el mensaje “Password changed successfully” informándonos de que
la contraseña ha sido cambiada correctamente.
Figura 29. Cambio de contraseña de usuario Pi.
Seguidamente abriremos la tercera opción “Enable Boot to Desktop/Scratch”, esta
nos permitirá, una vez iniciado el sistema, la activación inmediata de la interfaz gráfica del
sistema operativo, por defecto, nos aparecerá el sistema de línea de comandos si no
54
seleccionamos ninguna opción.
Figura 30. Elección del sistema de arranque.
Por tanto elegiremos “Desktop Log in as user pi at the grafical desktop” ya que es
lo más intuitivo para el manejo de nuestra Raspberry.
Accedemos ahora a la cuarta opción “Internationalisation Options” la cual nos
permitirá la modificación del lenguaje del sistema, la zona horaria y la distribución de
nuestro teclado.
Figura 31. Opciones de internacionalización
Seleccionaremos la segunda opción “Change Timezone”, cambio de la zona horaria
e introduciremos nuestro continente “Europa” y nuestra capital “Madrid”. De esta manera
tendremos nuestra zona horaria ajustada.
Con la tercera opción “Change Keyboard Layout” cambiaremos la distribución de
nuestro teclado. Elegiremos el teclado genérico “PC genérico 105 teclas (intl)” con la
55
configuración en Español, ya que nos aparecerá por defecto en Inglés pudiéndonos
ocasionar de esta manera bastantes inconvenientes a la hora de su utilización.
Las siguientes ventanas que nos aparecerán nos permitirán configurar la tecla AltGr
izquierdo y derecho para funciones especiales, como nuestro teclado posee ese botón,
seleccionaremos la primera de las opciones, ejecutando de esta manera las opciones
predeterminadas.
Figura 32. Configuracion tecla AltGr por defecto
Por último, el sistema nos solicitará si deseamos activar Control+Alt+Retroceso
para cerrar el modo gráfico y entrar en el modo de comandos. Seleccionaremos la opción
“No”.
Figura 33. Configuración Control+Alt+Retroceso
Tras estas modificaciones tendremos nuestro sistema operativo Raspbian listo para
ser utilizado.
2. Configuración del módulo UART de Raspberry Pi:
La comunicación que realizaremos con el módulo eRIC, se llevará a cabo a través
de un puerto serie (UART). En Raspberry Pi son los puertos 8 y 10 los que están
destinados a este propósito.
Por tanto, el primer paso será configurar el UART de la Raspberry Pi. Para este fin,
utilizaremos librerías de manejo de archivos de Linux para controlar el archivo asociado a
56
este módulo. Este archivo es /dev/ttyAMA0.
Debemos desbloquear estos pines antes de usarlos, ya que Raspberry Pi
los utiliza por defecto para mostrar mensajes de control y diagnóstico. Para esto,
modificaremos los siguientes archivos de configuración:
- Archivo 1: …/boot/cmdline.txt
Abriremos este archivo y lo editaremos eliminando las opciones que hacen
referencia al puerto serie, que por defecto son las siguientes:
console=ttyAMA0,115200 kgdboc=ttyAMA0,115200
- Archivo 2: …/etc/inittab
En este caso, realizaremos el mismo procedimiento anterior, eliminando la línea
siguiente en el archivo:
T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100
Cuando tratemos de ejecutar el programa, comprobaremos que será necesario
proveer permisos de lectura y escritura en el puerto serie para poder utilizarlo, por lo tanto
iremos a la ventana de comandos e introduciremos la siguiente función:
sudo chmod a+rw /dev/ttyAMA0
Con el comando chmod se nos permitirá cambiar los permisos de un archivo o
directorio del servidor.
3. Instalación de los paquetes Python y Python serial:
A continuación se llevará a cabo la configuración de los pines GPIO de nuestra
Raspberry Pi. Para ello será necesario la instalación de la librería RPi.GPIO y el uso del
lenguaje de programación Python para programar las salidas de estos pines.
57
Por lo que será necesario instalar los paquetes de Python y Python serial para poder
desarrollar este fin.
La instalación necesaria se encuentra descrita en el Anexo 7.3 de nuestro TFG.
4. Creación de los scripts necesarios:
Para realizar la comunicación en serie de nuestra Raspberry Pi y el módulo receptor
eRIC, crearemos un scrip en Python donde importaremos en primer lugar los módulos
necesarios para el desarrollo de nuestra actividad, el módulo encargado del
encapsulamiento del acceso para el puerto serie y el que nos provee de varios métodos para
trabajar con cualquier funcionalidad del sistema operativo.
Usaremos además el comando “readlineCR” para leer los datos que nos llegaran al
puerto serie, en nuestro caso, lo que envía el módulo transmisor, un 1 cada vez que este
detecte presencia.
Cuando el dato llegue a nuestra Raspberry Pi, esta ejecutará los scrips que activan
la cámara y envían el correo electrónico, ya que se le estará indicando que hay un intruso
en el inmueble.
En el script destinado a nuestra webcam, programaremos que esta realice 3
instantáneas de 754x300 las cuales guardaremos en una carpeta específica para, más
adelante, poder visualizarlas en nuestra página web.
También crearemos un script que se encargará de enviar un correo electrónico
avisándonos que hay un intruso en nuestro inmueble.
No será necesaria la instalación de librerías externas ya que Python cuenta con una
biblioteca nativa que permite conectarse a un servidor SMTP, al igual que utiliza Gmail,
permitiendo así el envío de mensajes por correo electrónico, este módulo es smtplib.
58
SMTP (Simple Mail Transfer Protocol) es un protocolo de nivel de aplicación que
se utiliza para comunicarse con los servidores de correo de servicios externos, es solamente
un protocolo de entrega por lo que únicamente podrá enviar correos electrónicos.
Definiremos primeramente el correo que se encargará del envío del email una vez
que la alarma haya sido activada. Será necesaria la introducción de la contraseña para que
este pueda ser enviado.
Necesitaremos además el email del cliente para que este pueda recibir el aviso. En
el mensaje únicamente se mostrará la dirección de correo electrónico del remitente, el
asunto, en nuestro caso “Alarma” y el cuerpo del mensaje “Intruso”.
Por último, haremos la conexión al servidor en el puerto 587 y mandaremos el
correo electrónico, como podemos ver a continuación:
Figura 34. Correo electrónico generado por Raspberry PI
59
5. Instalación del servidor web LAMP:
Un servidor Web utiliza el protocolo HTTP para la transmisión de datos. Si un
cliente quiere acceder a un servidor Web, este envía una petición HTTP que recibe el
servidor y luego el servidor envía la información a través de protocolo HTTP al cliente en
formato HTML.
LAMP es el acrónimo que describe un sistema de infraestructura de internet de un
servidor web que usa Linux como sistema operativo, Apache de servidor web HTTP,
MySQL como gestor de base de datos Open Source y PHP o Python como los lenguajes de
programación para crear webs dinámicas.
Procederemos entonces a instalar el servidor en nuestra Raspberry Pi como queda
indicado en el Anexo 7.3 para crear de esta manera una página web donde poder observar
las imágenes tomadas por nuestro sistema.
6. Creación de una página web:
Crearemos además una página web que actuará como intermediaria entre el servicio
y el cliente.
Para el desarrollo de nuestra página web tomaremos como referencia el lenguaje de
marcas HMTL5, estructurando así la página en diversas secciones.
Figura 35. Secciones disponibles en página web
Para darle formato a esta, usaremos una hoja de estilos responsive, que nos
permitirá visualizarla además en nuestro dispositivo móvil, a parte de CSS3, mecanismo
simple que describe cómo se va a mostrar el contenido en la pantalla, proporcionando un
control total sobre el estilo y formato del sitio web.
60
Como página principal “Desarrollo de aplicación Wireless basado en sistemas de
radio integrada easyRadio” se presentaran las primeras tres instantáneas tomadas por la
webcam, esta pestaña se refrescará cada 10 segundos para mostrarnos las sucesivas fotos
tomadas.
Figura 36. Página principal web
En las pestañas “Descripción del TFG” y “Objetivos” se describirá de forma breve
lo ya descrito en esta memoria, con el fin de informar al usuario del producto.
Figura 37. Pestaña “Objetivos” web Además presentará una sección en la cual se mostrará el manual de usuario en pdf,
el cual podrá visualizarse a pantalla completa o ser descargado.
61
Figura 38. Manual de usuario web.
7. Creación de un “Daemon”:
Uno de los puntos importantes después de la instalación del servidor y de la
creación de los scripts, es el hecho del arranque automático de nuestra cámara en el
momento que el sensor detecte movimiento.
Para ello será necesaria la creación de un “demonio”, es decir, un programa que se
mantendrá en segundo plano, esperando a que ocurra algo o realizando una tarea
específica, sin esperar intervención de un usuario.
De esta manera dejaremos de utilizar la consola de comandos para ejecutar el
programa, ya que el “demonio” estará esperando el aviso del sensor para activar la cámara.
Para la automatización de nuestro programa es necesario conocer los niveles de
ejecución y subsistemas en Linux, ya que es la forma estándar que los sistemas operativos
como en nuestro caso, Raspbian, tienen de interpretar los contenidos de su directorio init.d.
Este sistema tiene varios modos de ejecución, desde el arranque hasta que llega al
modo de parada, pasando por todos ellos de forma secuencial, teniendo cada uno tiene sus
determinadas tareas.
62
Además, para ejecutar un programa como subsistema, debemos también desarrollar
un script y situarlo en el directorio anteriormente mencionado, ofreciéndole una serie de
permisos, rwxr-xr-x, para que pueda ser ejecutado.
Una vez finalizada toda la instalación en nuestra Raspberry Pi, procederemos al
conexionado de todos los elemento para comprobar su correcto funcionamiento.
En un primer momento conectamos nuestro módulo eRIC a la Raspberry Pi a través
de los pines UART.
Figura 39. GPIOs RaspberryPi
Fuente: http://www.dynamoelectronics.com/images/stories/Productos/raspberrypi_b_plus.png
Podemos observar como los pines destinados a la lectura de los datos en serie
son el pin 8 (UART tx) y el pin 10 (UART rx), por lo que, con ayuda de un cable dupont
macho/hembra conectaremos el pin 3 (transmisor) de nuestro módulo eRIC con el pin 10
de la Raspberry Pi (receptor).
63
Figura 40. Conexión Raspberry Pi – Módulo eRIC
Finalmente nos quedaría conectar nuestra webcam al sistema receptor, para que
cuando éste reciba el aviso, la cámara se active realizando las instantáneas, tal y como
hemos programado.
Será necesario para ello que nos descargaremos los drivers que encontraremos en la
página oficial de Logitech.
Figura 41. Descarga de drivers Webcam Logitech
Fuente: http://support.logitech.com/en_us/product/hd-webcam-c270#download
Como vimos anteriormente en las especificaciones, la webcam c270 presenta un
cable USB para poder realizar su conexión, el cual conectaremos a uno de los puertos USB
que presenta nuestra Raspberry Pi.
64
Por tanto, el sistema receptor quedaría como se muestra a continuación:
Figura 42. Montaje final sistema receptor.
En conjunto, el sistema desarrollado tendría la siguiente estructura:
SISTEMA TRANSMISOR:
Figura 43. Sistema transmisor.
65
SISTEMA RECEPTOR:
Figura 44. Sistema receptor
66
CAPÍTULO 3 -
67
CAPITULO 4
Resultados
Una vez finalizada la instalación y conexión de nuestros dispositivos, realizaremos
la comprobación del correcto funcionamiento de la aplicación desarrollada.
Estando nuestro sistema listo para su uso, instalando transmisor y receptor a una
distancia no superior a los 120 metros, nos dispondremos a pasar por delante del sensor
PIR, dispositivo situado en el módulo transmisor, no alejados de él más de 8 metros, para
que de esta manera, detecte intrusión y mande un pulso a nuestra placa de Arduino.
Realizaremos una comprobación de que esta detección ha llegado a la placa
abriendo nuestro monitor serial, el cual, mostrará un “1” en caso afirmativo, mandando
entonces este pulso a nuestro módulo eRIC transmisor.
Tras ser descubiertos, podremos observar como ambos módulos han realizado la
comunicación, ya que tras llegar al receptor, este mandará la información a nuestra
Raspberry Pi, proceso que podemos comprobar, accediendo al monitor serial de esta, el
cual mostrará el pulso recibido, informándonos además, de la activación de la cámara web
y el envió del correo electrónico.
Al accionarse la webcam, se comenzará con la toma de las tres primeras
instantáneas que se guardarán en una carpeta específica, proceso que se repetirá cada vez
que el sensor PIR detecte movimiento.
Además recibiremos un correo electrónico, el cual nos avisará de que nuestro
sistema de seguridad ha detectado un intruso en el inmueble.
Finalmente, accediendo a la página web creada, podremos visualizar, desde la
pantalla principal de esta, las fotografías tomadas por nuestra cámara web, las cuales cada
68
20 segundos se irán refrescando, para de esta manera, mostrarnos siempre las imágenes
captadas más actuales
Nos dispondremos entonces, como se ha explicado anteriormente, a comprobar que
nuestro sistema funciona correctamente, siguiendo paso a paso, el envío de la información.
En primer lugar activaremos el sensor PIR, acción que llevaremos a cabo pasando
nuestra mano para que este detecte presencia.
Comprobamos que la placa de Arduino ha recibido esta intrusión, para ello
abriremos su monitor serie y corroboraremos este hecho.
Figura 46. Monitor serie Arduino con intruso
Figura 45. Activación sensor PIR prueba final
69
Tras observar cómo ha llegado la información a nuestro Arduino, procedemos a
verificar que la acción ha sido transmitida entre módulos, llegándole esta a nuestra
Raspberry Pi.
Por lo que abriremos su pantalla serial, esperando a recibir la información. Si todo
ha funcionado según lo previsto, en ella podremos ver lo siguiente:
Figura 47. Envio de email desde Raspberry Pi
Raspberry Pi se encuentra escuchando hasta que recibe el aviso, “1”, en ese
momento, como se puede observar en la captura realizada, envía el correo electónico a
nuestro dispositivo.
Figura 48. Correo electrónico recibido.
70
Activando además la webcam para que realice las primeras tres instantáneas de la
situación, con una resolución de 754x380.
Figura 49. Captura de imágenes de la webcam.
Guardándonos estas, en una carpeta específica “var/www/html/cam”, de nuestra Raspberry
Pi, para más adelante poder visualizarlas desde la página web.
Figura 50. Guardado de imágenes tomadas
71
Seguidamente, procedemos a visitar nuestra web, para comprobar que las capturas se han
realizado correctamente.
Figura 51. Web creada para visualizar imágenes.
Se adjunta a continuación un enlace en el cual podremos visualizar en un video su
funcionamiento:
https://drive.google.com/file/d/0B6Iodtc6GFgsSWUtbEF6bl9GVTg/view
72
CAPÍTULO 4 -
73
CAPITULO 5
Conclusiones
Finalmente, tras comprobar el correcto funcionamiento de la aplicación
desarrollada y, tras la puesta en marcha del servicio web, se ha alcanzado con éxito el
objetivo de este TFG; creando un servicio capaz de permitir la comunicación entre dos
puntos utilizando como sistema radio el kit eRIC.
Durante el desarrollo de este Trabajo Fin de Grado, se han detectado varios
problemas, los cuales han sido abordados de la manera más apropiada posible.
Los módulos de transmisión de eRIC están creados para ser desarrollados por los
usuarios, estos comparten sus conocimientos en un foro destinado a ello y de esta manera
se encuentran en constante crecimiento, pero a su vez, no presentan demasiada
información.
Se han encontrado dificultades debido a que el primer kit que se nos facilitó dejo de
ser reconocido por nuestro PC. Tras investigar los posibles motivos relacionadas con este
problema, decidimos optar por pedir otro kit para continuar con el desarrollo de nuestro
TFG.
Otro de los problemas presentados, tiene relación con los software facilitados en la
memoria USB. Durante la compilación de ciertos programas, este no respondía, haciendo
fallida la subida de estos a los módulos. Esto es debido a que las nuevas actualizaciones se
encuentran en fase beta. Por tanto decidimos utilizar una placa de Arduino para realizar
dichos programas.
También fue un inconveniente el envió de imágenes a través de los módulos debido
a que estos únicamente eran capaces de transmitir paquetes de 250 bytes, no haciendo
74
posible el envío de imágenes en tiempo real. Por lo que decidimos utilizar una Raspberry
Pi y conectar la cámara a esta, para que así pudiéramos visualizarlas rápidamente sin
necesidad de fragmentarlas.
Otra de las dificultades encontradas es que estos módulos no presentan memoria, es
decir, cada vez que estos se encienden, necesitan ser configurados con el trabajo que
queremos que desempeñen, debido a esto, procedimos a desarrollar un manual de usuario
para que el cliente pudiera definir la utilidad de los mismos sin necesidad de tener que
documentarse.
Por otra parte cabe destacar que son muy intuitivos ya que con un simple código de
botones estos pueden ejercer de transmisor o receptor según nos interese sin necesidad de
programarlos.
En general, podemos decir que estos módulos nos permitirían desarrollar
aplicaciones varias para el uso doméstico de gran variedad, siempre y cuando seamos
partícipes del foro del mismo donde recojamos ideas y podamos ser ayudados por la
comunidad, debido a que la información de los mismos es escueta y se encuentra todavía
en desarrollo.
75
CAPÍTULO 5 -
76
CAPITULO 6
Líneas de futuro
En una futura continuación de nuestro Proyecto Fin de Grado, sería recomendable
informarse de ciertos módulos que han salido al mercado recientemente, los cuales hacen
que sean más completos, ofreciendo nuevas y mejores posibilidades de desarrollo de los
mismo sin necesidad de utilizar otros elementos de distinta marca para desarrollar la
aplicación.
También optaría por la utilización de una nueva placa que se comercializó hace
pocos meses, la cual integra Arduino en el módulo eRIC, pudiendo esta manera, prescindir
de una de las placas utilizadas en nuestro proyecto.
Recomendaría además, trabajar con la versión más actual de estos módulos, eRIC9,
ya que todos los proyectos actuales están desarrollados con este tipo, dejando atrás
nuestros módulos.
En lo que respecta a nuestro montaje, sería una buena opción, utilizar varios
sensores en el inmueble, para detectar en todo momento donde se encuentra el individuo y
aumentar, del mismo modo, el número de cámaras, haciendo así que nuestro recinto esté
completamente vigilado.
Sería interesante una mejora de la página web, donde en esta, en vez de mostrarse
instantáneas cada determinados segundos, se mostrase video en streaming, cada vez que se
acceda a ella, de la situación del inmueble.
77
CAPÍTULO 6 -
78
PARTE II
PRESUPUESTOS
79
CAPÍTULO 7
Recursos materiales:
En la tabla que mostraremos a continuación se detalla de manera económica los
recursos materiales utilizados en el desarrollo de nuestro TFG.
Concepto Unidades Precio/unidad Precio total
Kit eRIC LPRS 1 130,44 Euros 130,44 Euros
Sensor PIR 1 1.79 Euros 1.79 Euros
Arduino UNO Rev 3 1 19.82 Euros 19.82 Euros
Raspberry Pi 3 Model B 1 40.99 Euros 40.99 Euros
Tarjeta microSd 16GB 1 6.55 Euros 6.55 Euros
Webcam Logitech C270 1 20.58 Euros 20.58 Euros
Cables de conectores micro USB 4 2.53 Euros 10.12 Euros
Cables Dupont 1 3.99 Euros 3.99 Euros
Microsoft Windows 7 Profesional 1 125 Euros 125 Euros
Total 359.28 Euros
Tabla 1. Presupuesto recursos materiales.
80
7.1 Presupuesto final
Por tanto el presupuesto final de nuestro sistema será de:
Concepto
Recursos materiales 359.28 Euros
Precio Final (21% IVA) 434.73 Euros
Tabla 2. Presupuesto final
81
CAPÍTULO 7 -
82
PARTE III
ANEXOS
83
CAPÍTULO 8
8.1 Desarrollo del manual de usuario.
Una vez adquirido nuestro sistema por el usuario, este dispondrá de un kit que
estará formado por dos módulos:
Módulo emisor:
Este módulo estará constituido por un sensor de presencia PIR, un transmisor eRIC
y una placa de Arduino.
Además presentará sus respectivas fuentes de alimentación tanto para la placa de
Arduino como para el transmisor eRIC, aunque este último se adquiere con una pila
Alcalina de 9 V, se facilitará este para no tener que reemplazarla continuamente cada vez
que se agote.
Todos los elementos se presentarán soldados para que el usuario no tenga que
realizar ningún tipo de conexionado.
Figura 52. Módulo emisor facilitado al usuario.
Este será el módulo encargado de detectar la presencia, por lo que lo situaremos en
la puerta de entrada al inmueble.
El usuario deberá alimentar el Arduino y el módulo eRIC con las fuentes que se
proporcionan:
84
Figura 53. Conexión fuentes transmisor.
Una vez conectado a la toma de corriente procederemos a configurar el módulo
eRIC, proceso que nos llevará menos de un minuto.
Con ayuda de la figura adjuntada a continuación, el usuario procederá a encender el
módulo y a continuación realizará la siguiente combinación de botones:
1. Encenderemos en primer lugar nuestro módulo.
2. Mantendremos pulsado el SW1.
3. Sin soltar el SW1, pulsaremos una vez sobre el botón de RESET.
4. Soltaremos el SW1.
5. Si el proceso se ha realizado correctamente, aparecerán parpadeando las luces
correspondiente al SW3 y SW4.
6. Finalmente procederemos a pulsar sobre el SW4.
Una vez realizado el procedimiento descrito, tendremos nuestro emisor eRIC listo
para trabajar.
Figura 54. Descripción visual del módulo emisor para la configuración de usuario.
85
Finalmente el usuario será el encargado de la colocación estratégica de los
aparatos para que estos no se puedan ver a simple vista.
No debemos olvidar, que el sensor PIR será el encargado de la detección del
individuo, con esto quiere decirse que este no deberá ocultarse demasiado para tener buen
campo de visión, ni deberá colocarse a una distancia superior a los 8 metros de la puerta de
entrada.
Los elementos se entregarán totalmente programados, por lo que el usuario no
tendrá que preocuparse en ningún momento por el software de estos.
86
Módulo receptor:
El módulo receptor presente en el kit adquirido por el usuario contendrá una cámara
Logitech C270, un receptor eRIC y una placa Raspberry Pi 3 model B, además de un cable
Ethernet y dos fuentes de alimentación con conector micro USB.
Figura 55. Módulo receptor facilitado al usuario.
El usuario deberá encargarse de conectar a la alimentación tanto el módulo eRIC
como la de la placa Raspberry Pi con los dos cables de conectores micro USB que se
facilitan en el kit.
Figura 56. Conexión fuentes de alimentación
El siguiente paso será la conexión de la webcam mediante el USB que esta posee a
la Raspberry Pi por uno de los cuatro puertos que presenta.
87
Una vez todos los elementos conectados, se procederá a la configuración del
módulo eRIC receptor, como en el punto anterior, no nos llevará más de un minuto.
Con ayuda de la figura adjunta, se deberán de seguir los siguientes pasos:
Figura 57. Descripción visual del módulo receptor para la configuración de usuario
1. Encenderemos en primer lugar nuestro módulo.
2. Mantendremos pulsado el SW1.
3. Sin soltar el SW1, pulsaremos una vez sobre el botón de RESET.
4. Soltaremos el SW1.
5. Si el proceso se ha realizado correctamente, aparecerán parpadeando las luces
correspondiente al SW3 y SW4.
6. Finalmente procederemos a pulsar sobre el SW3.
Una vez realizado el procedimiento descrito, tendremos nuestro receptor eRIC listo
para trabajar.
En este caso, los elementos también se entregarán totalmente programados, por lo
que el usuario no tendrá que preocuparse en ningún momento por el software de estos.
88
Cuando hayamos completado la instalación de ambos módulos el sistema pordrá ser
usado.
Una vez en funcionamiento, si el sensor detecta presencia, el usuario recibirá un
correo electónico como el que se muestra a continuación:
89
8.2 Descripción de pines del transceptor eRIC.
A continuación se detallan la descripción en profundidad de los pines que consta
nuestro transceptor.
90
8.3 Conjunto de comandos de configuración de Easyradio eRIC.
En este apartado se muestran los comandos que nos permitirán modificar los
parámetros de nuestros módulos con el software Easy Radio Companion.
91
92
93
94
8.4 Instalación de los paquetes Python y Python serial.
A continuación realizaremos la configuración de los pines GPIO de nuestra
Raspberry Pi.
Para ello será necesario la instalación de la librería RPi.GPIO y además, haremos
uso del lenguaje de programación Python para programar las salidas de estos pines.
En primer lugar abriremos el terminal y entraremos en la consola de Python:
sudo Python
Dentro de esta, instalaremos la librería para controlar los GPIO, la cual nos
descargaremos directamente en nuestra Raspberry Pi introduciendo el siguiente comando
por consola:
wget'http://downloads.sourceforge.net/project/raspberry-
gpio-python/RPi.GPIO-0.5.4.tar.gz'
Cuando este proceso haya finalizado, procederemos a descomprimirlo:
tar zxvf RPi.GPIO-0.5.4.tar.gz
Ahora, nos situaremos en el directorio donde acabamos de descomprimir el archivo:
cd RPi.GPIO-0.5.4/
También nos descargaremos el paquete python-dev. Este paquete contiene
cabeceras, en particular Python.h, las cuales son necesarias para compilar los módulos de
extensión de Python "-dev".
sudo apt-get install python-dev
95
Una vez finalizada la descarga, instalaremos la librería:
sudo python setup.py install
96
8.5 Instalación del servidor web LAMP.
En primer lugar, se recomienda actualizar la Raspberry Pi, esta acción se puede
realizar también a través de la consola de comandos.
sudo groupadd www-data
sudo usermod-a -G www-data www-data
Seguidamente procederemos a la instalación de Apache:
sudo apt-get install apache2
Cuando este proceso haya terminado, se habrá creado un directorio nuevo en
/var/www donde se localizarán los archivos HTML y PHP del servidor, generándose
además un archivo llamado index.php.
Escribiendo la dirección IP de nuestra Raspberry Pi en el navegador nos aparecerá
una página con la frase “It Works!” indicándonos de esta manera que el servidor ha sido
instalado correctamente.
Figura 58. Instalación Apache
Seguidamente pasamos a instalar PHP, este lenguaje nos permitirá crear webs
dinámicas:
sudo apt-get install php5
A continuación, instalaremos los paquetes disponibles:
97
sudo apt-get install libapache2-mod-php5 libapache2-mod-
perl2 php5 php5-cli php5-common php5-curl php5-dev php5-gd
php5-imap php5-ldap php5-mhash php5-mysql php5-odbc
Una vez finalizado, reiniciaremos nuestra Raspberry Pi:
sudo reboot
Para comprobar que ha sido instalado realizaremos una prueba con PHP:
sudo nano /var/www/info.php
Y escribiremos dentro del documento el siguiente código:
<?php
phpinfo();
?>
Igual que en el caso anterior, nos iremos al navegador e introduciremos la IP de
nuestra Raspberry Pi.
Figura 59. Instalación PHP
98
Por último, realizaremos la instalación de MySQL, se trata de una base de datos la
cual permite almacenarlos.
sudo apt-get install mysql-server mysql-client php5-
mysql
Cuando termine la instalación se nos pedirá introducir una contraseña y una vez
introducida pasaremos a iniciar MySQL:
sudo service mysql start
En este caso, para comprobar su correcto funcionamiento, escribiremos en la
consola el siguiente comando, seguido de la contraseña previamente definida:
mysql -uroot –p*****
Si el siguiente comando en aparecer por consola es “mysql>” podremos saber que
la instalación se ha realizado correctamente.
99
8.6 Script para la creación de un Daemon:
Este script es el siguiente:
. /lib/lsb/init-functions
Definiremos ahora, las variables que nos servirán para la identificación del
programa:
DAEMON=/home/pi/serialtest.py
NOMBRE=Alarma
DESCRIPCION="Servicio de Alarma"
Comprobaremos si el programa ya se encuentra en ejecución, y si esto es asi,
terminaría el script:
test -x $DAEMON || exit 0
El siguiente comando nos detendrá el script siempre que el programa devuelva un
código de salida diferente de cero.
set -e
La siguiente estructura de control se encarga de la programación de nuestro
subsistema, debe tener 4 operaciones obligatorias, start, stop y restart.
- Start, se encargará de ejecutar el nuestro programa en Python.
- Stop, tendrá la finalidad de pararlo una vez que este no reciba información.
- Restart, recargará la configuración y si no es capaz comanzará con el reinicio.
case "$1" in
100
start)
log_daemon_msg "Arrancando $DESCRIPCION" "$NOMBRE"
start-stop-daemon // ayuda a controlar la ejecución de
subsistemas.
--start //inicia el programa
--background //Lo sitúa en segundo plano
--pidfile /var/run/$NOMBRE.pid--make-pidfile //Creación del
fichero para la identificación del mismo
--quiet --startas /bin/bash -- -c "exec $DAEMON >$LOGFILE
2>$ERRFILE"
log_end_msg $?
;;
stop)
log_daemon_msg "Parando $DESCRIPCION" "$NOMBRE"
start-stop-daemon --stop --oknodo --quiet --pidfile
/var/run/$NOMBRE.pid
log_end_msg $?
;;
restart)
log_daemon_msg "Reiniciando $DESCRIPCION" "$NOMBRE"
start-stop-daemon --stop --oknodo --quiet --pidfile
/var/run/$NOMBRE.pid
sleep 1
start-stop-daemon --start --background --pidfile
/var/run/$NOMBRE.pid --make-pidfile --quiet --startas
/bin/bash -- -c "exec $DAEMON >$LOGFILE 2>$ERRFILE"
log_end_msg $?
;;
force-reload)
restart
;;
*)
101
log_failure_msg "Uso: /etc/init.d/$NOMBRE
{start|stop|restart|force-reload}"
esac
exit 0
102
PARTE IV
BIBLIOGRAFÍA
103
REFERENCIAS BIBLIOGRÁFICAS
[1] Low Power Radio Solutions:
http://www.lprs.co.uk/index.html
[2] Foro LPRS:
http://www.lprs.co.uk/resource-centre/connect2-forum
[3] Tesis profesional, Implementación de sistemas inalámbricos por
medio de PICS:
http://catarina.udlap.mx/u_dl_a/tales/documentos/lep/bracho_m_ea
[4] Placa Arduino Uno:
https://www.arduino.cc/en/Main/ArduinoBoardUno
[5] Foro Arduino:
https://forum.arduino.cc/
[6] Webcam Logitech c270:
http://www.logitech.com/es-es/product/hd-webcam-c270
[7] Raspberry Pi 3 Model B:
https://www.raspberrypi.org/products/raspberry-pi-3-model-b
[8] Python desde PHP:
http://a-wela.blogspot.com.es/2014/12/ejecutar-script-de-python-desde-
php.html
[9] Information about automation engineering:
http://jacekhryniewicz.wixsite.com/website
[10] Software Test and Integration Engineer:
http://frederickvandenbosch.be/
[11] Programación en Python:
www.es.python.org/
[12] Gauchat, J.D. El gran libro de HTML5, CSS3 y Javascript. 2013.
104
