prototipo de sistema de seguridad en vehículos de transporte
Anuncio
PROTOTIPO DE SISTEMA DE SEGURIDAD EN VEHÍCULOS DE
TRANSPORTE PUBLICO QUE PERMITE LA CAPTURA DE IMAGEN
FOTOGRÁFICA, POSICIONAMIENTO GLOBAL Y ALMACENAMIENTO
EN BASE DE DATOS
AUTORES:
JONATHAN FERNEY GONZALEZ BENAVIDES
CARLOS ARTURO MARIN MENDEZ
UNIVERSIDAD DISTRITAL FRANCISCO JOSÉ DE CALDAS
FACULTAD TECNOLÓGICA
PROYECTO CURRICULAR DE INGENIERIA EN TELECOMUNICACIONES
Bogotá D.C., Colombia
2015
PROTOTIPO DE SISTEMA DE SEGURIDAD EN VEHÍCULOS DE
TRANSPORTE PUBLICO QUE PERMITE LA CAPTURA DE IMAGEN
FOTOGRÁFICA, POSICIONAMIENTO GLOBAL Y ALMACENAMIENTO
EN BASE DE DATOS
JONATHAN FERNEY GONZALEZ BENVIDES
CARLOS ARTURO MARIN MENDEZ
Código: 20122273010
Código: 20122273002
Monografía presentada como requisito parcial para optar al título de:
Ingeniería en Telecomunicaciones
Director:
HERMES JAVIER ESLAVA BLANCO, M.Sc. Ph.D(c)
UNIVERSIDAD DISTRITAL FRANCISCO JOSÉ DE CALDAS
FACULTAD TECNOLÓGICA
PROYECTO CURRICULAR DE INGENIERIA EN TELECOMUNICACIONES
Bogotá D.C., Colombia
2015
PROTOTIPO DE SISTEMA DE SEGURIDAD EN VEHÍCULOS DE TRANSPORTE
PUBLICO QUE PERMITE LA CAPTURA DE IMAGEN FOTOGRÁFICA,
POSICIONAMIENTO GLOBAL Y ALMACENAMIENTO EN BASE DE DATOS
PÁGINA DE APROBACIÓN
Observaciones
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
_______________________________
Hermes Javier Eslava Blanco, m.sc. ph.d(c)
Director Del Proyecto
_______________________________
José David Cely Callejas
Jurado
Fecha de Presentación:
Resumen
El objeto principal del proyecto es el diseño de un dispositivo de seguridad en vehículos capaz de
capturar datos de posición geográfica, tomar fotografías y enviar esta información vía internet, para
ser alojados en una base de datos y visualizados a través de una página web. Este prototipo se diseñó
usando la plataforma Raspberry Pi 2 Modelo B, la cual proporciona mayores garantías en términos de
compatibilidad y versatilidad. Se diseñó una base de datos en un servidor remoto con MySQL para la
importación de la información recibida y permitirle al usuario final previamente registrado, consultar
esta información vía web.
Con este prototipo se pretende ofrecer una alternativa tecnológica para mitigar la inseguridad en
vehículos de trasporte público y reforzar el sistema integral de seguridad para el beneficio de la
comunidad en general.
Abstract
The main purpose of the project is the design of a vehicle safety device enable for capturing
geographical positional data, take pictures and send information by Internet, to be housed in a
database and displayed through a web page. This prototype was designed using the platform
Raspberry Pi 2 Model B, this platform provides greater guarantees in terms of compatibility and
versatility. The database was designed on a remote server with MySQL for the import of the
information received and permits the end user previously registered, access this information via the
web.
With this prototype is intended to provide a technological alternative to mitigate insecurity in public
transport vehicles and reinforce the comprehensive security system for benefit of the community.
4
Contenido
Resumen................................................................................................................................................... 4
Contenido ................................................................................................................................................. 5
Lista de tablas ........................................................................................................................................... 8
Lista de figuras ......................................................................................................................................... 9
Lista de términos .................................................................................................................................... 10
Glosario .................................................................................................................................................. 11
Introducción ........................................................................................................................................... 12
1.
DESCRIPCIÓN DEL PROYECTO ........................................................................................................ 13
1.1.
2.
OBJETIVOS .............................................................................................................................. 13
1.1.1.
Objetivo General ............................................................................................................ 13
1.1.2.
Objetivos Específicos ...................................................................................................... 13
METODOLOGÍA............................................................................................................................... 14
2.1.
Diseño del Hardware .............................................................................................................. 14
2.2.
Diseño Web y base de datos .................................................................................................. 14
2.3.
Fases del proyecto.................................................................................................................. 15
3.
MODELO DE FACTIBILIDAD TECNOLÓGICA .................................................................................... 17
4.
MARCO TEÓRICO ............................................................................................................................ 21
4.1.
HTML (HyperText Markup Language) .................................................................................... 21
4.1.1.
4.2.
Estructura de cabecera................................................................................................... 21
PHP (Hypertext Preprocessor) ............................................................................................... 21
4.2.1.
Características PHP ......................................................................................................... 22
4.3.
WAMP SERVER ....................................................................................................................... 22
4.4.
CSS .......................................................................................................................................... 23
4.5.
JAVA SCRIPT............................................................................................................................ 24
4.5.1.
API de Google Maps ....................................................................................................... 24
5
4.6.
SERVIDOR WEB ....................................................................................................................... 25
4.7.
SERVIDOR FTP......................................................................................................................... 25
4.8.
MD5 (Message-Digest Algorithm) .......................................................................................... 25
4.9.
BASES DE DATOS .................................................................................................................... 25
4.9.1.
Tipos de bases de datos ................................................................................................. 26
4.9.2.
Sistema Gestor de Base de Datos ................................................................................... 28
4.9.3.
MySQL............................................................................................................................. 28
4.9.4.
Modelo de Entidad – Relación....................................................................................... 29
4.10.
GPS...................................................................................................................................... 30
4.10.1.
Introducción ................................................................................................................... 30
4.10.2.
Elementos que lo componen.......................................................................................... 30
4.10.3.
Funcionamiento.............................................................................................................. 30
4.10.4.
Fiabilidad de los datos .................................................................................................... 31
4.10.5.
Fuentes de error ............................................................................................................. 31
4.10.6.
GPS diferencial................................................................................................................ 32
4.10.7.
Coordenadas GPS ........................................................................................................... 32
4.10.8.
Múltiples sistemas de coordenadas para coordenadas geográficas .............................. 33
4.10.9.
Unidades de medida para las coordenadas GPS ............................................................ 34
4.11.
TRANSMISIÓN DE DATOS EN LA RED CELULAR .................................................................. 35
4.11.1.
Telefonía Móvil 3G ......................................................................................................... 35
4.11.2.
Comparación de la velocidad de los estándares de la telefonía móvil .......................... 36
4.12.
RASPBERRY PI ..................................................................................................................... 37
4.12.1.
Hardware Raspberry Pi ................................................................................................... 37
4.12.2.
Accesorios para Raspberry Pi ......................................................................................... 39
4.12.3.
Software para Raspberry Pi ............................................................................................ 41
4.13.
PYTHON Y RASPBERRY ........................................................................................................ 42
4.13.1.
5.
Python ............................................................................................................................ 42
DESARROLLO DEL PROYECTO ......................................................................................................... 44
5.1.
DISEÑO DE HARDWARE .......................................................................................................... 44
5.1.1.
Inicio de Raspberry Pi ..................................................................................................... 45
5.1.2.
Adaptación de módulos y Programación de Raspberry Pi ............................................. 51
5.1.3.
Internet móvil con el modem 3G USB Huawei E173 en la Raspberry ............................ 59
6
5.2.
6.
DISEÑO DE APLICATIVO .......................................................................................................... 63
5.2.1.
Instalación WAMP Server: .............................................................................................. 63
5.2.2.
Transferencia de información ........................................................................................ 64
5.2.3.
Creación de base de datos, tabla y conexión de MySQL con PHP ................................. 65
5.2.4.
Visualización ................................................................................................................... 72
Pruebas técnicas............................................................................................................................. 75
6.1.
Prueba de Estrés: ................................................................................................................... 76
7.
Conclusiones................................................................................................................................... 78
A.
Anexo: Script “principal.py” ........................................................................................................... 79
B.
Anexo: Script “pulsador.py” ........................................................................................................... 80
D.
Anexo: Script “picam.py” ............................................................................................................... 82
E.
Anexo: Script “iniciogps.py” ........................................................................................................... 85
F.
Anexo: Script “envioFTP.py” .......................................................................................................... 87
H.
Anexo: Script “mapa.php” .............................................................................................................. 89
8.
Bibliografía ..................................................................................................................................... 90
7
Lista de tablas
Tabla 1: Fases del proyecto .................................................................................................................... 16
Tabla 2: Comparación entre plataformas electrónicas modernas compuestas. ................................... 17
Tabla 3: Comparación entre lenguajes de programación. ..................................................................... 18
Tabla 4: Comparación entre servidores de mapas. ................................................................................ 20
Tabla 5: Comparación entre los tiempos de respuesta de los mapas.................................................... 20
Tabla 6: Correlación entre coordenadas Decímales y Sexagesimales. [21] .......................................... 34
Tabla 7: Comparación de la velocidad de los estándares de la telefonía móvil. [23] ............................ 36
Tabla 8: Conexiones GPIO. [26] .............................................................................................................. 38
Tabla 9: Extensión de conexiones GPIO para modelo B versión 2. [26]................................................. 39
Tabla 10: Es pesificaciones técnicas del módulo GPS. [30] .................................................................... 41
Tabla 11: Tabla de Monitoreo en MySQL ............................................................................................... 66
Tabla 12: Tabla de registro ..................................................................................................................... 67
8
Lista de figuras
Figura 1: Modelo Top-Down para el diseño de Hardware. .................................................................... 14
Figura 2: Modelo cascada para el diseño de software ........................................................................... 15
Figura 3: Entorno de Administración WampServer. [5] ......................................................................... 23
Figura 4. Representación de mapa en Google Maps. [8] ....................................................................... 24
Figura 5: Gestores de bases de datos. [14] ............................................................................................ 28
Figura 6: Cálculo de la posición usado tres satélites. [17] ..................................................................... 31
Figura 7. División de la superficie terrestre en paralelos y meridianos. [20]......................................... 33
Figura 8: Placa Raspberry pi. [24] ........................................................................................................... 37
Figura 9: Raspberry pi Modelo B. [25].................................................................................................... 38
Figura 10: Modulo cámara para Raspberry pi. [28] ............................................................................... 39
Figura 11: Modulo GPS Ublox NEO 6M. [29] .......................................................................................... 40
Figura 12: Interfaz del programa SD Formatter. [34] ............................................................................. 45
Figura 13: Pantalla inicial de Pi Recovery. [36] ...................................................................................... 47
Figura 14: Menú principal de configuración de Raspbian. [36] ............................................................. 47
Figura 15: Menú de opciones de internacionalización de Raspbian. [36] ............................................. 48
Figura 16: XMING con Raspberry Pi iniciar startlxde. [38] ..................................................................... 50
Figura 17: Conexión de la cámara a la interfaz CSI de la Raspberry Pi. [39] .......................................... 53
Figura 18: Esquema y conexión de módulo Ublox M6 a Raspberry pi. [41] .......................................... 56
Figura 19: Pantalla de terminal con datos del GPS. [41] ........................................................................ 57
Figura 20: Correo electrónico recibido de emergencia.......................................................................... 58
Figura 21: Datos almacenados para la importación en la base de datos............................................... 58
Figura 22: Pantalla inicial de Sakis 3G interactivo. ................................................................................. 62
Figura 23: Interfaz de logeo de phpMyAdmin ....................................................................................... 64
Figura 24: Interfaz TYPSoft FTP Server ................................................................................................... 65
Figura 25: Esquema entidad relación ..................................................................................................... 68
Figura 26: Diagrama de bloques del registro de usuario ....................................................................... 70
Figura 27: Diagrama de bloques inicio sesión ........................................................................................ 71
Figura 28: Entorno Web, consulta sin datos de tabla monitoreo .......................................................... 72
Figura 29: Entorno Web consulta datos tabla monitoreo ..................................................................... 72
Figura 30: Captura de coordenadas en Google Maps ............................................................................ 73
Figura 31: Google Developers equipo escritorio. ................................................................................... 75
Figura 32: Google Developers dispositivo móvil. ................................................................................... 76
Figura 33. Prueba de carga de conexión con 25 usuarios. ..................................................................... 76
Figura 34. Respuesta de páginas y estilos. ............................................................................................. 77
Figura 35. Tiempo respuesta plataforma web. ...................................................................................... 77
9
Lista de términos
CSS:
Cascading Style Sheets
XML:
eXtensible Markup Language
WML:
Wireless Markup Language
MD5:
Message-Digest Algorithm 5
DBA:
Data Base Administrator
SGBD:
Data Base Management System
SQL:
Structured Query Language
C:
Lenguaje de programación
NAVSTAR: Navigation System Using Timing and Ranging
GNSS:
Global Navigation Satellite System
GLONASS: Global'naya Navigatsionnaya Sputnikovaya Sistema
WAAS:
Wide Area Augmentation System
EGNOS:
European Geostationary Navigation Overlay Service
MSAS:
Multi-functional Satellite Augmentation System
GAGAN:
GPS Aided Geo Augmented Navigation
GPRS:
General Packet Radio Service
EDGE:
Enhanced Data rates for GSM Evolution
UMTS:
Universal Mobile Telecommunications System
WCDMA:
Wideband Code Division Multiple Access
CDMA:
Code Division Multiple Access
HSDPA:
High Speed Downlink Packet Access
LTE:
Long Term Evolution
SBC:
Single Board Computer
GPIO:
General Purpose Input/Output
IDE:
Integrated Development Environment
UNIX:
Sistema operativo
10
Glosario
3G:
Abreviatura de tercera generación de transmisión de voz y datos a través de la
telefonía móvil.
Browser:
Software, aplicación o programa que permite la navegación en la web.
API:
(Application Programming Interface), interfaz de programación de aplicaciones.
Apache:
Servidor HTTP Apache de código abierto, para plataformas Linux, Microsoft,
Macintosh etc.
Cámara:
Dispositivo tecnológico cuyo objetivo es la captura de imágenes.
Directorio:
Contenedor virtual de archivos.
Google Maps: Servidor de aplicaciones de mapas en la web, pertenece a la empresa Google.
GPS:
(Global Position System) Sistema de posicionamiento global que permite determinar
la posición de un objeto (persona, un vehículo etc.).
FTP:
(File Text Protocol), transferencia de archivos entre dispositivos que proporciona
seguridad y orden en la transferencia.
HTML:
Lenguaje de marcas de hipertexto para la elaboración de páginas web.
HTTP:
(Hypertext Transfer Protocol) usado para la transacción de la World Wide Web.
JavaScript:
Lenguaje de programación de uso principalmente para desarrollo de páginas web
dinámicas.
MySQL:
Gestor de bases de datos relacional, multihilo y multiusuario.
Raspberry PI: Mini ordenador que puede ser usado como servidor de contenidos.
Raspbian:
Sistema operativo Linux para Raspberry basado en Debian.
PHP:
(Hypertext PreProcessor), lenguaje de código abierto especialmente adecuado para
desarrollo web y puede ser incrustado en HTML.
Python:
Lenguaje de programación de alto nivel, interpretado y multipropósito.
SHELL:
Término usado en informática para referirse a un intérprete de comandos.
WampServer: Entorno de desarrollo web (Windows-Apache-MySQL-Php/Phyton/Perl).
11
Introducción
Pensando en la vinculación de proyectos que contribuyan a la mejora y desarrollo de los sistemas de
seguridad ciudadana, surge la necesidad de elaborar alternativas y estrategias en búsqueda del
fortalecimiento integral de seguridad.
La inseguridad en la ciudad es uno de los problemas más sentidos por la población, que afecta las
diversas actividades económicas, sociales, recreativas, educativas, entre otras, con diferente
intensidad.
Según el Observatorio de Seguridad de Bogotá de la Cámara de Comercio, la percepción de seguridad
en el primer semestre del 2013 es la siguiente. El taxi es la modalidad de transporte público
considerada más segura por los encuestados; no obstante, su percepción positiva se reduce en 7
puntos. El Transmilenio es señalado seguro solo por el 23% de los encuestados y el taxi por el 18%. En
el caso del taxi, indican que la posibilidad de solicitarlo directamente a la empresa, es la razón
principal para percibirlo como un medio de trasporte seguro. Quienes lo consideran inseguro, señalan
la posibilidad de ser víctima de paseo millonario y de fleteo. Quienes consideran que el Transmilenio
es seguro, señalan como razones más importantes la presencia de policía y de vigilancia privada. Los
demás argumentan que hay exceso de personas e indican que se presentan casos de robos y atracos.
De esta manera, la Cámara de Comercio informa que el transporte público de pasajeros sigue siendo
uno de los escenarios donde se registra la mayor victimización, los más altos niveles de percepción de
inseguridad y de conflictividad en la ciudad. Por tanto, es preciso mejorar la calidad de la información
a fin de comprender la magnitud de los hechos que ocurren en el sistema de transporte de la ciudad y
proponer estrategias concretas y públicas que permitan mejorar las condiciones de seguridad. [1]
En este caso, el proyecto está enfocado al diseño y desarrollo de un prototipo tecnológico de
seguridad vehicular, que busca satisfacer las necesidades básicas mediante envío de reportes
periódicos a una base de datos, de localización geográfica del vehículo a través de GoogleMaps,
capturas fotográficas al interior del vehículo, dirección, estado de activación automática o de
emergencia, fecha y hora, de tal manera que esta información pueda ser consultada cuando el
usuario lo requiera en internet.
La proyección a futuro, es que el prototipo sirva como base para elaborar una plataforma más
robusta, que contenga mayores elementos en los reportes y mejoras en la eficiencia operativa para
proporcionar un sistema de seguridad más optimizado.
12
1. DESCRIPCIÓN DEL PROYECTO
1.1.
1.1.1.
OBJETIVOS
Objetivo General
Diseñar y desarrollar un sistema de seguridad en vehículos de transporte público de pasajeros,
realizando captura de imágenes fotográficas y simultáneamente obteniendo la ubicación del vehículo,
esta información adquirida podrá ser consultada por el usuario interesado vía web.
1.1.2.
Objetivos Específicos
Diseñar el sistema físico y operacional capaz de capturar imágenes fotográficas y
coordenadas de posicionamiento, transmitiendo los datos obtenidos a través de la red celular
a un servidor remoto.
Diseñar una base de datos para almacenar la información recibida y ser consultada vía web.
Validar, comparar y analizar la veracidad de los datos transmitidos y recibidos, realizando
diversas pruebas en vehículos y ubicaciones diferentes.
13
2. METODOLOGÍA
A continuación, se describe la metodología implementada para el diseño del hardware y el software
utilizado para el funcionamiento general del proyecto.
2.1.
Diseño del Hardware
Para el desarrollo completo del dispositivo físico se realizó con el diseño Top-Down. El diseño TopDown consiste en capturar una idea con un alto nivel de abstracción, implementarla partiendo de la
misma, e incrementar el nivel de detalle según sea necesario. El sistema inicial se va subdividiendo en
módulos, estableciendo una jerarquía. Cada módulo se subdivide cuantas veces sea necesario hasta
llegar a los componentes primarios del diseño como muestra el esquema de la figura.
Figura 1: Modelo Top-Down para el diseño de Hardware.
2.2.
Diseño Web y base de datos
Para el desarrollo WEB y creación de la base de datos, la elección del modelo de software para este
caso fue el modelo cascada, el desarrrollo secuencial de las fases permite que a medida que se
termina un bloque, le de vida al siguiente y permita compactar y complementar el desarrollo y
ejecución del diseño. Este modelo, fue la mejor práctica encontrada para el tipo de proyecto
implementado. A continuación la respresentación del esquema.
14
Figura 2: Modelo cascada para el diseño de software
2.3.
Fases del proyecto
Para dar cumplimiento a los objetivos específicos, se siguieron una serie de actividades, las cuales dan
indicios del proceso seguido para la finalidad del proyecto.
En la siguiente tabla, se relacionan las actividades principales.
Investigación y análisis de las posibilidades de dispositivos electrónicos y nuevas
tecnologías que faciliten la creación del hardware requerido.
Elección de la mejor opción en relación costo-beneficio y adquisición de los materiales
indispensables para la fabricación del hardware.
Diseño del sistema
físico local
Diseño de un diagrama del circuito, acoplando los diferentes módulos que interfieren
en el dispositivo.
Acoplamiento e implementación de los módulos electrónicos para la función
requerida.
Pruebas y revisión del funcionamiento del dispositivo, verificando la compatibilidad,
tiempos de respuesta y capacidad de almacenamiento.
Diseño del sistema
físico remoto
Evaluar características, ventajas y desventajas sobre el servidor a utilizar para el
desarrollo, procesamiento y visualización de la información.
Integración y configuración del servidor remoto, para el almacenamiento de archivos
FTP, base de datos y pagina web.
15
Configuración local de red del servidor para ser identificado en internet y lograr recibir
información externa enviada del dispositivo Raspberry.
Estudio sobre los diferentes lenguajes de programación necesarios.
Manejo de comandos en la Shell del sistema operativo de la Raspberry.
Programación de
código fuente
Creación del código en Python para el control de los módulos y el procesamiento de los
archivos en la Raspberry Pi.
Manejo y aplicación del API de Google Maps para la incorporación y modificación, en
código JavaScript, PHP y HTML.
Importación de la información recibida con sentencias SQL, y programación en HTML,
PHP y JavaScript para la publicación de la información.
Adquisición de los datos primordiales, como imágenes y coordenadas de
posicionamiento.
Validación,
comparación y
análisis de los datos
transmitidos y
recibidos
Pruebas de captura de imágenes, con diferentes entornos y cambios de iluminación, al
igual que el almacenamiento de manera local.
Validación de la transmisión de los datos a través de la red local y la red 3G,
diagnosticando tiempos, cantidad de datos, costos y perdidas de conectividad.
Revisión de la veracidad y concordancia de los datos transmitidos con los recibidos,
registrados en la base de datos y visualización en la página web por usuario registrado.
Tabla 1: Fases del proyecto
16
3. MODELO DE FACTIBILIDAD TECNOLÓGICA
Tabla 2: Comparación entre plataformas electrónicas modernas compuestas.
17
Tabla 3: Comparación entre lenguajes de programación.
18
19
Tabla 4: Comparación entre servidores de mapas.
Tabla 5: Comparación entre los tiempos de respuesta de los mapas.
20
4. MARCO TEÓRICO
4.1.
HTML (HyperText Markup Language)
Es el lenguaje que se emplea para el desarrollo de páginas de internet.
HTML es un lenguaje de marcado que nos permite indicar la estructura de nuestro documento
mediante etiquetas. Este lenguaje nos ofrece una gran adaptabilidad, una estructuración lógica y es
fácil de interpretar tanto por humanos como por máquinas, ya que siguen un esquema de árbol
donde existe un elemento raíz y donde el resto de etiquetas se insertan de manera lógica y
estructurada. Además, se trata de un fichero de texto, y solo se necesita un editor como el bloc de
notas para generar un documento HTML.
4.1.1.
Estructura de cabecera
Información contextual de la página. Estos metadatos nos permiten indicar información que
puede no quedar clara en el contenido.
Referencia a otros ficheros. Todos aquellos recursos que necesite nuestra página deben estar
referenciados desde la cabecera. Por ejemplo, archivos de CSS y JavaScript, el icono de la
barra de direcciones, etc.
Scripts y estilos. Si estos no se definen en un fichero independiente, se incluyen en la sección
de cabecera para que estén disponibles en todo el documento y no tener que repetirlos.
Por otro lado, en el cuerpo se encuentra todo el contenido de la página, desde el texto a las
imágenes, pasando por vídeos, enlaces, etc. Este contenido debe estar estructurado en diferentes
secciones y marcado correctamente. [2]
4.2.
PHP (Hypertext Preprocessor)
A diferencia de Java o JavaScript que se ejecutan en el navegador, PHP se ejecuta en el servidor, por
eso nos permite acceder a los recursos que tenga el servidor; ejemplo: una base de datos. El
programa PHP es ejecutado en el servidor y el resultado enviado al navegador. Al ser PHP un lenguaje
21
que se ejecuta en el servidor, no es necesario que su navegador lo soporte, es independiente del
navegador, sin embargo para que las páginas PHP funcionen, el servidor donde están alojadas debe
soportar PHP. [3]
4.2.1.
Características PHP
Algunas de las características más relevantes de PHP son:
1. Libertad de elegir el sistema operativo y el servidor web. Además, se tiene la posibilidad de
utilizar programación por procedimientos o programación orientada a objetos (POO), o una
mezcla de ambas.
2. Una de las características más potentes y destacables de PHP es su soporte para un amplio
abanico de bases de datos. Escribir una página web con acceso a una base de datos es simple
utilizando una de las extensiones específicas de bases de datos (ejemplo: MySQL) o utilizar
una capa de abstracción como PDO, o conectarse a cualquier base de datos que admita el
estándar de Conexión Abierta a Bases de Datos por medio de la extensión ODBC.
3. PHP también cuenta con soporte para comunicarse con otros servicios usando protocolos
tales como LDAP, IMAP, SNMP, NNTP, POP3, HTTP, COM (en Windows) y muchos otros.
También se pueden crear sockets de red puros e interactuar usando cualquier otro protocolo.
[4]
4.3.
WAMP SERVER
Es un acrónimo para describir un sistema de infraestructura que usa las siguientes herramientas
(Windows-Apache-MySQL-PHP, Perl o Python), este entorno de desarrollo web permite tener un
servidor propio o host local (instalado en el equipo). Es usado (entre otros) por desarrolladores y/o
programadores para realizar prácticas de sus proyectos web antes de subirlos al servidor web en
internet. [5]
Características:
Manejo de Bases de datos con MySQL
Software para servidor web Apache
Software para poder programar script con PHP (generalmente).
Permite el manejo sencillo de Bases de Datos con PHPMyAdmin y SQLiteManager
Es gratuito.
22
Figura 3: Entorno de Administración WampServer. [5]
4.4.
CSS
El concepto de hojas de estilo apareció por primera vez en 1996 cuando W3C publicó una
recomendación nueva intitulada "Hojas de estilo en cascada" o CSS, su sigla en inglés.
El principio de las hojas de estilo, consiste en la utilización de un solo documento para almacenar las
características de presentación de las páginas asociadas a grupos de elementos. Esto implica nombrar
un conjunto de definiciones y características de presentación de las páginas, y activar esos nombres
para aplicarlos a una parte del texto. Por ejemplo, se pueden configurar los títulos de una sección
para que aparezcan en fuente Arial, en color verde y en cursiva.
Las hojas de estilo se desarrollaron para compensar los defectos de HTML con respecto a la
presentación y al diseño de las páginas. HTML tiene varias etiquetas para modificar la presentación y
definir los estilos del texto, pero cada elemento tiene su propio estilo, independientemente de los
elementos que lo rodean. Al utilizar hojas de estilo, cuando se necesite cambiar la apariencia de un
sitio que tiene cientos de páginas Web todo lo que hay que hacer es editar las definiciones de la hoja
de estilo en un solo lugar para cambiar la apariencia del sitio completo.
Se denominan "hojas de estilo en cascada" porque se pueden definir múltiples hojas y los estilos
pueden aplicarse a todas las páginas (con un sistema predefinido para resolver conflictos).
Las hojas de estilo pueden utilizarse para:
Lograr una apariencia uniforme de todo el sitio al activar una sola definición de estilo en cada
página.
Cambiar un aspecto en todo el sitio Web con tan sólo editar unas pocas líneas.
Hacer que los códigos HTML sean más fáciles de leer ya que los estilos se definen por
separado.
Permitir que las páginas se carguen más rápido ya que hay menos cantidad de HTML en cada
página.
Posicionar los elementos de la página de una manera más uniforme. [6]
23
4.5.
JAVA SCRIPT
JavaScript es un sencillo lenguaje de programación, que presenta una característica especial: sus
programas, llamados comúnmente scripts, se enlaza en las páginas HTML y se ejecutan en el
navegador (Mozilla Firefox, Microsoft Internet Explorer,...). Estos scripts normalmente consisten en
unas funciones que son llamadas desde el propio HTML cuando algún evento sucede. De ese modo,
podemos añadir efectos como que un botón cambie de forma al pasar el ratón por encima, o abrir
una ventana nueva al pulsar en un enlace. [7]
4.5.1.
API de Google Maps
Es sólo HTML, CSS y JavaScript trabajando junto. Los mapas son solo imágenes que se cargan en el
fondo a través de peticiones ejecutadas por la tecnología de AJAX, y se insertan en un <div> en la
página HTML. Mientras navegas en el mapa, el API envía información acerca de las nuevas
coordenadas y los niveles de “zoom” del mapa a través de AJAX y esto retorna las imágenes.
El API consiste de archivos JavaScript que contienen las clases, métodos y propiedades que se usan
para el comportamiento de los mapas. La última versión del API es la 3.0.
Figura 4. Representación de mapa en Google Maps. [8]
Las coordenadas están expresadas usando números decimales separados por coma. La latitud
siempre precede la longitud. La latitud es positiva si va después del punto mostrado en el mapa y
negativo si va antes. La longitud es positiva si va arriba del punto y negativa si va debajo.
El código a utilizar es el siguiente:
<script
src="https://maps.googleapis.com/maps/api/js?v=3.exp&signed_in=true"></script>
Es importante que el código mencionado anteriormente, se encuentre debajo del elemento
<script> que incluye el API, para que así se pueda cargar todas las clases, métodos y propiedades a
usar. Las clases, métodos y propiedades comienzan con google.maps. A eso se le conoce
como namespace. [8]
24
4.6.
SERVIDOR WEB
Los servidores web son los encargados de recibir las peticiones referidas a páginas o elementos de la
web a través del protocolo http o https y de devolver el resultado de la petición, que suele ser un
recurso alojado en el servidor. Normalmente es el navegador el que pide al servidor web el recurso
que desea el usuario, para finalmente recibir dicho recurso (si fue válida la petición) y traducirle si es
necesario a su forma legible por el usuario (es decir la traducción de HTML la hace el navegador). [9]
4.7.
SERVIDOR FTP
Uno de los servicios más antiguos de Internet, File Transfer Protocol permite mover uno o más
archivos con seguridad entre distintos ordenadores proporcionando seguridad y organización de los
archivos así como control de la transferencia.
La seguridad se ha convertido en un tema candente. Durante años, los servidores ftp comunicaban
con los clientes "en abierto," es decir, que la información de la conexión y de la contraseña era
vulnerable a la interceptación. Ahora, los servidores ftp, tales como BulletProof FTP, SecureFTP,
SurgeFTP, TitanFTP, y WS_FTP, soportan SSL/TLS y utilizan el mismo tipo de cifrado presente en los
sitios web seguros. Con SSL/TLS, los servidores ftp pueden cifrar los comandos de control entre los
clientes del ftp y el servidor, así como los datos del archivo. Con la ayuda del PGP, como en WS_FTP
pro, los datos del archivo se aseguran todavía más con el cifrado público. [10]
4.8.
MD5 (Message-Digest Algorithm)
El algoritmo MD5 se utiliza como una función de codificación o huella digital de un archivo. A menudo
empleado para codificar contraseñas en bases de datos, el MD5 es igualmente capaz de generar una
huella de archivo para asegurar que no haya cambios en el mismo tras una transferencia, por
ejemplo. Un hash MD5 está compuesto por 32 caracteres hexadecimales. [11]
4.9.
BASES DE DATOS
Un sistema de bases de datos sirve para integrar los datos, organizar campos, registros y archivos. Lo
componen los siguientes elementos:
Hardware. Máquinas en las que se almacenan las bases de datos. Incorporan unidades de
almacenamiento masivo para este fin.
Software. Es el sistema gestor de bases de datos. El encargado de administrar las bases de
datos.
25
Datos. Incluyen los datos que se necesitan almacenar y los metadatos que son datos que
sirven para describir lo que se almacena en la base de datos.
Usuarios. Personas que manipulan los datos del sistema. Hay tres categorías:
Usuarios finales. Aquellos que utilizan datos de la base de datos para su trabajo cotidiano
que no tiene por qué tener que ver con la informática. Normalmente no utilizan la base
de datos directamente, si no que utilizan aplicaciones creadas para ellos a fin de facilitar
la manipulación de los datos. Estos usuarios sólo acceden a ciertos datos.
Desarrolladores. Analistas y programadores encargados de generar aplicaciones para los
usuarios finales.
Administradores. También llamados DBA (Data Base Administrator), se encargan de
gestionar las bases de datos. [12]
4.9.1.
Tipos de bases de datos
Las bases de datos se pueden clasificar de varias maneras, según el contexto que se esté manejando o
su utilidad.
Según variabilidad de datos.
Bases de datos estáticas
Estas son bases de datos de solo lectura, utilizadas primordialmente para almacenar datos históricos
que posteriormente se pueden utilizar para estudiar el comportamiento de un conjunto de datos a
través del tiempo, realizar proyecciones y tomar decisiones.
Bases de datos dinámicas
Estas son bases de datos donde la información almacenada se modifica con el tiempo, permitiendo
operaciones como actualización, borrado y adición de datos, además de las operaciones
fundamentales de consulta.
De acuerdo a su modelo de administración de datos:
Bases de datos Jerárquicas
En este modelo los datos se organizan en una forma similar a un árbol (visto al revés), en donde
un nodo padre de información puede tener varios hijos. El nodo que no tiene padres es llamado raíz,
y a los nodos que no tienen hijos se los conoce como hojas. Son especialmente útiles en el caso de
aplicaciones que manejan un gran volumen de información y datos muy compartidos permitiendo
crear estructuras estables y de gran rendimiento.
Bases de datos de red
26
Éste es un modelo ligeramente distinto del jerárquico; la diferencia fundamental es la modificación
del concepto de nodo: se permite que un mismo nodo tenga varios padres (posibilidad no permitida
en el modelo jerárquico). Mejora la redundancia de datos sin embargo la administración es más
compleja y limita el uso del usuario final.
Bases de datos transaccionales
Son bases de datos cuyo único fin es el envío y recepción de datos a grandes velocidades, estas bases
son muy poco comunes y están dirigidas por lo general al entorno de análisis de calidad, datos de
producción e industrial.
Bases de datos relacionales
Éste es el modelo utilizado en la actualidad para modelar problemas reales y administrar datos
dinámicamente. En este modelo, el lugar y la forma en que se almacenen los datos no tienen
relevancia (a diferencia de otros modelos como el jerárquico y el de red). Esto tiene la considerable
ventaja de que es más fácil de entender y de utilizar para un usuario esporádico de la base de datos.
La información puede ser recuperada o almacenada mediante "consultas" que ofrecen una amplia
flexibilidad y poder para administrar la información.
Bases de datos multidimensionales
Son bases de datos ideadas para desarrollar aplicaciones muy concretas, los campos o atributos de
una tabla pueden ser de dos tipos, o bien representan dimensiones de la tabla, o bien representan
métricas que se desean estudiar.
Bases de datos orientadas a objetos
Este modelo, bastante reciente, y propio de los modelos informáticos enfocado a objetos, trata de
almacenar en la base de datos los objetos completos (estado y comportamiento). Paradigma,
herencia y polimorfismo son de los principales conceptos que incorpora el paradigma de objetos.
Bases de datos documentales
Permiten la indexación a texto completo, y en líneas generales realizar búsquedas más potentes.
Tesaurus es un sistema de índices optimizado para este tipo de bases de datos.
Bases de datos deductivas
Es un sistema de base de datos pero con la diferencia de que permite hacer deducciones a través de
inferencias. Se basa principalmente en reglas y hechos que son almacenados en la base de datos. Las
bases de datos deductivas son también llamadas bases de datos lógicas, a raíz de que se basa en
lógica matemática. [13]
27
4.9.2.
Sistema Gestor de Base de Datos
Un Sistema Gestor de Base de Datos (SGBD) es un sistema de software que permite la definición
de bases de datos; así como la elección de las estructuras de datos necesarios para el
almacenamiento y búsqueda de los datos, ya sea de forma interactiva o a través de un lenguaje de
programación. Un SGBD relacional es un modelo de datos que facilita a los usuarios describir los
datos que serán almacenados en la base de datos junto con un grupo de operaciones para manejar
los datos.
Los SGBD relacionales son una herramienta efectiva que permite a varios usuarios acceder a los datos
al mismo tiempo. Brindan facilidades eficientes y un grupo de funciones con el objetivo de garantizar
la confidencialidad, la calidad, la seguridad y la integridad de los datos que contienen, así como un
acceso fácil y eficiente a los mismos. [14]
Algunos de los principales gestores de bases de datos son:
MySQL
Microsoft SQL Server
PostgreSQL
Oracle
Figura 5: Gestores de bases de datos. [14]
4.9.3.
MySQL
Es un sistema gestor de bases de datos relacionales rápido, sólido y flexible. Es idóneo para la
creación de bases de datos con acceso desde páginas web dinámicas, así como para la creación de
cualquier otra solución que implique el almacenamiento de datos, posibilitando realizar múltiples y
rápidas consultas. Está desarrollado en C y C++, facilitando su integración en otras aplicaciones
desarrolladas también en esos lenguajes.
Es un sistema cliente/servidor, por lo que permite trabajar como servidor multiusuario y de
subprocesamiento múltiple, o sea, cada vez que se crea una conexión con el servidor, el programa
servidor establece un proceso para manejar la solicitud del cliente, controlando así el acceso
simultáneo de un gran número de usuarios a los datos y asegurando el acceso a usuarios autorizados
solamente. [15]
28
4.9.4.
Modelo de Entidad – Relación
El Modelo de Entidad Relación es un modelo de datos basado en una percepción del mundo real que
consiste en un conjunto de objetos básicos llamados entidades y relaciones entre estos objetos,
implementándose en forma gráfica a través del Diagrama Entidad Relación.
Hablamos de ejemplares cuando nos referimos a una clase de objetos con características similares
(ejemplares=registros). Se puede definir como Entidad a cualquier objeto, real o abstracto, que existe
en un contexto determinado o puede llegar a existir y del cual deseamos guardar información.
Los Atributos son características o propiedades asociadas a la entidad que toman valor en una
instancia particular. Ejemplo: nombre, cédula, teléfono.
Clave primaria: Se denomina Clave principal o primaria al atributo o conjunto mínimo de atributos
(uno o más campos) que permiten identificar en forma única cada instancia de la entidad, es decir, a
cada registro de la tabla. Las claves principales se utilizan cuando se necesita hacer referencia a
registros específicos de una tabla desde otra tabla. En un principio se puede identificar más de un
atributo que cumpla las condiciones para ser clave, los mismos se denominan Claves candidatas.
Tipos de relaciones
Clasificación por cardinalidad:
Relación Uno a Uno: Cuando un registro de una tabla sólo puede estar relacionado con un
único registro de la otra tabla y viceversa. En este caso la clave foránea se ubica en alguna de
las 2 tablas.
Relación Uno a Muchos: Cuando un registro de una tabla (tabla secundaria) sólo puede estar
relacionado con un único registro de la otra tabla (tabla principal) y un registro de la tabla
principal puede tener más de un registro relacionado en la tabla secundaria. En este caso la
clave foránea se ubica en la tabla secundaria.
Relación Muchos a Muchos: Cuando un registro de una tabla puede estar relacionado con
más de un registro de la otra tabla y viceversa. En este caso las dos tablas no pueden estar
relacionadas directamente, se tiene que añadir una tabla entre las dos (Tabla débil o de
vinculación) que incluya los pares de valores relacionados entre sí.
Clasificación por modalidad:
Dadas las tablas A y B, que se encuentran relacionadas: Si para todo registro de A debe existir siempre
al menos un registro de B asociado, se dice que la relación en sentido A->B es Obligatoria. Si para
todo registro de A, pueden existir o no, uno o varios registros de B asociados, se dice que la relación
en sentido A->B es optativa. La modalidad de las relaciones se debe analizar en ambos sentidos. [16]
29
4.10. GPS
Dado que el concepto principal de nuestro proyecto se basa en la tecnología GPS, veremos a
continuación algunos conceptos básicos sobre el Sistema de Posicionamiento Global, GPS.
4.10.1.
Introducción
El Global Positioning System (GPS) o Sistema de Posicionamiento Global originalmente
llamado NAVSTAR, es un Sistema Global de Navegación por Satélite (GNSS) el cual permite
determinar en todo el mundo la posición de una persona, un vehículo o una nave, con una desviación
de cuatro metros. El sistema fue desarrollado e instalado, y actualmente es operado, por
el Departamento de Defensa de los Estados Unidos.
4.10.2.
Elementos que lo componen
Sistema de satélites: Formado por 21 unidades operativas y 3 de repuesto en órbita sobre la tierra a
20.200 km con trayectorias sincronizadas para cubrir toda la superficie del globo. Se abastecen
mediante paneles de energía solar.
Estaciones terrestres: Envían información de control a los satélites para controlar las órbitas y realizar
el mantenimiento de toda la constelación.
Terminales receptores: Nos indica la posición en la que estamos, conocidas también como Unidades
GPS, son las que podemos adquirir en las tiendas especializadas.
4.10.3.
Funcionamiento
El receptor GPS funciona midiendo su distancia de los satélites, y usa esa información para calcular su
posición. Esta distancia se mide calculando el tiempo que la señal tarda en llegar al receptor.
Conocido ese tiempo y basándose en el hecho de que la señal viaja a la velocidad de la luz (salvo
algunas correcciones que se aplican), se puede calcular la distancia entre el receptor y el satélite.
Cada satélite indica que el receptor se encuentra en un punto en la superficie de la esfera con centro
en el propio satélite y de radio la distancia total hasta el receptor.
Obteniendo información de dos satélites se nos indica que el receptor se encuentra sobre la
circunferencia que resulta cuando se intersectan las dos esferas.
Si adquirimos la misma información de un tercer satélite notamos que la nueva esfera solo corta el
círculo anterior en dos puntos. Uno de ellos se puede descartar porque ofrece una posición absurda.
De esta manera ya tendríamos la posición en 3-D. Sin embargo, dado que el reloj que incorporan los
receptores GPS no está sincronizado con los relojes atómicos de los satélites GPS, los dos puntos
determinados no son precisos.
30
Teniendo información de un cuarto satélite, eliminamos el inconveniente de la falta de sincronización
entre los relojes de los receptores GPS y los relojes de los satélites. Y es en este momento cuando el
receptor GPS puede determinar una posición 3-D exacta (latitud, longitud y altitud). Al no estar
sincronizados los relojes entre el receptor y los satélites, la intersección de las cuatro esferas con
centro en estos satélites es un pequeño volumen en vez de ser un punto. La corrección consiste en
ajustar la hora del receptor de tal forma que este volumen se transforme en un punto.
Figura 6: Cálculo de la posición usado tres satélites. [17]
4.10.4.
Fiabilidad de los datos
Debido al carácter militar del sistema GPS, el Departamento de Defensa de los Estados Unidos se
reserva la posibilidad de incluir un cierto grado de error aleatorio que puede variar de los 15 a los 100
metros.
Aunque actualmente no aplique tal error inducido, la precisión intrínseca del sistema GPS depende
del número de satélites visibles en un momento y posición determinados. Sin aplicar ningún tipo de
corrección y con ocho satélites a la vista, la precisión es de 6 a 15 metros; pero puede obtenerse más
precisión usando sistemas de corrección (Ej: DGPS).
4.10.5.
Fuentes de error
Retraso de la señal en la ionosfera y troposfera.
Señal multirruta, producida por el rebote de la señal en edificios y montañas cercanos.
Errores de orbitales, donde los datos de la órbita del satélite no son completamente precisos.
Número de satélites visibles.
Geometría de los satélites visibles.
Errores locales en el reloj del GPS.
31
4.10.6.
GPS diferencial
DGPS (Differential GPS) o GPS diferencial es un sistema que proporciona a los receptores de GPS
correcciones a los datos recibidos de los satélites GPS. Estas correcciones, una vez aplicadas,
proporcionan una mayor precisión en la posición calculada.
El sistema de correcciones funciona de la siguiente manera:
Una estación base en tierra, con coordenadas muy bien definidas, escucha los satélites GPS.
Calcula su posición por los datos recibidos de los satélites.
Dado que su posición está bien definida, calcula el error entre su posición verdadera y la
calculada, estimando el error en cada satélite.
Se envía estas correcciones al receptor a través de algún medio.
Existen varias formas de obtener las correcciones DGPS. Las más usadas son:
Recibidas por radio a través de algún canal preparado para ello, como el RDS en una emisora
de FM.
Descargadas de Internet con una conexión inalámbrica.
Proporcionadas por algún sistema de satélites diseñado para tal efecto. En Estados Unidos
existe el WAAS, en Europa el EGNOS, en Japón el MSAS y en India el GAGAN, todos
compatibles entre sí.
Para que las correcciones DGPS sean válidas, el receptor tiene que estar relativamente cerca de
alguna estación DGPS, generalmente, a menos de mil kilómetros.
La precisión lograda puede ser de unos dos metros en latitud y longitud, y unos tres metros en altitud.
[18]
4.10.7.
Coordenadas GPS
Las coordenadas geográficas son un conjunto de líneas imaginarias que permiten ubicar con exactitud
un lugar en la superficie de la Tierra. Este conjunto de líneas corresponden a los meridianos y
paralelos.
Estas líneas o círculos son trazados por los cartógrafos sobre los mapas.
Cualquier punto de nuestro planeta puede ubicarse al conocerse el meridiano de longitud y el
paralelo de latitud. [19]
32
Figura 7. División de la superficie terrestre en paralelos y meridianos. [20]
Latitud
La latitud de un punto es la medida del ángulo formado por el plano ecuatorial con la línea que une a
éste punto al centro de la tierra.
Por regla general está comprendido entre -90 ° y 90 °. Los valores negativos son para ubicaciones en
el hemisferio sur, y el valor de la latitud es de 0 ° en el ecuador.
Longitud
La longitud tiene el mismo principio, con la diferencia en que no existe una referencia natural como lo
es el ecuador para la latitud. La referencia para la longitud ha sido establecida arbitrariamente en el
Meridiano de Greenwich (que pasa a través del Real Observatorio de Greenwich en las afueras de
Londres), y la longitud de un punto es la medida angular formada por el semiplano del eje de la tierra
que pasa por el meridiano de Greenwich, y el semiplano del eje de la tierra que pasa por el punto.
Como hay 180 meridianos en cada hemisferio, la mayor longitud que se puede medir en cada uno es
de 180°, tanto en dirección este como en dirección oeste.
Un tercer componente
Los lectores meticulosos habrán notado que hace falta un tercer elemento para localizar un punto,
este es la altitud. En la mayoría de los casos las coordenadas GPS son necesarias para ubicar lugares
en la superficie terrestre, lo que le resta importancia a dicho parámetro. Sin embargo, es igual de
necesario que la latitud y longitud para poder definir una ubicación GPS de manera completa y
precisa.
4.10.8.
Múltiples sistemas de coordenadas para coordenadas geográficas
Como hemos visto, las definiciones anteriores toman en cuenta varios parámetros que deben ser
establecidos o identificados para futuras referencias:
33
El plano ecuatorial y el modelo de la forma de la tierra elegida.
Un conjunto de puntos de referencia.
La posición del centro de la tierra.
El eje de la tierra.
El meridiano de referencia.
Estos cinco criterios son las bases de los distintos sistemas de coordenadas usados a través de la
historia.
Actualmente el sistema geodésico más usado es el WGS 84 (usado mayormente para las coordenadas
GPS).
4.10.9.
Unidades de medida para las coordenadas GPS
Las dos principales unidades de medidas son las coordenadas decimales y sexagesimales.
Coordenadas decimales
La latitud y longitud son números decimales con las siguientes características:
- Latitud entre 0° y 90 °: Hemisferio Norte.
- Latitud entre 0° y -90°: Hemisferio Sur.
- Longitud entre 0° y 180°: Al este del meridiano de Greenwich.
- Longitud entre 0° y -180°: Al oeste del meridiano de Greenwich.
Coordenadas sexagesimales
Las coordenadas sexagesimales tienen tres componentes: grados, minutos y segundos. Cada uno de
estos componentes suele ser un número entero, pero se puede usar un número decimal en los
segundos si se desea una mayor precisión.
Un grado tiene 60 minutos y un minuto consiste de 60 segundos de ángulo del arco.
A diferencia de las coordenadas decimales, las sexagesimales no pueden ser negativas. En dicho caso,
las letras E u O son añadidas a la longitud para especificar la posición este-oeste desde el meridiano
de Greenwich, y a la latitud se le agregan las letras N o S para designar el hemisferio (Norte o Sur).
[21]
Coordenadas Decimales
Coordenadas Sexagesimales
Latitud
Longitud
Latitud
Longitud
0° a 90°
0° a 180°
N
E
0° a 90°
0° a -180°
N
O
0° a -90°
0° a 180°
S
E
0° a -90°
0° a -180°
S
O
Tabla 6: Correlación entre coordenadas Decímales y Sexagesimales. [21]
34
4.11. TRANSMISIÓN DE DATOS EN LA RED CELULAR
Para reflejar la evolución de las tecnologías utilizadas en la telefonía móvil se utiliza el concepto de
“generación”, de forma que cada generación engloba un conjunto de estándares de transmisión de
datos (y de voz) que ofrecen unas determinadas prestaciones y calidad de servicio.
1G – Fue la primera generación de telefonía móvil y utilizaba tecnología analógica para la transmisión
de información. Se utilizó en los años 80.
2G – Es la segunda generación de telefonía móvil que utiliza fundamentalmente GSM (Global System
for Mobile Communications, sistema global para las comunicaciones móviles) como estándar de
transmisión de telefonía digital. Permite la transmisión tanto de voz como de datos (por ejemplo,
mensajes cortos de texto o SMS). Utiliza varias bandas de frecuencia dependiendo de la región o país.
4.11.1.
Telefonía Móvil 3G
El primer estándar 3G: EDGE
EDGE (Enhanced Data rates for GSM of Evolution o Tasas de Datos Mejoradas para la evolución de
GSM) también conocida como EGPRS (Enhanced GPRS) es el siguiente estándar que aparece en la
telefonía móvil para la transmisión de datos. Esta tecnología funciona con redes GSM que tengan
implementado GPRS y las actualizaciones necesarias propias de EDGE, por lo que es relativamente
sencilla su implementación por parte de los operadores.
Debido a su compatibilidad con GSM hay autores que la consideran una tecnología puente entre 2G y
3G, es decir, 2.5G. Sin embargo, EDGE puede alcanzar una velocidad de transmisión teórica de 384
Kbps, con lo cual cumple los requisitos de la ITU para una red 3G, también ha sido aceptado por la ITU
como parte de IMT-2000, de la familia de estándares 3G.
EDGE utiliza modulación GMSK (Gaussian Minimum-Shift Keying) y modulación 8-PSK (8 Phase Shift
Keying) para algunos de los esquemas de modulación y codificación de datos aumentando así su
eficacia.
Banda ancha en la telefonía móvil: UMTS
UMTS (Universal Mobile Telecommunications System o Servicio Universal de Telecomunicaciones
Móviles) es el nombre con el que se engloban todas las tecnologías incluidas en 3G desligadas de las
redes GSM. Precisamente el hecho de que los operadores hayan necesitado una gran inversión para
implantar las redes UMTS ha ocasionado un gran retraso en su implementación. Este retraso ha sido
cubierto en muchos casos con las tecnologías intermedias 2.5G. La tecnología de transmisión utilizada
en UMTS es WCDMA.
WCDMA es una tecnología móvil inalámbrica de tercera generación que aumenta las tasas de
transmisión
de
datos
de
los
sistemas
GSM.
Utiliza
como
técnica
de
35
multiplexación CDMA (multiplexación por división de código). Soporta de manera satisfactoria una
tasa transferencia de datos que va de 144 hasta 512 Kbps para áreas de cobertura amplias aunque en
el estándar se especifican velocidades de hasta 2 Mbps. El estándar de WCDMA fue desarrollado
como el proyecto de la sociedad 3GPP, que es el acrónimo de 3rd Generation Partnership Project.
Esta organización realiza la supervisión del proceso de elaboración de estándares relacionados con
3G.
El despliegue de redes UMTS facilita la aparición del servicio conocido como Internet móvil ya que las
velocidades que se pueden alcanzar con esta tecnología permiten hacer uso de una gran parte de los
servicios ofrecidos en Internet, típicamente la navegación web. De esta forma aparecen en el
mercado tanto teléfonos móviles que soportan la tecnología 3G como módems 3G utilizados para
proporcionar conectividad a ordenadores. Normalmente la conexión de estos dispositivos al
ordenador es mediante un puerto USB. [22]
4.11.2.
Comparación de la velocidad de los estándares de la telefonía móvil
Tabla con la comparación de la velocidad de transmisión de subida y bajada, que permiten los
distintos estándares funcionando actualmente en la telefonía celular.
Tecnología
Velocidad promedio de bajada
Velocidad promedio de subida
GSM (2G)
1.8 kB/s
1.8 kB/s
GPRS (2.5G)
7.2 kB/s
3.6 kB/s
CDMA2000 1×RTT
18 kB/s
18 kB/s
EDGE (2.75G)
29.6 kB/s
29.6 kB/s
UMTS 3G
48 kB/s
48 kB/s
EDGE (type 2 MS)
59.2 kB/s
59.2 kB/s
EDGE Evolution (type 1 MS)
148 kB/s
59 kB/s
EDGE Evolution (type 2 MS)
237 kB/s
118 kB/s
HSPA (3.5G)
1,706 kB/s
720 kB/s
HSPA+
5.25 MB/s
1.437 MB/s
LTE (2×2 MIMO)
21.625 MB/s
7.25 MB/s
LTE (4×4 MIMO)
40.750 MB/s
10.750 MB/s
Tabla 7: Comparación de la velocidad de los estándares de la telefonía móvil. [23]
36
4.12. RASPBERRY PI
Raspberry Pi es una placa computadora (SBC) de bajo costo desarrollada en Reino Unido por la
Fundación Raspberry Pi. En realidad, se trata de una diminuta placa base de 85 x 54 milímetros (del
tamaño aproximado de una tarjeta de crédito) en el que se aloja un chip Broadcom BCM2835 con
procesador ARM hasta a 1 GHz de velocidad (modo Turbo haciendo overclock), GPU VideoCore IV y
512 Mbytes de memoria RAM (Las primeras placas contaban con sólo 256MB de RAM).
Figura 8: Placa Raspberry pi. [24]
4.12.1.
Hardware Raspberry Pi
Con unas dimensiones de placa de 8.5 por 5.3 cm, en su corazón tiene un chip integrado Broadcom
BCM2835, que contiene un procesador ARM11 con varias frecuencias de funcionamiento y la
posibilidad de subirla (haciendo overclocking) hasta 1 GHz sin perder la garantía, un procesador
gráfico VideoCore IV, y 512MB de memoria RAM. La última Raspberry Pi 2 cuenta con 1GB de
memoria RAM. Todo ello equivale en la práctica a un ordenador con unas capacidades gráficas
similares a la XBOX de Microsoft y con la posibilidad de reproducir vídeo en 1080p.
En la placa nos encontramos además con una salida de vídeo y audio a través de un conector HDMI,
con lo que conseguiremos conectar la tarjeta tanto a televisores como a monitores que cuenten con
dicha conexión. En cuanto a vídeo se refiere, también cuenta con una salida de vídeo compuesto y
una salida de audio a través de un minijack. Posee una conexión Ethernet 10/100.
En su parte inferior cuenta con un lector de tarjetas SD (micro SD para los modelos A+, B+ y Pi 2), lo
que abarata enormemente su precio y da la posibilidad de instalar un sistema operativo en una
tarjeta de memoria de 4 GB o más (clase 4 o clase 10). De esta forma tenemos también la posibilidad
de minimizar el espacio que necesitamos para tener todo un ordenador en un volumen mínimo. [24]
37
Figura 9: Raspberry pi Modelo B. [25]
Conexiones GPIO
Raspberry Pi A +, B + y 2 B incluyen 40 pines GPIO. Los modelos A y B tienen sólo los primeros 26
pines.
GPIO #
Función
Pin #
Pin #
Función
GPIO #
N/A
+ 3V3
1
2
+ 5V
N/A
GPIO2
SDA1 (I2C)
3
4
+ 5V
N/A
GPIO3
SCL1 (I2C)
5
6
GND
N/A
GPIO4
GCLK
7
8
TXD0 (UART)
GPIO14
N/A
GND
9
10
RXD0 (UART)
GPIO15
GPIO17
Gen0
11
12
GEN1
GPIO18
GPIO27
GEN2
13
14
GND
N/A
GPIO22
GEN3
15
16
GEN4
GPIO23
N/A
+ 3V3
17
18
GEN5
GPIO24
GPIO10
MOSI (SPI)
19
20
GND
N/A
GPIO9
MISO (SPI)
21
22
GEN6
GPIO25
GPIO11
SCLK (SPI)
23
24
CE0_N (SPI)
GPIO8
N/A
GND
25
26
CE1_N (SPI)
GPIO7
(Modelos A y B paran aquí)
EEPROM
ID_SD
27
28
ID_SC
EEPROM
GPIO5
N/A
29
30
GND
N/A
GPIO6
N/A
31
32
-
GPIO12
GPIO13
N/A
33
34
GND
N/A
GPIO19
N/A
35
36
N/A
GPIO16
GPIO26
N/A
37
38
Digital IN
GPIO20
N/A
GND
39
40
OUT digital
GPIO21
Tabla 8: Conexiones GPIO. [26]
38
Modelo B revisión 2 también tiene un pad (llamado P5 en el tablero y P6 en los esquemas) de 8 pines
que ofrecen acceso a un adicional de 4 conexiones GPIO.
GPIO #
Función
Pin #
Pin #
Función
GPIO #
N/A
+ 5V
1
2
+ 3V3
N/A
GPIO28
GPIO_GEN7
3
4
GPIO_GEN8
GPIO29
GPIO30
GPIO_GEN9
5
6
GPIO_GEN10
GPIO31
N/A
GND
7
8
GND
N/A
Tabla 9: Extensión de conexiones GPIO para modelo B versión 2. [26]
Modelos A y B proporcionan acceso GPIO para el LED de estado ACT usando GPIO 16. Modelos A+ y
B+ proporcionan acceso GPIO para el LED de estado ACT usando GPIO 47, y el LED de estado de
alimentación usando GPIO 35. [26]
4.12.2.
Accesorios para Raspberry Pi
Cuando adquirimos la Raspberry Pi recibimos exactamente eso, una placa sin más. Para ponerla en
funcionamiento necesitamos de una serie de accesorios tales como una fuente de alimentación de al
menos 1000mah, un cable HDMI, una tarjeta de memoria SD/microSD con el Sistema Operativo y un
adaptador WiFi o un cable RJ45 para poder conectarnos a internet. Además por estética o por
protección podemos adquirir una de las muchas cajas que existen a la venta. [24]
Otros periféricos y carcasas son comercializados por empresas ajenas a la fundación. Por ejemplo
la Gertboard, que ha sido creada con propósito educativo, sirve para hacer uso del puerto GPIO y
poder interaccionar con LEDs, interruptores, señales analógicas, sensores, y otros dispositivos.
También incluye un controlador opcional para Arduino para poder interaccionar con el Raspberry Pi.
[27]
Cámara
Es una cámara capaz de capturar vídeo con una resolución de 1080p. La cámara cuenta con un sensor
Omnivisión de 5 megapíxeles que además de vídeo en alta definición y a 30 fotogramas por segundo,
es capaz de hacer fotos con una resolución de 2.592 X 1.944 píxeles.
La conexión de este pequeño módulo se vende con el tradicional acabado de Raspberry Pi (o lo que
es lo mismo, sin ningún acabado, en un circuito puro y duro) como podemos observar en la imagen.
Figura 10: Modulo cámara para Raspberry pi. [28]
39
Carcasa
Otro de los accesorios imprescindible si se quiere resguardar la Raspberry Pi es la carcasa. Las hay de
todos los colores, formatos, materiales, diseños e incluso carcasas caseras fabricadas por los mismos
usuarios. [28]
Modulo GPS Ublox NEO 6M
El módulo NEO 6M de la empresa suiza UBlox es una excelente alternativa de precisión y costo
beneficio. Es de un tamaño reducido por lo que es fácilmente portable en tus proyectos. Se
comunica a través de puerto serial UART. Esta presentación viene en modo modular para que se
pueda usar en cualquier plataforma como Arduino, Raspberry Pi, pcDuino o con un Laptop. Mide
parámetros como latitud, longitud, velocidad, altitud.
Figura 11: Modulo GPS Ublox NEO 6M. [29]
Características:
- Ultra sensibilidad: -165dBm
- 22 tracking/66 acquisition-channel receiver
- Soporta estándares WAAS/EGNOS/MSAS/GAGAN
- Frecuencia de actualización 5Hz
- Velocidad de desplazamiento máxima: 500m/seg
- Protocolo NMEA (a 9600bps)
- 01 puerto serial
- Antena incorporada de 18.2 x 18.2 x 4.0 mm
- Rango de temperatura: -40 to 85 C
- Cumple estándar RoHS
- Tamaño reducido, 30mm x 20mm x 11.4mm [30]
Especificaciones:
Tipo de receptor
Sensibilidad
Precisión
Tiempo de lectura
L1 frequency band, C/A code
22 Tracking / 66 Canales de lectura
Tracking
-165dBm
Acquisition
-148dBm
Posición
3mts. 3D RMS sin SA
Velocidad
0.1m/s sin SA
Timing (PPS)
60ns RMS
Cold Start
36s
40
Warm Start
Hot Start
Re-Acquisition
Tracking
Acquisition
Sleep/Standby
Consumo de energía
Frecuencia de actualización de datos de
1Hz
navegación
Altitude
Límites de operación
Velocity
Aceleración
OutlineDimension
Center Frequency
Bandwidth
Antenna Specifications
Impedance
Axial Ratio
Polarization
Dimensiones
Dimensiones y peso
Peso
VCC
Fuente de poder
Corriente
Temperatura de operación
Temperatura de
Entorno
almacenamiento
Humedad
33s
1s
<1s
<30mA @ 3V Vcc
40mA
TBD
Max 18,000m
Max 515m/s
Menor a 4g
18.2 x 18.2 x 4.0 mm
1575 ± 3 MHz
10 MHz min
50 Ω
3 dB max
RHCP
30mm x20mm x 11.4mm
9g
5V ±5%
55mA(typical)
40 ~ +85 (sin batería de
respaldo)
0 ~ +125
Tabla 10: Es pesificaciones técnicas del módulo GPS. [30]
4.12.3.
Software para Raspberry Pi
El Raspberry Pi usa mayoritariamente sistemas operativos basados en el núcleo Linux. Raspbian, una
distribución derivada de Debian que está optimizada para el hardware de Raspberry Pi, se lanzó
durante julio de 2012 y es la distribución recomendada por la fundación para iniciarse.
El chip ARM11 en el corazón del Pi (modelos de primera generación) se basa en la versión 6 de
la ARM . Las versiones actuales de varias versiones populares de Linux, incluyendo Ubuntu , no se
ejecutarán en el ARM11. No es posible ejecutar Windows en el Raspberry Pi original, aunque en el
nuevo Raspberry Pi 2 es capaz de ejecutar Windows 10 . El Raspberry Pi 2 actualmente sólo es
compatible con Ubuntu Snappy Core , Raspbian , OpenELEC y RISC OS. [27]
Software Incluido en Raspbian
La distribución viene con algunas aplicaciones preinstaladas como los navegadores Midori, Dillo y
NetSurf. Además contiene herramientas de desarrollo como IDLE para el lenguaje de programación
Python o Scratch, y diferentes ejemplos de juegos usando los módulos Pygame. Destaca también el
menú “raspi-config” que permite configurar el sistema operativo sin tener que modificar archivos de
configuración manualmente y el wifi-config, el cual permite configurar redes inalámbricas si usamos
un receptor WiFi USB. [31]
41
4.13. PYTHON Y RASPBERRY
La fundación Raspberry Pi recomienda el uso de Python como lenguaje de programación, sin
embargo, no limitan el uso de lenguaje C, C++, Java, Scratch y Ruby ya que vienen instalados por
defecto en Raspbian. Es posible utilizar cualquier software de programación siempre y cuando pueda
ser ejecutado en un procesador ARMv6.
El entorno de desarrollo integrado (IDE) para programar en Python viene incluido en Raspbian, se
llama IDLE. [32]
4.13.1.
Python
Python es un lenguaje de programación creado por Guido van Rossum a principios de los años 90
cuyo nombre está inspirado en el grupo de cómicos ingleses “Monty Python”. Es un lenguaje similar a
Perl, pero con una sintaxis muy limpia y que favorece un código legible.
Se trata de un lenguaje interpretado o de script, con tipado dinámico, fuertemente tipado,
multiplataforma y orientado a objetos.
Lenguaje interpretado o de script
Un lenguaje interpretado o de script es aquel que se ejecuta utilizando un programa intermedio
llamado intérprete, en lugar de compilar el código a lenguaje máquina que pueda comprender y
ejecutar directamente una computadora (lenguajes compilados).
La ventaja de los lenguajes compilados es que su ejecución es más rápida. Sin embargo los lenguajes
interpretados son más flexibles y más portables.
Python tiene, no obstante, muchas de las características de los lenguajes compilados, por lo que se
podría decir que es semi interpretado. En Python, como en Java y muchos otros lenguajes, el código
fuente se traduce a un pseudo código máquina intermedio llamado bytecode la primera vez que se
ejecuta, generando archivos .pyc o .pyo (bytecode optimizado), que son los que se ejecutarán en
sucesivas ocasiones.
Tipado dinámico
La característica de tipado dinámico se refiere a que no es necesario declarar el tipo de dato que va a
contener una determinada variable, sino que su tipo se determinará en tiempo de ejecución según el
tipo del valor al que se asigne, y el tipo de esta variable puede cambiar si se le asigna un valor de otro
tipo.
Fuertemente tipado
42
No se permite tratar a una variable como si fuera de un tipo distinto al que tiene, es necesario
convertir de forma explícita dicha variable al nuevo tipo previamente. Por ejemplo, si tenemos una
variable que contiene un texto (variable de tipo cadena o string) no podremos tratarla como un
número (sumar la cadena “9” y el número 8). En otros lenguajes el tipo de la variable cambiaría para
adaptarse al comportamiento esperado, aunque esto es más propenso a errores.
Multiplataforma
El intérprete de Python está disponible en multitud de plataformas (UNIX, Solaris, Linux, DOS,
Windows, OS/2, Mac OS, etc.) por lo que si no utilizamos librerías específicas de cada plataforma
nuestro programa podrá correr en todos estos sistemas sin grandes cambios.
Orientado a objetos
La orientación a objetos es un paradigma de programación en el que los conceptos del mundo real
relevantes para nuestro problema se trasladan a clases y objetos en nuestro programa. La ejecución
del programa consiste en una serie de interacciones entre los objetos.
Python también permite la programación imperativa, programación funcional y programación
orientada a aspectos. [33]
43
5. DESARROLLO DEL PROYECTO
La idea de este proyecto es crear un localizador GPS portátil con Raspberry Pi que almacene en un
archivo local su posición exacta cada cierto tiempo o evento especial, acoplar una cámara fotográfica
para capturar imágenes en el mismo instante que la posición. Inmediatamente almacenados estos
archivos, se transmitirán a un servidor remoto a través de internet, haciendo uso de la red móvil 3G y
almacenando estos datos definitivos en el servidor de base de datos. Posteriormente se podrá
visualizar la foto, accediendo de forma remota a una página web, al igual que la posición, la cual
representaremos en un mapa interactivo de Google Maps aprovechando su API.
Al realizar el prototipo como objeto principal del proyecto, hubo varios factores decisivos, antes, al
inicio y en el proceso del desarrollo, los cuales se tuvieron en cuenta para lograr los mejores
resultados, sin afectar el presupuesto, el rendimiento y utilizando medios tecnológicos
implementados en los sistemas modernos. Dando cumplimiento a lo anterior, se escogieron
componentes de hardware y software, con facilidad de adquisición, versátil, compatibilidad para
acoplamiento y buenas fuentes de documentación y de conocimiento.
El diseño del prototipo se distribuye en varias fases correlacionadas entre sí. Iniciando con el diseño y
acople del dispositivo físico y los módulos necesarios con funciones específicas. Posteriormente, se
debe configurar y programar el dispositivo en su totalidad para controlar su funcionamiento, según lo
requerido y con un rendimiento óptimo. Luego, se realiza el diseño de la base de datos y el montaje
del servidor, donde se alojará la base de datos y se almacenarán los datos finales. Finalmente, se crea
una plataforma web, la cual podrá ser consultada por el usuario final, para realizar consulta de la base
de datos existente, con los archivos y datos correspondientes.
5.1.
DISEÑO DE HARDWARE
Como base del hardware, se utilizó la plataforma educativa “Raspberry Pi 2 Modelo B”, la cual
presenta varias ventajas relacionándolo con sus antecesores y con otros dispositivos de fines
similares. Al tratarse de un ordenador de placa reducida, podemos encontrar gran diversidad de
funcionalidades, sin que el dispositivo sufra saturación o bajo rendimiento.
Entre otras, las principales ventajas que se puede encontrar son, el costo y facilidad de adquisición,
compatibilidad con diferentes sistemas operativos, facilidad en la configuración y programación al
44
encontrar gran cantidad de documentos explicativos que tratan sobre el dispositivos y sus diferentes
módulos, versatilidad para trabajar en diferentes ámbitos y contextos.
5.1.1.
Inicio de Raspberry Pi
Materiales Necesarios
Como mínimo, para iniciar a funcionar el Raspberry Pi, se necesita:
Memoria micro SD de al menos 4 GB.
Adaptador micro SD a SD.
Computador con lector de tarjetas SD.
Adaptador de alimentación micro USB.
Teclado.
Mouse.
Cable HDMI o bien adaptador activo de HDMI a VGA.
Televisor o monitor.
Software Necesario
Paso 1. Preparar la tarjeta SD para copiar el Sistema Operativo
En el siguiente link se puede descargar la aplicación que permite formatear la tarjeta. El software se
llama SD Formatter, de los mismos creadores del estándar para almacenar información en las tarjetas
SD, por lo tanto es seguro de utilizar.
https://www.sdcard.org/downloads/formatter_4/SDFormatter4exe.zip
Una vez el archivo ha sido descargado, descomprimir el archivo y hacer clic en el archivo con el
nombre setup.exe. Este programa inicializará el proceso de instalación, instalar con las opciones
predeterminas.
Figura 12: Interfaz del programa SD Formatter. [34]
45
Insertar la tarjeta SD en el lector del PC o portátil. Una vez ha sido reconocida por el sistema, ejecutar
el programa instalado. Utilizar las opciones predeterminadas, sin embargo, hay que fijarse bien en
utilizar la opción “QUICK FORMAT” para que borre toda la información de la tarjeta en el menor
tiempo posible. A partir de este momento, toda la información contenida en la tarjeta será borrada
permanentemente. Este proceso tomara unos minutos dependiendo de la capacidad de la tarjeta.
Con la tarjeta SD formateada, ahora es posible instalar el sistema operativo con NOOBS. Esto se hace
mediante una copia directa de los archivos en la tarjeta SD. Para hacer la copia se debe seguir los
siguientes pasos. [34]
Paso 2. Descarga de Noobs y copia en la tarjeta SD
Descargar el Sistema Operativo directamente del sitio oficial de Raspberry Pi
(http://www.raspberrypi.org/downloads), en este link se encuentra que hay diferentes versiones
disponibles. Lo recomendable es inicialmente utilizar NOOBS, el cual contiene las siguientes versiones
de sistemas operativos:
Archlinux
OpenELEC
Pidora
RISC OS
RaspBMC
Raspbian
Seleccionar el archivo con el nombre NOOBS. Después de unos segundos el archivo empezará a
descargarse, esto tomará bastante tiempo ya que el archivo es de 737 MB.
Una vez el archivo ha descargado por completo, descomprimir el archivo en un lugar conocido. Al
final debería obtener una carpeta. Esta carpeta es la que contiene todo el sistema operativo. Luego
abrir la carpeta donde se descargó el sistema operativo y proceder a copiar o mover todo el
contenido.
Con estos pasos, el sistema operativo ha sido copiado en la tarjeta SD y ahora se puede proceder a
instalar el sistema operativo. [35]
Paso 3. Instalación y configuración inicial del Raspberry Pi (raspi-config)
Una vez la tarjeta ha sido preparada y NOOBS ha sido copiado, el sistema operativo se reinicia y el
primer programa que se ejecuta es Pi Recovery, este programa sirve para instalar la versión del
sistema operativo deseada.
En la pantalla inicial, seleccionar Raspbian para instalar el sistema operativo. Este proceso tomará
entre 15 a 20 minutos.
46
Figura 13: Pantalla inicial de Pi Recovery. [36]
Después que Raspbian “Wheezy” ha sido instalado, hay que configurar el Sistema operativo
para que funcione en español. Los siguientes pasos muestran las diferentes opciones
disponibles.
Al reiniciar el dispositivo el primer programa que se ejecuta se llama raspi-config, este
programa solo se ejecuta en inglés. En caso de que ya haya instalado el sistema operativo y
se desee realizar alguna de estas modificaciones, se puede hacer ejecutando el siguiente
comando desde la terminal:
sudo raspi-config
El primer menú que muestra contiene 9 diferentes opciones disponibles, a continuación se
revisará cada una de las opciones disponibles:
Figura 14: Menú principal de configuración de Raspbian. [36]
1.
2.
3.
4.
Expandir el sistema de archivos (Expand Filesystem).
Cambiar la contraseña del usuario Pi (Change User Password).
Activar el escritorio al iniciar (Entable Boot to Desktop).
Opciones de internacionalización (Internationalisation Options).
47
Esta opción permite modificar el lenguaje del sistema operativo, la zona horaria y la distribución de su
teclado.
Figura 15: Menú de opciones de internacionalización de Raspbian. [36]
La opción I1 sirve para indicar donde se encuentra ubicado, esta opción configura el lenguaje del
sistema operativo, los caracteres, la denominación de la moneda, etc. Buscar y seleccionar el modo
de codificación:
es_CO. UTF-8 UTF-8
Para confirmar oprimir espacio y luego enter.
La opción I2, sirve para cambiar la zona horaria del sistema, la cual se ajusta de acuerdo a la ciudad
donde vive o la más cercana. El sistema ha sido configurado como Colombia, Bogotá.
La opción I3, permitirá cambiar la configuración del teclado, si la marca y tipo del teclado no aparece,
seleccionar el predeterminado “PC genérico 105 teclas (intl)”.
Luego seleccionar el idioma del teclado, si en la primera pantalla no aparece Español seleccionar otro.
En la siguiente ventana hay una lista de opciones, seleccionar “Español” o “Español
(Latinoamericano)”.
Luego seleccionar la distribución del teclado, se recomienda utilizar la primera opción, solo “Español
Latinoamericano”.
5. Activar la cámara (Enable camera)
Esta opción sirve para dar soporte a la cámara de Raspberry Pi, permite activar el puerto para que
haya comunicación entre la CPU y el controlador de la cámara. Seleccionar la opción “Enable”, ya que
posteriormente se hará uso del módulo de la cámara.
6. Adicionar a Rastrack (Add to Rastrack)
7. Overclockig
8. Opciones avanzadas (Advanced Options) [36]
Paso 4. Conexión del Raspberry Pi a Internet usando cable de red
48
Es recomendable que el Raspberry Pi tenga conexión disponible a Internet para poder actualizar
programas. Existen 3 diferentes métodos para conectar la Raspberry Pi, entre ellos están:
Conexión directa a través del Router
Conexión con dongle WiFi
Conexión directa al PC
Para realizar la conexión con cable de red se necesitan los siguientes materiales.
Router con puerto RJ-45 disponible (Puede ser o no WiFi)
Conexión a internet
Cable RJ-45
La manera más sencilla de conectar el Raspberry Pi a internet o a la red casera es a través del puerto
RJ-45 del router inalámbrico. Para esto solamente hay que conectar el cable de red RJ-45
directamente desde el Raspberry Pi al router.
Para la mayoría de los routers que se encuentran en nuestra casa, el Raspberry Pi debería conectarse
directamente sin ninguna otra conexión extra. En caso que no se pueda conectar, verifiicar que el
router está configurado para DHCP (Dynamic Host Configuration Protocol), el cual le asigna
aleatoriamente la dirección IP al dispositivo.
Para verificar si la conexión es exitosa, es necesario cerciorarse que el Router le ha asignado
una dirección IP al Raspberry Pi. Esto se puede hacer desde la línea de comando utilizando el
siguiente comando:
ifconfig –a
Si el Router asignó una dirección IP al Raspberry Pi, ahora puede verificar si está conectado a
internet. [37]
Paso 5. Conexión remota al Raspberry Pi usando Xming
En el mundo Linux existen muy buenas alternativas para ejecutar escritorios remotos. Una opción,
entre varias es XMING. Esta opción permite ejecutar el escritorio remoto del Raspberry Pi usando el
sistema de gestión gráfico llamado X11 o X Windows. Esta es una aplicación tipo cliente-servidor,
donde se necesita instalar aplicaciones en ambos lados tanto en el servidor como en el cliente. Para
este caso el servidor es el Raspberry Pi y el cliente un PC con Windows. El Raspberry Pi usa X Windows
como el gestor de su ambiente gráfico, por ende no se necesita instalar nada adicional. Sin embargo,
para el PC con Windows, es necesario instalar la aplicación Xming para que pueda interpretar los
comandos recibidos por el Raspberry Pi en un ambiente gráfico.
Hay que tener en cuenta que Xming transfiere la información gráfica a través de Putty, por lo tanto
este debe ser instalado con anterioridad, y los pasos a seguir.
49
El programa que se tiene que instalar en el PC se llama XMING, este se puede descargar directamente
de la página del desarrollador en el link http://sourceforge.net/projects/xming/. Descargar el
archivo y luego ejecutar el instalador con todos los parámetros que trae por defecto.
Una vez haya terminado la instalación, ahora es necesario crear un archivo de configuración para
conectarse al Raspberry Pi, para esto buscar la aplicación Xlaunch en el escritorio o en la barra de
inicio, dependiendo de la versión de Windows que se tenga instalada.
Al ejecutar la aplicación, la primera pantalla indica como desea que se ejecute el ambiente X
Windows. Para poder terminar la conexión, necesitará hacer click derecho sobre Xming en la barra de
tareas y luego cerrar.
En la siguiente opción, seleccionar “start a program”. Esto indicará que tan pronto inicie Xming, esta
aplicación se debe ejecutar desde el Raspberry Pi.
Como el interés es ejecutar el escritorio del Raspberry Pi llamado LXDE, se debe hacer el llamado de
esta aplicación. Para esto en el campo start program ingresar startlxde. En el cuadro de la
configuración, seleccionar Using PuTTY (plink.exe). En el campo “connect to computer” ingresar la
dirección IP de la Raspberry Pi. En el campo login user ingresar el nombre del usuario del Raspberry
Pi, en este caso es el común “Pi”, siguiente a esto la contraseña que se haya asignado a este usuario,
el predeterminado es “raspberry”.
Figura 16: XMING con Raspberry Pi iniciar startlxde. [38]
Si se desea copiar texto entre el PC y el Raspberry Pi, dejar activada la casilla Clipboard. Esta función
es muy práctica cuando desean copiar textos entre los ambientes. Sin embargo, copiar imágenes o
archivos en general no es posible con este método.
Una vez se haya terminado, volverá a la venta anterior. Ahora solo es necesario hacer click en
“finish” y se ejecutará la conexión remota al Raspberry Pi. [38]
50
5.1.2.
Adaptación de módulos y Programación de Raspberry Pi
A continuación se hará una descripción de las conexiones de los módulos requeridos con el propósito
ya sabido. Así mismo, se incluirá la configuración y programación indispensable para el satisfactorio
acople de todos y cada uno.
Para los scripts programados en la plataforma de la Raspberry, se usó el lenguaje de programación
Python, instalado de forma predeterminada con el sistema operativo Raspbian. A lo largo del capítulo
se hará mención de varios scripts en Python y una descripción de las funciones de cada uno y su
relación entre sí, los cuales son “principal.py”, “pulsador.py”, “temporales.py”, “picam.py”,
”iniciogps.py”, “envioFTP.py”, “envioEmail.py” y un script en PHP nombrado “mapa.php”. Todos estos
códigos están guardados en la ruta “/home/pi” de la Raspberry Pi y podrán ser observados con
detalle en los anexos.
Scripts iniciales
Habrán tres scripts que se ejecutarán automáticamente al iniciar el arranque con el encendido de la
Raspberry Pi y controlan la ejecución de los demás scripts.
A continuación, se adiciona el código del script “principal.py”, este es el primero en iniciar y estará en
ejecución constantemente para realizar captura de datos de la cámara y el GPS automáticamente
cada 10 minutos contados a partir de la última captura finalizada. Este script hace un llamado de la
función “principal” en el script “picam.py” y define el estado como “Automático”, este mismo se
incluirá en la publicación final de la página web y se tendrá en cuenta en los siguientes scripts.
Seguido a esto, se inicia el script “pulsador.py”, el cual tiene como función testear continuamente la
pulsación del botón de pánico incorporado a los pines GPIO 03 (numeración BCM) y Ground o pines
GPIO 05 y 09 (numeración estándar). Se toma el pin GPIO 03, aprovechando su resistencia de pull-up
interna que viene activada por defecto, así no es necesario agregar resistencias externas.
Este script también está en continua ejecución, esperando un voltaje bajo en el pin 03 configurado
como entrada. Al tener un estado bajo en el GPIO 03, inicialmente se modifica el estado a “S.O.S.” o
de emergencia. Seguidamente, se hace llamado a la función “principal” en picam.py. Este último
proceso, permitirá grabar un video de 10 segundos, configurables, ya que al tratarse de un estado de
51
emergencia, requerirá de mayor precisión en los datos, por esto obtendremos mejor visualización de
la situación con un video y no con una fotografía, como en el caso del estado “Automático”.
Por último, se inicia el script “temporales.py”. El propósito de este script es, intentar realizar una
conexión efectiva con el servidor para enviar los archivos que estén en la carpeta
“/home/pi/TemporalEnvio”, los cuales están almacenados y que no lograron ser enviados al servidor
en el momento de obtenerlos, por alguna falla en la conexión. Este proceso se repite cada 5 minutos,
intentando realizar conexión con el servidor en cada momento.
Para iniciar los scripts al encender la Raspberry se utiliza la herramienta “cron” de los sistemas Unix,
cron es un administrador de procesos en segundo plano. Al agregar líneas de texto en el archivo
“crontab” se incluyen estos procesos al cron, dependiendo de su configuración. En este caso se
agregan las siguientes líneas:
Conexión y configuración de la Cámara
Antes de conectar la cámara, localizar la CSI y luego tirar de la pestaña suavemente hacia
arriba. Ahora empujar el cable plano del módulo de la cámara en la ranura, con los contactos de plata
en el cable de espaldas al puerto Ethernet. Recordar que no se debe empujar el cable muy profundo.
52
Ahora mantenerlo en su lugar con una mano y empujar la lengüeta CSI hacia abajo con la otra mano
para bloquear la cinta de la cámara.
Figura 17: Conexión de la cámara a la interfaz CSI de la Raspberry Pi. [39]
Con el hardware en su lugar, ahora es el momento de instalar el software. Antes de activar la cámara,
asegurar de que se está ejecutando la última versión del firmware Raspberry Pi con estos comandos:
sudo apt-get update
sudo apt-get upgrade
Dependiendo de qué tan antigua es la instalación de Raspbian, y la velocidad de conexión a internet,
estos comandos pueden tomar más de media hora para completar.
Una vez que se ha completado, iniciar el script "ROSSP-config", este ayuda a configurar la Pi:
sudo ROSSP-config
Desplazarse por la lista hasta el elemento que dice "Enable Camera" y pulsar la tecla enter. En la
siguiente pantalla, se pedirá confirmar la elección seleccionando la opción "Enable". A continuación,
volverá a la pantalla principal de la utilidad de configuración. Ahora puede seleccionar la opción
"Finish" y reiniciar el Raspberry Pi.
Una vez que se haya reiniciado el Raspberry Pi, ahora se puede usar las dos utilidades de línea de
comandos, raspistill y raspivid para capturar imágenes fijas y vídeos respectivamente. [40]
Detección de movimiento
Para detectar el movimiento con la cámara se utiliza el script en Python escrito por miembros de la
comunidad de Raspberry Pi.
El script se basa en la biblioteca de imágenes de Python que es una biblioteca para el análisis y la
manipulación de las imágenes, así que hay que realizar la siguiente instalación:
sudo apt-get install python-imagen-tk
Ahora, se debe guardar el script y hacerlo ejecutable:
53
wget –c http://pastebin.com/?raw.php i = Yh77jhZ9W –o picam.py
chmod +x picam.py
Después que el script “principal.py” o “pulsador.py” hagan el llamado de la función “principal.picam
(estado)”, empezará a ejecutarse el código de “picam.py”, con el cual se busca detectar movimiento
antes de tomar una fotografía.
Tendremos que ajustar algunos aspectos de la secuencia de comandos para asegurar que funciona
para nuestras necesidades. Básicamente, se realizaron modificaciones en el script en la parte de la
toma de la fotografía final y el almacenamiento de la misma.
El script está diseñado para almacenar las imágenes en un directorio llamado "PICAM" bajo el
directorio personal, pero para nuestra conveniencia esta ruta se modificó por
/home/pi/TemporalEnvio.
El script encenderá el LED de color rojo de la cámara y empezará a tomar imágenes de baja
resolución. Luego va a compararlas y determinar si hay movimiento mediante la comparación de los
píxeles de las imágenes. Si detecta cambios, el script capturará una imagen de mayor resolución.
El script es muy eficiente y elimina automáticamente las imágenes de baja resolución que captura
para la comparación y sólo almacena las imágenes de alta resolución que han capturado el
movimiento.
Al lograr detectar una variación considerable en los pixeles de las imágenes de test, se modifica el
valor de la variable takePicture (takePicture = True), de esta manera la condición y el código mostrado
en la imagen se ejecutan.
A continuación, se invoca la función interna “saveImage (camerasettings, saveWidth, saveHeight,
saveQuality, diskSpaceToreserve)”. En estas líneas de código es donde se obtiene la fotografía o video
definitivo con la configuración, resolución y calidad, predefinidos al inicio del script, para lograr una
estabilidad entre calidad de la imagen y el tamaño de almacenamiento. El nombre del archivo de la
foto está definido como “image + fecha + hora + .jpg”, por ejemplo “image20150715164615.jpg”,
asegurando que ningún nombre de archivo se pueda repetir, evitando perdida de información. Y
análogamente el nombre de archivo del video está definido de igual forma, únicamente cambiando la
palabra “image” por “video” y el formato por .mp4, por ejemplo “video20150715164615.mp4”. Estos
archivos se enviarán seguidamente al servidor FTP, en caso de no lograr enviarlo o de no poder
conectar con el servidor, serán almacenados en la carpeta “/home/pi/TemporalEnvio”, a la espera de
poder ser enviados.
54
La variable “FTPnamePic” hace referencia al nombre con el cual se guardará la imagen en el servidor
de archivos, lo cual es necesario especificar al realizar el envío de los archivos a través del protocolo
FTP.
Después de guardar la foto o video se ejecuta el script “iniciogps.py” con la ayuda de la función
“os.system ()”, que permite escribir líneas de comando de la Shell del sistema. Con este script se
obtendrán datos como coordenadas GPS, dirección, fecha y hora de la adquisición de los datos, todos
estos alojados en un archivo temporal en la ruta “/home/pi/datos.txt”. En este mismo archivo de
texto se adiciona la ruta de almacenamiento de la imagen en el servidor, el estado, anteriormente
mencionado y el identificador de dispositivo. Más adelante, se hará referencia a dicho archivo con
más detalle.
Conexión y configuración del módulo GPS
El módulo no tiene pines soldados donde conectar los cables, así que, o se sueldan los cables
directamente a la placa, o se adquiere una cabecera de pines y se sueldan.
Para comunicar el módulo Ublox M6 con la Raspberry Pi se usará el puerto serie “/dev/ttyAMA0”.
Para ello se conecta el módulo GPS a la Raspberry tal como indica el esquema, los cables TX y RX
deben estar cruzados, es decir, el pin TX de la Raspberry va conectado al pin RX del módulo GPS y el
55
pin RX de la Raspberry va conectado al pin TX del módulo GPS. Se alimenta el módulo desde los pines
GPIO de 3.3V y GND de la Raspberry.
Figura 18: Esquema y conexión de módulo Ublox M6 a Raspberry pi. [41]
El puerto serie “dev/ttyAMA0”, no está disponible por defecto y hay que desbloquearlo. Para ello se
abre el archivo “/boot/cmdline.txt”, desde la Raspberry y cambiar:
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1
root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
por:
dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4
elevator=deadline rootwait
Seguidamente abrir el archivo “/etc/inittab”, y en la última línea poner un ‘#’.
Modificaría:
T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100
Por:
#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100
Para que estos cambios tengan efecto reiniciar la Raspberry Pi, una vez reiniciada ya se tiene el
puerto serie listo para usarlo. Ahora instalar algunas dependencias que harán falta para interpretar
los datos del módulo GPS con este comando desde la terminal:
sudo apt-get install gpsd gpsd-clients python-gps
GPSD es una aplicación que corre en segundo plano y que recoge los datos GPS del módulo y los
envía a través de un socket que necesita ser activado cada vez que inicia la Raspberry, por eso
introducir en la terminal:
56
sudo gpsd /dev/ttyAMA0 -F /var/run/gpsd.sock
Para que el socket se inicie automáticamente al arrancar la Raspberry, se abre el archivo
“etc/rc.local” y se pone justo antes de “exit 0”, la línea anterior.
Si se ha hecho todo bien al introducir el comando “cgps -s”, debería mostrar algo como esto:
Figura 19: Pantalla de terminal con datos del GPS. [41]
Ahora que las pruebas de conexión del GPS con la Raspberry Pi están finalizadas y satisfactorias se
puede implementar un script para su accionar. [41]
Al tener iniciado el socket GPSD y ya teniendo el receptor GPS activado y conectado con los satélites,
solo basta obtener las coordenadas de posición. En el script, constantemente está obteniendo los
datos latitud y longitud, en busca de valores efectivos, por esto se realiza una condición para que al
obtener datos diferentes a 0 (cero), guarde las coordenadas en variables locales y al igual la dirección
de esa ubicación.
El script “iniciogps.py” importa, entre otras, principalmente las librerías “gps” y “pygeocoder”,
librerías exclusivas para el uso con un receptor GPS. La primera, se encarga de crear un streaming de
datos GPS y constantemente está obteniendo datos de posición, y la segunda tiene como único
propósito traducir las coordenadas geográficas obtenidas, en una dirección legible, conocido como
geo codificación inversa.
57
Al obtener las coordenadas y la dirección, se realiza validación si el estado actual es “S.O.S.” para
hacer un envío inmediato de un correo electrónico con los datos básicos de ubicación, haciendo un
llamado a la función “enviar” en el script “envioEmail.py”. Esto, con el propósito de poder tener una
reacción oportuna a la emergencia. Se podrá ver en detalle el código del script “envioEmail.py” en los
anexos.
Figura 20: Correo electrónico recibido de emergencia.
Posteriormente, se realiza lectura del archivo “mapa.php” guardado con anterioridad en la ruta
“/home/pi/mapa.php”, se busca la palabra clave “coordenadas” dentro de todo el texto en el archivo
y se modifica por “latitud, longitud”, siendo latitud y longitud las coordenadas obtenidas por el GPS.
Se guarda el archivo modificado en la ruta “/home/pi/TemporalEnvio” con un nombre diferente de la
misma forma en que se nombró la imagen, quedando como “map + fecha + hora + .html”.
Adicionalmente, se crea un archivo temporal “datos.txt” para agregar los datos obtenidos (latitud,
longitud, dirección, fecha, hora, URL del mapa, …). Al finalizar el script de “iniciogps.py” y retomar el
final del script “picam.py” se adicionan más datos al archivo “datos.txt” (…, URL de la imagen, estado,
idUser). Al completar la escritura de este archivo se guarda en la ruta “/home/pi/TemporalEnvio” con
el mismo formato para el nombre utilizado para la imagen y el mapa, quedando como “date + fecha +
hora + .txt”. En la siguiente imagen se observa la forma en que se guarda el texto.
Figura 21: Datos almacenados para la importación en la base de datos.
Obsérvese que cada dato está encerrado entre los caracteres “|”. La finalidad de este carácter
especial está en la importación de estos datos a la base de datos, previo envío del archivo al servidor,
y ya encontrándose guardado en una carpeta exclusiva dentro del servidor.
58
Los archivos definitivos se almacenan en conjunto en la ruta “/home/pi/TemporalEnvio”, como ya se
ha mencionado. Al final de los scripts “iniciogps.py” y “picam.py” se intenta realizar el envío
inmediato de los archivos respectivos al servidor a través del protocolo FTP. Es en este momento,
cuando se realiza el llamado de la función “enviar” dentro del script “envioFTP.py”
Transmisión de archivos al servidor remoto
Como ya se ha venido mencionando, el envío de los archivos se hace a un servidor de archivos a
través del protocolo FTP, mientras se tenga una conexión estable a internet. La librería “ftplib”
importada en el script “envioFTP.py” permite de forma sencilla realizar el envío de los archivos. Para
concretar la transacción, inicialmente se debe establecer una conexión con el servidor, por esto se
debe indicar el nombre del servidor o su IP publica, usuario, clave y carpeta donde se guardará el
archivo. Si la conexión es satisfactoria, se realiza el envío indicando la ruta de archivo origen y ruta de
archivo destino. Finalizada la transacción el archivo enviado se elimina del almacenamiento local.
Si por cualquier motivo no se logra concretar la conexión con el servidor y/o no se puede enviar el
archivo, el script “envioFTP.py” finalizará su ejecución sin insistir en la conexión y el archivo seguirá
guardado temporalmente en el dispositivo local, hasta que se ejecute el script “temporales.py” y
seguida la función “listaArchivos” del script “envioFTP.py” y se realice nuevamente un intento
satisfactorio de conexión con el servidor, enviando efectivamente los archivos pendientes.
La intención de la función “listaArchivos” es realizar un listado de todos los archivos guardados en la
carpeta “/home/pi/TemporalEnvio”, los cuales se encuentran en espera de envío al servidor. Este
programa es ejecutado por el script “temporales.py” y se ejecuta automáticamente desde el arranque
de la Raspberry Pi, realizando el mismo proceso cada 5 minutos. Para dar cumplimiento, se agrega
una línea de código en el “crontab”, ya mostrado anteriormente.
5.1.3.
Internet móvil con el modem 3G USB Huawei E173 en la Raspberry
La instalación de un modem 3G / 4G USB en un Raspberry Pi no es una tarea sencilla. El principal
problema es que la mayoría de los módems USB actúan como dos dispositivos, un dispositivo de
almacenamiento USB y un módem USB. Cuando se conecta a la Raspberry PI el dispositivo es por lo
general iniciado en modo de almacenamiento USB. Hay un programa llamado usb_modeswitch que
podemos utilizar para hacer la conmutación.
Inicialmente, se debe instalar el programa con el siguiente comando.
sudo apt-get install usb-modeswitch
Se tiene que conseguir los códigos del dispositivo USB en el modo de almacenamiento USB y
el modo de módem USB.
Conectar el módem USB y reiniciar el Raspberry PI sin LAN o conexión WiFi.
sudo reboot
59
Una vez reiniciado, abrir una ventana de terminal y escribir “lsusb”.
La salida será similar a la siguiente imagen. El módem debe ser catalogado como uno de los
dispositivos USB. Hay que tener en cuenta los números subrayados, estos son los códigos de
proveedores de productos y dispositivos.
En este caso aparece 12d1: 1c24. Este código hace referencia a la conexión en modo de
almacenamiento. Se puede comprobar escribiendo “tail –f /var/log/messages”, y se observa
que el modem se inició como “cdrom”.
Si ahora se desconecta el modem y se vuelve a conectar, se verá modificación en el modo de
conexión del modem, ya es reconocido en modo modem USB.
60
Es decir, se ha cambiado correctamente. Aparece en ttyUSB0, ttyUSB1, ttyUSB2 y ttyUSB3 conexiones
de modem GSM, y luego la tarjeta SD. Y podemos ver la actuación de usb_modeswitch, cambiando el
código a 12d1:1c23. Escribir “lsusb” para corroborar:
Ahora lo que se debe lograr es que este cambio se realice siempre, desde el inicio de la Raspberry o
en cualquier momento que se conecte el modem. Para lograrlo, hay que añadir lo siguiente en el
archivo “/etc/rc.local”, antes de la línea “exit 0”:
sudo service udev stop
sleep 2
sudo service udev start
El “/etc/rc.local” se ejecuta en cada arranque, y al añadir esas líneas se está diciendo que pare el
servicio udev, espere 2 segundos y lo vuelva a arrancar.
Instalando pppd, UMTSKeeper y Sakis3G
El programa más utilizado para realizar la conexión 3G es Sakis3g. Sin embargo, antes de instalarlo, se
tiene que saber que es muy frecuente perder la conexión 3G cada cierto tiempo, por lo que se suele
recurrir a otro programa, UMTSKeeper, que está constantemente comprobando la conexión y
recuperándola cuando se cae. Este último programa también realiza la instalación de Sakis3G.
Lo primero es instalar el servicio pppd:
sudo apt-get install ppp
A continuación, instalar UMTSKeeper:
cd ~
mkdir umtskeeper
cd umtskeeper
wget http://mintakaconciencia.net/squares/umtskeeper/src/umtskeeper.tar.gz
tar -xzvf umtskeeper.tar.gz
chmod +x sakis3g umtskeeper
Ahora, configurar sakis:
sudo ./sakis3g --interactive
61
Figura 22: Pantalla inicial de Sakis 3G interactivo.
Seleccionar los siguientes ítems, en orden de aparición, dando enter sobre la opción:
Connect with 3G.
USB device.
Huawei mobile.
Interface #2.
Reported by your modem (internet.comcel.com.co).
Usuario de APN: comcel.
Clave de APN: comcel.
Al finalizar estos pasos satisfactoriamente, ya está conectado a la red móvil 3G a través de “Claro”
utilizando el protocolo ppp0.
Y por último, configurar UMTSKeeper, según los parámetros que se escogieron anteriormente al
ejecutar Sakis3G. Ejecutar el siguiente comando (una sola línea), que luego se añadirá
a “crontab” para que se ejecute siempre que se arranque la Raspberry Pi:
sudo /home/pi/UMTSkeeper/umtskeeper --sakisoperators "OTHER='USBMODEM'
USBMODEM='12d1:1c23' USBINTERFACE='2' APN='internet.comcel.com.co' APN_USER='comcel'
APN_PASS='comcel'"
Consultar el fichero /var/log/umtskeeper.log y ver que está todo en orden. Probar a desconectar y
reconectar el modem, y que tras medio minuto vuelve a conectarse automáticamente.
62
5.2.
5.2.1.
DISEÑO DE APLICATIVO
Instalación WAMP Server:
El entorno de desarrollo escogido para el almacenamiento, captura y procesamiento de la
información fue WAMP server v2.2, Apache v2.2.22, MySQL v5.2.24 y PHP v5.4.3 este entorno fue
instalado en un equipo con Sistema Operativo Windows 7.
Configuraciones iniciales para el funcionamiento del servidor
1. Se cambió el puerto de escucha por defecto “80” por el puerto “81”, realizando modificación
httpd.conf en sus líneas 46 y 171.
También se modifica el archivo wampmanager.tpl, en las líneas 121 y 122 de esta versión. Al
realizar estas modificaciones siempre se realiza reinicio de los servicios para que los cambios
tomen efecto.
2. En el archivo Host del equipo se asigna la IP pública como “localhost”, de este modo y
solicitando la apertura del puerto 81, será posible visualizar el contenido de la información vía
web a través del enlace: http://miippublica:81/, internamente http://localhost:81 o
http://miipprivada:81.
Configuraciones básicas de seguridad del servidor
1. Realizar los cambios respectivos de permisos de tal manera que el acceso al phpmyadmin, se
pueda realizar únicamente de manera local:
<Directory "c:/wamp/apps/phpmyadmin3.5.1/">
Options Indexes FollowSymLinks MultiViews
AllowOverride all
Order Deny,Allow
Deny from all
Allow from 192.168.0.100
</Directory>
2. Establecer una contraseña a la consola MySQL con el comando SET PASSWORD
FOR root@localhost=PASSWORD('Su_Clave_Aqui');
63
3. Modificar el archivo config.inc.php, para que se solicite el usuario y contraseña para acceder
al phpmyadmin: se configura el usuario y contraseña y se modifica para que en el acceso pida
la contraseña:
Figura 23: Interfaz de logeo de phpMyAdmin
5.2.2.
Transferencia de información
Para el transporte de la información, se utilizará el protocolo FTP, haciendo uso de la librería “ftplib”
en la Raspberry PI, para el envío de archivos hacia el Servidor FTP. En el caso del almacenamiento de
la información en el servidor, se utilizó el servidor FTP TYPSoft. En este servidor se configuran los
diferentes usuarios FTP para diferentes dispositivos y se asignan los respectivos permisos a las
carpetas a las que tendrán acceso.
64
Figura 24: Interfaz TYPSoft FTP Server
5.2.3.
Creación de base de datos, tabla y conexión de MySQL con PHP
Para la creación y modificación de las base de datos y tablas, se manejaron de 2 maneras: Usando la
consola MySQL o a través de phpmyadmin:
Diseño y creación de base de datos: Para el diseño y creación de la base de datos, era necesario
pensar desde la perspectiva del usuario final. Los datos relevantes que requiere un usuario es
acceder, consultar y visualizar la información del dispositivo que monitorea su vehículo, que sea muy
intuitiva y entendible.
Por tal motivo, en el desarrollo se realizó la creación de 2 tablas en la base de datos para la
importación y procesamiento de la información:
Tabla monitoreo
En esta tabla se importará la información almacenada en el servidor FTP de manera automática
gracias al servicio de Windows instalado.
La tabla está compuesta por los siguientes campos:
CREATE TABLE IF NOT EXISTS `monitoreo` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`latitud` varchar(100) DEFAULT NULL,
`longitud` varchar(100) DEFAULT NULL,
`direccion` varchar(100) DEFAULT NULL,
`fecha` varchar(100) DEFAULT NULL,
`hora` varchar(100) DEFAULT NULL,
`mapa` varchar(100) DEFAULT NULL,
65
`foto` varchar(100) DEFAULT NULL,
`estado` varchar(100) DEFAULT NULL,
`id_user` text DEFAULT Ninguna,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=41 ;
Tabla 11: Tabla de Monitoreo en MySQL
Campo id: Este campo es tipo entero e incremental, de esta manera permitirá tener un
conteo global de todos los registros importados para el administrador de la base.
También juega un rol importante en la publicación de los registros vía web de manera
ordenada y descendente, lo que permite visualizar del último registro importado al
primero.
Campo latitud: Almacena la información de la latitud del registro importado.
Campo longitud: Almacena la información de la longitud del registro importado.
Campo dirección: Almacena la información de la dirección del registro importado,
generada por la función codificada de georreferenciación inversa.
Campo fecha: Almacena la información de la fecha del registro importado.
Campo hora: Almacena la información de la hora del registro importado.
Campo mapa: Almacena la información del link de acceso al mapa del registro
importado. En la visualización web por medio de un icono redirecciona por hipervínculo
a una nueva pestaña al archivo *.html almacenado en el servidor que contiene el mapa
con su respectivo marcador.
Campo foto: Almacena la información del link de acceso a la foto del registro importado.
En la visualización web por medio de un icono redirecciona por hipervínculo a una nueva
pestaña al archivo de la foto o el almacenamiento del video, esto depende del estado
reportado en el campo estado.
66
Campo estado: Este campo almacena el estado automático o S.O.S, dependiendo del
estado reportado, el campo foto puede tener un link que direccione a una foto o video.
Campo id_user: Este campo almacena el ID del dispositivo de cada reporte, es de vital
importancia para el acceso del usuario registrado y para el filtrado de la información.
Tabla registro
En esta tabla se almacenará la información correspondiente a los usuarios registrados, la contraseña
es codificada con MD5 para brindar una mayor seguridad de la información.
CREATE TABLE IF NOT EXISTS `registro` (
`id_user` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(100) NOT NULL,
`nickname` varchar(100) NOT NULL,
`pass` varchar(32) NOT NULL,
PRIMARY KEY (`id_user`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=43 ;
Tabla 12: Tabla de registro
Campo id_user: Este campo es tipo entero e incremental, de esta manera permitirá tener
un conteo global de todos los usuarios registrados, para el administrador de la base. La
importancia de este campo, radica en que será el ID de usuario otorgado para que la
persona pueda ingresar a la plataforma una vez realizado el proceso de registro.
Campo name: En este campo se almacena el nombre de la persona que se registra. Es un
campo obligatorio para realizar el registro de manera satisfactoria.
Campo nickname: Este campo no solo es obligatorio para realizar el registro de manera
satisfactoria, sino también para acceder a los registros en la plataforma web mediante
autenticación de usuario.
Campo pass: Campo obligatorio que almacena la contraseña en codificación MD5, por
seguridad este campo es necesario para la autenticación del usuario registrado.
Diagrama Entidad- Relación
En el diagrama se encuentran las tablas “monitoreo” y “registro” creadas en la base de datos “php”,
estas contienen información de los usuarios registrados y de los reportes generados para cada uno de
los dispositivos.
67
Figura 25: Esquema entidad relación
Conexión MySQL con PHP
Para establecer la conexión es necesario configurar los campos de:
IP del servidor.
Nombre de usuario.
Contraseña.
Base de datos.
Formulario de registro
Para el formulario de registro, serán requeridos 4 campos a ingresar en la página registro.html:
Nombres y Apellidos.
Nick Usuario.
Contraseña.
Repetir contraseña.
Cuando el usuario llena los campos y procede a finalizar el registro, en la página registro.php se valida
que los campos de contraseña y repetir contraseña sean iguales para hacer efectivo el registro. Si el
registro se realiza de manera satisfactoria se almacenarán los datos en la tabla “registro”, y al usuario
le indicará por medio de un aviso “registrado correctamente” con su respectivo ID de dispositivo, de
lo contrario indicará si las contraseñas no coinciden o si no ha llenado alguno de los campos
requeridos.
Importación de datos
La importación de datos es posible realizarla, gracias a un servicio Windows que siempre está activo.
Este servicio realiza la tarea de importación automática cada 15 segundos, sobre los archivos de datos
“*.txt” enviados desde la Raspberry a la carpeta /captura/CapturaArchivos.
68
Para que el servicio funcione es necesario establecer la conexión a la base de datos y colocar la URL
de la carpeta donde se almacenarán los archivos a importar.
También se configura en una variable las líneas para la importación de los archivos.
El complemento adicional de este servicio es que cada vez que importa un archivo lo elimina de la
carpeta dejando limpio el almacenamiento y a la espera de un nuevo archivo a importar.
69
Figura 26: Diagrama de bloques del registro de usuario
Inicio de Sesión
Para el inicio de sesión del usuario registrado, se creó la página principal “index.html”, donde se
solicita ingresar el nombre de usuario y contraseña. En el caso de la contraseña la entrada se coloca
de tipo “password”, de esa manera la contraseña estará oculta a la vista del usuario. Cuando se
ingresan los datos, son validados en la página “login.php”, si son incorrectos saldrá un mensaje
advirtiendo que el usuario y/o contraseña no son válidos, de lo contrario establece una sesión y
guarda los datos.
Después de validar, el usuario es direccionado a la página principal “index.php”. En esta página se
asociará el número de ID asociado, que posteriormente será utilizado para el filtrado de contenido y
70
que únicamente pueda visualizar la información que le corresponde al ID del dispositivo. Ejemplo:
http://miippublica:81/index.php?userid=”$userid”.
En el siguiente código se podrá observar que se almacena como variable global la información del
“userid”, obtenida de la dirección URL. Esto con el objetivo de identificar el ID del dispositivo
autenticado y proceder a comparar con el ID de dispositivo de la tabla, de esa manera garantizar que
únicamente publique la información cuando el “userid” obtenido de la dirección del link sea igual al
ID de dispositivo de la tabla.
Figura 27: Diagrama de bloques inicio sesión
Por otra parte, se ingresa una variable como “bandera” para identificar cuando el usuario registrado
tiene datos almacenados y cuando no los tiene. Cuando el estado de la bandera está en “1”, significa
que ya se ha cargado información procedente de la Raspberry, el estado de la bandera en “0”,
significa que para el usuario autenticado no se ha enviado información o no se ha configurado el
dispositivo para el envío, por tanto se publicará información sobre los campos “no data load”.
71
Figura 28: Entorno Web, consulta sin datos de tabla monitoreo
El campo “estado” puede ser “Automático” o “S.O.S.”. En el primer caso, la Raspberry inicia en estado
“Automático”, enviando un reporte cada 10 minutos, con una fotografía adjunta. El estado “S.O.S” se
activa cuando se pulsa el botón de emergencia, envía un reporte con un video adjunto.
Posteriormente, continúa en estado “Automático”.
5.2.4.
Visualización
Visualización página web
Los datos que el usuario podrá visualizar, serán los enviados desde la Raspberry e importados en la
tabla “monitoreo” en un entorno más amigable como se observa en la siguiente figura.
Figura 29: Entorno Web consulta datos tabla monitoreo
En la parte izquierda aparece filtrado por el ID del dispositivo, en los demás campos de la tabla
aparecerá la información relevante como Latitud, Longitud, Dirección, Fecha, Hora, Mapa, Foto y
Estado.
Visualización mapa en Google Maps
Para el campo Mapa, está relacionado un icono que funciona como hipervínculo hacia la URL donde
se almacenó el archivo en el servidor y cuyo nombre de archivo contiene fecha y hora de captura. Por
ejemplo, http://miippublica:81/captura/mapa+fecha+hora.html.
72
El archivo “*.html” del mapa se envía ya creado desde la Raspberry. Este archivo contiene las
coordenadas obtenidas por el dispositivo GPS y por medio de un script, se invoca la API de Google
Maps, que está abierta a los desarrolladores y al público en común, y por medio de parámetros en
una función, se definen las características de la publicación y la inclusión de las coordenadas para la
ubicación en el mapa.
Georreferenciación Inversa: Como se explica en el marco teórico, la georreferenciación inversa hace
posible que a partir de las coordenadas obtenidas, se pueda traducir a una dirección legible e
interpretable por el usuario común por medio de un marcador como se observa en la siguiente figura.
Figura 30: Captura de coordenadas en Google Maps
73
Visualización Foto
La visualización de la foto, es un icono referenciado a un hipervínculo que apunta a la URL donde se
encuentra
almacenado
el
archivo
“*.JPG”.
Por
ejemplo,
https://miipublica:81/captura/imagen+fecha+hora.jpg.
74
6. Pruebas técnicas
Se
realiza
una
última
prueba
en
una
página
de
Google
llamada
https://developers.google.com/speed/pagespeed/insights/, en esta se permite analizar la experiencia
de usuario navegando en la página desde un ordenador de escritorio así como de un dispositivo
móvil.
A continuación se observa que la calificación para la navegación desde un equipo de escritorio es de
95/100, donde las recomendaciones es hacer cambios en la ejecución de JavaScript y CCS.
Figura 31: Google Developers equipo escritorio.
En cuanto a la experiencia en móviles hacen observaciones respecto a incorporar y adecuar el tamaño
de los botones para facilitar el manejo táctil. La puntuación fue de 71/100.
75
Figura 32: Google Developers dispositivo móvil.
6.1.
Prueba de Estrés:
Para llevar a cabo las pruebas, una herramienta disponible vía web es: http://loadimpact.com. Con
esta herramienta web, se puede poner a prueba escenarios de conexión múltiple y reflejar los
tiempos de respuesta a medida que se aumenta la carga de usuarios.
Como se puede observar en la siguiente figura, la convención “VU load time” hace referencia a la
traza del tiempo de carga a medida que se incrementan los usuarios, cuya convención es “VUs
active”. Se puede apreciar que el tiempo promedio de carga esta en 1.2 s. Este tiempo promedio de
carga para tratarse de un servidor local en un equipo de hogar es bueno e indica que los tiempos de
respuesta y eficiencia de operatividad mejorarían significativamente si los serivicios son migrados a
un servidor público con mayores recursos y disponibilidad.
Figura 33. Prueba de carga de conexión con 25 usuarios.
76
También pueden ser evaluados los tiempos de respuesta de los estilos gráficos e imágenes.
Figura 34. Respuesta de páginas y estilos.
Pruebas de conexión y tiempos de respuesta:
Para evaluación de tiempo de respuesta se realizó a través de la herramienta web
http://www.webpagetest.org/, donde se ingresa la dirección a ser consultada, en este caso la
dirección principal “http://miipublica:81/index.php”. En la siguiente imagen se aprecia como la
segunda consulta a diferencia de la primera es mucho más rápida, tanto en la carga de documentos
así como en la carga completa de la página
Figura 35. Tiempo respuesta plataforma web.
77
7. Conclusiones
Se logró diseñar e implementar el prototipo de seguridad de manera eficiente y apropiada
para el desarrollo del proyecto. El estudio de la viabilidad técnica y la creación de nuevas
plataformas y dispositivos electrónicos multilenguaje y compatibles con diversos sistemas
operativos fueron facilitadores en la integración de los componentes Hardware y Software.
La georreferenciación es una herramienta potente y debe seguir siendo aprovechada al
máximo en las diferentes aplicaciones informáticas, de seguridad, ubicación, etc. Contar con
este recurso tecnológico permitió generar mapas de localización con un rango de error muy
bajo y acoplado con el “reverse Geocoding” permite conocer la dirección física donde se
encuentra el vehículo, haciendo que el prototipo sea confiable en la veracidad de la
información que proporciona.
El desarrollo de la base de datos, le permite a los usuarios consultar vía WEB de manera
amigable y entendible la información que le corresponde del dispositivo al que está
relacionado. Este logro es fundamental porque muchos proyectos, incluyendo este, están
orientados al usuario común.
La integración de los lenguajes (HTML, PHP, JavaScript, Phyton) optimizan significativamente
el rendimiento e integración de las aplicaciones. Contar con un sistema robusto y actualizado
en sus tecnologías permite ofrecer un dispositivo de alta fidelidad sin importar, en ocasiones,
la limitación de los recursos que se puedan tener.
78
A. Anexo: Script “principal.py”
import picam
from time import *
estado = "Automatico"
iduser = ‘5’
while (True):
StateFile = open("/home/pi/estado.txt", 'w')
StateFile.write(estado)
StateFile.close()
picam.principal(estado, iduser)
sleep (600)
79
B. Anexo: Script “pulsador.py”
import os
import time
import RPi.GPIO as GPIO
import picam
GPIO.setmode(GPIO.BCM)
GPIO.setup(3,GPIO.IN)
estado = "S.O.S."
iduser = ‘5’
while True:
input = GPIO.input(3)
if (input==0):
print ("Boton pulsado")
StateFile = open("/home/pi/estado.txt", 'w')
StateFile.write(estado)
StateFile.close()
picam.principal(estado, iduser)
80
C. Anexo: Script “temporales.py”
#!/usr/bin/env python
# -*- coding: utf-8
from envioFTP import listaArchivos
from time import *
while True:
listaArchivos()
sleep(300)
81
D. Anexo: Script “picam.py”
#!/usr/bin/python
import StringIO
import subprocess
import os
import time
from datetime import datetime
from PIL import Image
import picamera
import envioFTP
tiempo = time.strftime
threshold = 20
sensitivity = 30
forceCapture = False
forceCaptureTime = 60 * 60
filepath = "/home/pi/Temporalenvio"
PrefixPic = "image"
PrefixDate = "date"
diskSpaceToreserve = 40 * 1024 * 1024
camerasettings = ""
prefixWeb = "http://186.154.5.153:81/captura/"
saveWidth
= 1296
saveHeight = 972
saveQuality = 10
testWidth = 100
testHeight = 75
testAreaCount = 1
testBorders = [ [[1,testWidth],[1,testHeight]] ]
debugMode = False
def captureTestImage(settings, width, height):
command = "raspistill %s -w %s -h %s -t 200 -e bmp -n -o -" % (settings, width, height)
imageData = StringIO.StringIO()
imageData.write(subprocess.check_output(command, shell=True))
imageData.seek(0)
im = Image.open(imageData)
buffer = im.load()
imageData.close()
return im, buffer
def saveImage(settings, width, height, quality, diskSpaceToReserve, estado):
keepDiskSpaceFree(diskSpaceToReserve)
global localNamePic
82
global FTPnamePic
global horaArchivo
horaArchivo = tiempo("%Y%m%d_%H%M%S")
horaPublicar = tiempo("%A, %d/%m/%Y, %X")
if estado == 'Automatico':
localNamePic = filepath + "/" + PrefixPic + horaArchivo + ".jpg"
FTPnamePic = PrefixPic + horaArchivo + ".jpg"
with picamera.PiCamera(resolution=(width, height), led_pin=False) as foto:
foto.annotate_text = horaPublicar
time.sleep(0.05)
foto.capture(localNamePic, quality=quality)
foto.close()
print "Captured %s" % localNamePic
elif estado == 'S.O.S.':
localNamePic = filepath + "/" + PrefixVid + horaArchivo + ".mp4"
FTPnamePic = PrefixVid + horaArchivo + ".mp4"
with picamera.PiCamera(resolution=(640,480)) as camera:
time.sleep(0.1)
camera.start_recording('/home/pi/video.h264', quality=25)
camera.wait_recording(10)
camera.stop_recording()
comando = "MP4Box -fps 30 -add /home/pi/video.h264 %s" %(localNamePic)
os.system (comando)
def keepDiskSpaceFree(bytesToreserve):
if (getFreeSpace() < bytesToreserve):
for localNamePic in sorted(os.listdir(filepath + "/")):
if localNamePic.startswith(PrefixPic) and localNamePIc.endswith(".jpg"):
os.remove(filepath + "/" + localNamePic)
print "Deleted %s/%s to avoid filling disk" % (filepath,localNamePic)
if (getFreeSpace() > bytesToreserve):
return
def getFreeSpace():
st = os.statvfs(filepath + "/")
du = st.f_bavail * st.f_frsize
return du
def principal(estado, iduser):
image1, buffer1 = captureTestImage(camerasettings, testWidth, testHeight)
lastCapture = time.time()
while (True):
image2, buffer2 = captureTestImage(camerasettings, testWidth, testHeight)
changedPixels = 0
takePicture = False
if (debugMode):
debugimage = Image.new("RGB",(testWidth, testHeight))
debugim = debugimage.load()
for z in xrange(0, testAreaCount):
for x in xrange(testBorders[z][0][0]-1, testBorders[z][0][1]):
for y in xrange(testBorders[z][1][0]-1, testBorders[z][1][1]):
if (debugMode):
debugim[x,y] = buffer2[x,y]
83
if ((x == testBorders[z][0][0]-1) or (x == testBorders[z][0][1]-1)
or (y == testBorders[z][1][0]-1) or (y == testBorders[z][1][1]-1)):
debugim[x,y] = (0, 0, 255)
pixdiff = abs(buffer1[x,y][1] - buffer2[x,y][1])
if pixdiff > threshold:
changedPixels += 1
if (debugMode):
debugim[x,y] = (0, 255, 0)
if (changedPixels > sensitivity):
takePicture = True
if ((debugMode == False) and (changedPixels > sensitivity)):
break
if ((debugMode == False) and (changedPixels > sensitivity)):
break
if ((debugMode == False) and (changedPixels > sensitivity)):
break
if (debugMode):
debugimage.save(filepath + "/debug.bmp")
print "debug.bmp saved, %s changed pixel" % changedPixels
if forceCapture:
if time.time() - lastCapture > forceCaptureTime:
takePicture = True
if takePicture:
saveImage(camerasettings, saveWidth, saveHeight, saveQuality,
diskSpaceToreserve)
os.system("sudo python /home/pi/iniciogps.py")
datos = open("/home/pi/datos.txt", 'a')
datos.write("|%s%s|%s|%s" %(prefixWeb, FTPnamePic, estado, iduser))
print (estado)
datos.close()
horaArchivo = tiempo("%Y%m%d_%H%M%S")
localNameDate = filepath + "/" + PrefixDate + horaArchivo + ".txt"
FTPnameDate = "CapturaArchivos/" + PrefixDate + horaArchivo + ".txt"
os.rename("/home/pi/datos.txt",localNameDate)
envioFTP.enviar (localNameDate, FTPnameDate)
envioFTP.enviar (localNamePic, FTPnamePic)
break
image1 = image2
buffer1 = buffer2
84
E. Anexo: Script “iniciogps.py”
#! /usr/bin/python
# -*- coding: utf-8
import os
from gps import *
from time import *
import time
import threading
import envioFTP
from pygeocoder import Geocoder
import envioEmail
tiempo = time.strftime
filepath = "/home/pi/TemporalEnvio"
PrefixMapa = "map"
prefixWeb = "http://190.26.41.106:81/captura/"
gpsd = None
os.system('clear')
class GpsPoller(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
global gpsd
gpsd = gps(mode=WATCH_ENABLE)
self.current_value = None
self.running = True
def run(self):
global gpsd
while gpsp.running == True:
gpsd.next()
if __name__ == '__main__':
gpsp = GpsPoller()
try:
gpsp.start()
senal = 0
StateFile = open("/home/pi/estado.txt", 'r')
estado = StateFile.read()
while True:
os.system('clear')
print 'Latitud: ' , gpsd.fix.latitude
print 'Longitud: ' , gpsd.fix.longitude
print 'Estado: ', estado
85
if abs(gpsd.fix.latitude) > 0.0 and abs(gpsd.fix.longitude) > 0.0:
print "GPS OK"
latitud = "%s" %(gpsd.fix.latitude)
longitud = "%s" %(gpsd.fix.longitude)
direccion = Geocoder.reverse_geocode(gpsd.fix.latitude, gpsd.fix.longitude)
if estado == 'S.O.S.':
envioEmail.enviar (direccion, tiempo("%X, %d/%m/%Y"))
horaArchivo = tiempo("%Y%m%d_%H%M%S")
horaPublicar = tiempo("%A, %d/%m/%Y|%X")
localNameMapa = filepath + "/" + PrefixMapa + horaArchivo + ".html"
FTPnameMapa = PrefixMapa + horaArchivo + ".html"
mapa = open("/home/pi/mapa.php", 'r')
mapa_nuevo = mapa.read()
mapa_nuevo = mapa_nuevo.replace("coordenadas", latitud + "," + longitud)
mapa.close()
nuevo = open(localNameMapa,'w')
nuevo.write(mapa_nuevo)
nuevo.close()
datos = open("/home/pi/datos.txt", 'w')
datos.write("|%s|%s|%s|%s|%s%s" %(latitud, longitud, direccion[0],
horaPublicar, prefixWeb, FTPnameMapa))
datos.close()
envioFTP.enviar (localNameMapa, FTPnameMapa)
break
else:
print "Esperando GPS..."
if estado == "Automatico":
if senal == 60:
horaPublicar = tiempo("%A, %d/%m/%Y|%X")
datos = open("/home/pi/datos.txt", 'w')
datos.write("|Sin senal|Sin senal|No hay dato|%s|No existe archivo"
%(horaPublicar))
datos.close()
break
senal = senal + 1
sleep (1)
gpsp.running = False
gpsp.join()
except (KeyboardInterrupt, SystemExit):
print "\nDesconectando GPS..."
print "Ok.\nSaliendo..."
86
F. Anexo: Script “envioFTP.py”
#!/usr/bin/env python
# -*- coding: utf-8
import ftplib
import os
global s
path
ftp_servidor
ftp_usuario
ftp_clave
ftp_raiz
=
=
=
=
=
'/home/pi/TemporalEnvio/'
'190.26.41.106'
'gps'
'4m3r1c42014*'
'/captura'
def enviar (archivoOrigen, archivoDestino):
fichero_origen = archivoOrigen
fichero_destino = archivoDestino
try:
s = ftplib.FTP(ftp_servidor, ftp_usuario, ftp_clave)
try:
f = open(fichero_origen, 'rb')
s.cwd(ftp_raiz)
s.storbinary('STOR ' + fichero_destino, f)
f.close()
s.quit()
except:
print "No se ha podido encontrar el fichero " + fichero_origen
else:
os.remove(fichero_origen)
except:
print "No se ha podido conectar al servidor " + ftp_servidor
def listaArchivos ():
lstFiles = []
lstDir = os.walk(path)
#os.walk()Lista directorios y ficheros
try:
s = ftplib.FTP(ftp_servidor, ftp_usuario, ftp_clave)
for root, dirs, files in lstDir:
for fichero in files:
(nombreFichero, extension) = os.path.splitext(fichero)
if(extension == ".txt"):
lstFiles.append(nombreFichero+extension)
enviar (path + nombreFichero + extension, "CapturaArchivos/" + nombreFichero +
extension)
else:
lstFiles.append(nombreFichero+extension)
enviar (path + nombreFichero + extension, nombreFichero + extension)
except:
print "No se ha podido conectar al servidor " + ftp_servidor
87
G. Anexo: Script “envioEmail.py”
#!/usr/bin/python
# -*- coding: utf-8
import
import
import
import
import
smtplib
mimetypes
email
email.mime.application
sys
msg = email.mime.Multipart.MIMEMultipart()
msg['Subject'] = 'Activacion boton S.O.S.'
msg['From'] = 'gps.raspberrypi@gmail.com'
msg['To'] = 'gps.raspberrypi@gmail.com'
def enviar (direccion, hora):
cuerpo = ("Se ha detectado la activación del botón de pánico en su
vehículo.\n\nDirección: %s\nHora: %s\n\nPodra visualizar la foto y la ubicación en el mapa
accediendo a su cuenta a través del siguiente link. \n\nhttp://181.130.15.178:81/index.php"
%(direccion[0],hora))
print "Enviando correo a " ,msg['To']
body = email.mime.Text.MIMEText(cuerpo)
msg.attach(body)
s = smtplib.SMTP('smtp.gmail.com:587')
s.starttls()
s.login('gps.raspberrypi@gmail.com','raspberrypi')
s.sendmail('gps.raspberrypi@gmail.com',['gps.raspberrypi@gmail.com'], msg.as_string())
s.quit()
print "Email enviado"
88
H. Anexo: Script “mapa.php”
<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="initial-scale=1.0, user-scalable=no">
<meta charset="utf-8">
<title>Localización GPS Raspberry Pi</title>
<style>
html, body, #map-canvas {
height: 100%;
margin: 0px;
padding: 0px;
}
var
var
var
var
</style>
<script src="https://maps.googleapis.com/maps/api/js?v=3.exp&signed_in=true"></script>
<script>
geocoder;
map;
infowindow = new google.maps.InfoWindow();
marker;
function initialize() {
geocoder = new google.maps.Geocoder();
var latlng = new google.maps.LatLng(coordenadas);
var mapOptions = {
zoom: 20,
center: latlng,
mapTypeId: 'hybrid'
}
map = new google.maps.Map(document.getElementById('map-canvas'), mapOptions);
codeLatLng();
}
function codeLatLng() {
var latlng = new google.maps.LatLng(coordenadas);
geocoder.geocode({'latlng': latlng}, function(results, status) {
if (status == google.maps.GeocoderStatus.OK) {
if (results[0]) {
map.setZoom(20);
marker = new google.maps.Marker({
position: latlng,
map: map
});
infowindow.setContent(results[0].formatted_address);
infowindow.open(map, marker);
} else {
window.alert('No results found');
}
} else {
window.alert('Geocoder failed due to: ' + status);
}
});
}
google.maps.event.addDomListener(window, 'load', initialize);
</script>
</head>
<body>
<div id="map-canvas"></div>
</body>
</html>
89
8. Bibliografía
[1] Concejo de Bogotá D.C., “POR EL CUAL SE IMPLEMENTA UN SISTEMA TECNOLÓGICO DE
SEGURIDAD EN VIDEO VIGILANCIA Y BOTONES DE PÁNICO EN EL SERVICIO DE TRANSPORTE
PÚBLICO INDIVIDUAL Y COLECTIVO DE PASAJEROS EN EL DISTRITO CAPITAL.” Abril de-2014.
[2] “¿Cuáles son las características principales del HTML?,” Postgrado en Marketing Online,
comunicación, Marketing Digital, postgrado online, uab, barcelona. .
[3] Rosselott, “Manual de PHP Básico - WebEstilo.” Jun-2003.
[4] PHP Group, “PHP 5.4.45 Released.” 2015-2001.
[5] Olga Cirauqui Elorz, “Instalar WAMP.” 02-Mar-2012.
[6] “CSS: Hojas de estilo,” CCM. [Online]. Available: http://es.ccm.net/contents/156-css-hojas-deestilo. [Accessed: 06-Sep-2015].
[7] “Java Script,” prezi.com. [Online]. Available: https://prezi.com/_kd-lnphaoq6/java-script/.
[Accessed: 06-Sep-2015].
[8] “Google Maps API V3 introducción y primeros pasos,” Maestros del Web. .
[9] Jorge Sánchez Asenjo, “Servidores de Aplicaciones Web.” 2012.
[10] Masadelante.com, “¿Qué es un servidor FTP (FTP Servers)?” 2015-1999.
[11] MD5online.org, “MD5 Online.” 2015-2012.
[12] Jorge Sánchez, “Diseño Conceptual de Bases de Datos.” 2004.
[13] “Tipos De Bases De Datos,” El blog de base de datos. [Online]. Available:
http://basededatos.over-blog.net/article-tipos-de-bases-de-datos-68319538.html. [Accessed: 06Sep-2015].
[14] “¿Qué es un gestor y cuáles son sus tipos?” .
[15] EcuRed, “Sistema Gestor de Base de Datos.” .
[16] “Base de datos modelo entidad relacion,” 20:20:14 UTC.
[17] Carl Rod Nave, “Satélites de Posicionamiento Global.” 2010.
[18] “Qué es el GPS, funcionamiento general,” Penyagolosa.net - Senderismo en Castellón, 2015-2006.
[Online].
Available:
http://www.penyagolosa.net/informacion-general/que-es-el-gpsfuncionamiento-general.html.
[19] Querelle y Cia Ltda., “Coordenadas geográficas,” Profesor en Linea. [Online]. Available:
http://www.profesorenlinea.cl/geografiagral/Coordenadasgeog.htm.
[20] “Coordenadas geográficas.” [Online]. Available: http://www.portaleducativo.net/quintobasico/684/Coordenadas-geograficas. [Accessed: 06-Sep-2015].
[21] “Sistema
de
Coordenadas,”
Coordenadas
GPS,
2015.
[Online].
Available:
http://www.coordenadas-gps.com/sistema-de-coordenadas.
[22] ms.gonzalez, “La transmisión de datos en la telefonía móvil | Redes Telemáticas.” .
[23] “Las redes de transmisión de datos usadas en los teléfonos celulares,” NorfiPC. [Online].
Available: http://norfipc.com/celulares/redes-transmision-datos-usadas-telefonos-celulares.php.
[Accessed: 07-Sep-2015].
90
[24] “Raspberry
Pi,”
Raspberry
Shop,
2015-2011.
[Online].
Available:
http://www.raspberryshop.es/index.php.
[25] winfernux, “Nuevo modelo de Raspberry Pi: La Model B+,” Life Bit Blog. .
[26] “Raspberry Pi,” Wikipedia, the free encyclopedia. 09-Sep-2015.
[27] “Raspberry Pi,” Wikipedia, la enciclopedia libre. 03-Aug-2015.
[28] “Accesorios para Raspberry Pi,” Raspberry Shop, 2015-2011. [Online]. Available:
http://www.raspberryshop.es/accesorios-raspberry-pi.php.
[29] “Modulo Gps Ublox NEO-6M,” arm32. [Online]. Available: http://www.arm32.cl/wireless/32modulo-gps-ublox-neo-6m.html. [Accessed: 10-Sep-2015].
[30] Botscience EIRL, “Módulo GPS para Arduino UBlox NEO 6M,” BOT Science, 2013. [Online].
Available: http://botscience.net/store/index.php?route=product/product&product_id=73.
[31] “RASPBERRY PI | Historia de la Informática.” .
[32] “Programando con Raspberry Pi B+ | botboss.” .
[33] “Python
PARA
TODOS.”
[Online].
Available:
http://www.academia.edu/8911458/Python_PARA_TODOS. [Accessed: 10-Sep-2015].
[34] “Tutorial 1 - Preparando la tarjeta SD para instalar el sistema operativo,” Frambuesa Pi Colombia
- Raspberry Pi en español. .
[35] “Tutorial 2 - Descarga de NOOBS y copia en la tarjeta SD,” Frambuesa Pi Colombia - Raspberry Pi
en español. .
[36] S. G. B. M. P. R. at C. U. L. de F. P. Estudi and o un P. de I. B. en C. U. L. E. y promotor de los
principios de R. P. para los que hablamos español, “Tutorial 3 - Instalación y configuración de
inicial del Raspberry Pi (raspi-config),” Frambuesa Pi Colombia - Raspberry Pi en español. .
[37] “Tutorial 4 (Parte 1) - Conexión del Raspberry Pi a Internet usando cable de red,” Frambuesa Pi
Colombia - Raspberry Pi en español. .
[38] “Tutorial 7 - Conexión remota al Raspberry Pi usando Xming,” Frambuesa Pi Colombia - Raspberry
Pi en español. .
[39] “Raspberry Pi NoIR Infrared Camera Board v1.3 (5MP, 1080p),” Pi Supply. .
[40] “Use the Raspberry Pi as a DIY Surveillance camera,” Make Tech Easier. [Online]. Available:
https://www.maketecheasier.com/raspberry-pi-as-surveillance-camera/. [Accessed: 10-Sep2015].
[41] “Tracker GPS con Raspberry Pi y el módulo Ublox M6,” fpaez.com. .
91
