ESCUELA TÉCNICA SUPERIOR DE INGENIEROS

INDUSTRIALES Y DE TELECOMUNICACIÓN

UNIVERSIDAD DE CANTABRIA

Trabajo Fin de Grado

Diseño e implementación de un sistema de

telemetría controlado por dispositivos
embebidos
(Design and implementation of a telemetry
system managed via embedded devices)

Para acceder al Título de

Graduado en
Ingeniería de Tecnologías de Telecomunicación

Autor: Raquel Martín Turrión

Julio - 2022
 GRADUADO EN INGENIERÍA DE TECNOLOGÍAS DE
TELECOMUNICACIÓN

CALIFICACIÓN DEL TRABAJO DE FIN DE GRADO

Realizado por: Raquel Martín Turrión

Director del TFG: Roberto Sanz Gil
Título: “Diseño e implementación de un sistema de telemetría controlado
…………..por dispositivos embebidos”
Title: “Design and implementation of a telemetry system managed via
………….embedded devices”

Presentado a examen el día: 5 de julio de 2022

para acceder al Título de

GRADUADO EN INGENIERÍA DE TECNOLOGÍAS DE

TELECOMUNICACIÓN

Composición del Tribunal:

Presidente (Apellidos, Nombre): Sanz Gil, Roberto
Secretario (Apellidos, Nombre): García Gutiérrez, Alberto Eloy
Vocal (Apellidos, Nombre): Fanjul Vélez, Félix

Este Tribunal ha resuelto otorgar la calificación de: …………………………………….

Fdo.: El Presidente Fdo.: El Secretario

Fdo.: El Vocal Fdo.: El Director del TFG

(sólo si es distinto del Secretario)

Vº Bº del Subdirector Trabajo Fin de Grado Nº

(a asignar por Secretaría)
Agradecimientos
Primero de todo, quiero especialmente agradecer a mi familia el apoyo
incondicional que me han dado, no solo durante todo el proyecto, sino durante toda
la carrera. Por no dejar que me venga abajo ante los problemas sobrevenidos
durante el desarrollo de este trabajo y del grado.
También quiero dar las gracias a mis amigos, que se encargaban de recordarme
que no debía distraerme y dejar las cosas para el último momento, sino que debía
ser constante.
Además, quiero agradecer a Mariola Garayo, Ángela Isla y María Isabel Sciddurlo
por haberme acompañado, apoyado y ayudado durante estos cuatro duros años en
los que hemos pasado de ser compañeras a ser grandes amigas.
Por último, pero no menos importante, agradecer a mi tutor del TFG Roberto Sanz
por haberme animado a escoger este tema tan actual y haberme ayudado a
solucionar con empeño cualquier duda o problema que me surgía durante el
transcurso del proyecto.
Resumen
Este Trabajo de Fin de Grado trata, como indica el título, de realizar un diseño e
implementación de un sistema de telemetría controlado por dispositivos embebidos.
En concreto, se explicará cómo realizar un sistema de detección de incendios
complementado con varios sensores más que ayudarán a obtener datos y realizar
acciones.
Para ello, se utilizarán un sensor de llamas, un sensor de sonido, un sensor de
humedad y temperatura, un buzzer y un sensor LED RGB que irán conectados al
Arduino. Como los datos de estos sensores se quieren enviar por Bluetooth a la
Raspberry Pi, habrá que conectar también un módulo Bluetooth al Arduino.
En la Raspberry Pi se realizará un servidor web para mostrar al usuario los datos
recibidos del Arduino de una forma visual y directa. Para conseguir esto, habrá que
insertar los datos recibidos en una base de datos y hacer que el servidor web lea
los datos que se quieran mostrar al usuario.
Abstract
This Final Degree Project deals, as the title indicates, with designing and
implementing a telemetry system controlled by embedded devices. Specifically, it
will be explained how to make a fire detection system complemented by several
more sensors that will help to obtain data and carry out actions.
To make this possible, a flame sensor, a sound sensor, a humidity and temperature
sensor, a buzzer and a RGB LED sensor will be used, which will be connected to
the Arduino board. A Bluetooth module will have to be connected to the Arduino
board to send data from sensors to Raspberry Pi.
A web server will be made in the Raspberry Pi to show the user the data received
from the Arduino board in a visual and direct way. To achieve this, it will be
necessary to insert the data received in a database and make the web server read
the data that we want to be shown to the user.
 Índice de contenidos
Capítulo 1. Introducción ..................................................................................................................... 1
1.1. Objetivos del proyecto............................................................................................................. 1
1.2. Motivación personal ................................................................................................................ 1
1.3. Estructura del documento ....................................................................................................... 2
Capítulo 2. Hardware del sistema ....................................................................................................... 3
2.1. Telemetría ................................................................................................................................ 3
2.2. Evolución del proyecto ............................................................................................................ 4
2.2. Arduino UNO............................................................................................................................ 6
2.2.1. Módulo Bluetooth HC-05 .................................................................................................. 8
2.2.2. Sensor de temperatura y humedad DHT11 Módulo KY-015 ............................................ 9
2.2.3. Sensor de llama Módulo KY-026 ..................................................................................... 10
2.2.4. Sensor de sonido Módulo KY-037 ................................................................................... 12
2.2.5. Buzzer pasivo Módulo KY-006 ........................................................................................ 13
2.2.6. LED RGB Módulo KY-016 ................................................................................................. 14
2.3. Raspberry Pi 3 model b .......................................................................................................... 15
Capítulo 3. Software del sistema ...................................................................................................... 17
3.1. Arduino UNO.......................................................................................................................... 17
3.2. Raspberry Pi 3 model b .......................................................................................................... 20
3.2.1. Base de datos .................................................................................................................. 20
3.2.2. Recepción e inserción de datos del Arduino .................................................................. 23
3.2.3. Servidor web ................................................................................................................... 24
3.2.4. Aplicación web ................................................................................................................ 24
3.3. Establecimiento de la conexión Bluetooth ............................................................................ 30
Capítulo 4. Integración y validación del sistema .............................................................................. 32
Capítulo 5. Conclusiones y líneas futuras ......................................................................................... 38
5.1. Conclusiones .......................................................................................................................... 38
5.2. Líneas futuras......................................................................................................................... 38
Referencias ....................................................................................................................................... 39
Anexo I. Configuración de la Raspberry Pi ........................................................................................ 41
I.1. Instalación del sistema operativo en la Raspberry Pi model 3 b ............................................ 41
I.2. Instalación del paquete mysql-connector-python.................................................................. 41
I.3. Instalación del servidor web Apache ...................................................................................... 41
 I.4. Instalación de MySQL MariaDB .............................................................................................. 42
I.5. Instalación de PHP .................................................................................................................. 43
I.6. Instalación de PhpMyAdmin ................................................................................................... 44
I.7. Creación de un usuario de MySQL .......................................................................................... 45
Anexo II. Configuración del módulo Bluetooth HC-05...................................................................... 48
Anexo III. Configuraciones previas del sensor de temperatura y humedad..................................... 50
 Lista de figuras
Figura 2.1. Ejemplo de sistema de telemetría en camiones ............................................................... 3

Figura 2.2. Funciones de un sistema de telemetría............................................................................ 4

Figura 2.3. Despliegue de la versión 1.0 ............................................................................................ 4
Figura 2.4. Despliegue de la versión 1.1 ............................................................................................ 5
Figura 2.5. Despliegue de la versión 2.0 ............................................................................................ 5
Figura 2.6. Arduino UNO .................................................................................................................... 6
Figura 2.7. Esquema del Arduino UNO .............................................................................................. 6
Figura 2.8. Módulo Bluetooth HC-05 .................................................................................................. 8
Figura 2.9. Conexión entre el módulo Bluetooth HC-05 y el Arduino ................................................. 9
Figura 2.10. Sensor DHT11 ................................................................................................................ 9
Figura 2.11. Conexión entre el sensor DHT11 y el Arduino ............................................................. 10
Figura 2.12. Sensor de llama ............................................................................................................ 11
Figura 2.13. Conexión entre el sensor de llama y el Arduino ........................................................... 11
Figura 2.14. Sensor de sonido .......................................................................................................... 12
Figura 2.15. Conexión entre el sensor de sonido y el Arduino ......................................................... 13
Figura 2.16. Buzzer pasivo ............................................................................................................... 13
Figura 2.17. Conexión entre el buzzer pasivo y el Arduino .............................................................. 14
Figura 2.18. LED RGB ...................................................................................................................... 14
Figura 2.19. Conexión entre el LED RGB y el Arduino .................................................................... 15
Figura 2.20. Raspberry Pi model b ................................................................................................... 15
Figura 3.1. Inicialización del programa “Enviar_datos_sensores.ino” de Arduino ........................... 17
Figura 3.2. Void loop del programa “Enviar_datos_sensores.ino” de Arduino ................................. 18
Figura 3.3. Función detectaFuego del programa “Enviar_datos_sensores.ino” de Arduino ............ 19
Figura 3.4. Función cambioLED del programa “Enviar_datos_sensores.ino” de Arduino ............... 19
Figura 3.5. Función humedad_temperatura() del programa “Enviar_datos_sensores.ino” de
Arduino .............................................................................................................................................. 20
Figura 3.6. Logos de MySQL y phpMyAdmin ................................................................................... 20
Figura 3.7. Creación de la base de datos y tablas correspondientes .............................................. 21
Figura 3.8. Creación de la tabla humedad ........................................................................................ 21
Figura 3.9. Creación de la tabla temperatura ................................................................................... 22
Figura 3.10. Creación de la tabla sensor_llama ............................................................................... 22
Figura 3.11. Creación de la tabla sensor_sonido ............................................................................. 22
Figura 3.12. Inicialización del programa “leer_arduino.py” ............................................................... 23
Figura 3.13. Bucle del programa “leer_arduino.py” .......................................................................... 23

Figura 3.14. Servidor Apache ........................................................................................................... 24

Figura 3.15. Lectura de valores de “index.php” ................................................................................ 25

Figura 3.16. Título y menú de “index.php” ........................................................................................ 25

Figura 3.17. Muestra de valores de “index.php” ............................................................................... 26

Figura 3.18. Código de “main.css” .................................................................................................... 27

Figura 3.19. Cambio del código de “sub_page.css” respecto a “main.css” ..................................... 27

Figura 3.20. Código de “deteccion_fuego.php” ................................................................................ 28

Figura 3.21. Código de “info_hora.php” ............................................................................................ 29

Figura 4.1. Esquema completo de la conexión entre los sensores y el Arduino .............................. 31

Figura 4.2. No se detecta fuego y el LED está apagado .................................................................. 32

Figura 4.3. Se detecta fuego y el LED está encendido .................................................................... 32

Figura 4.4. Detecciones de incendios ............................................................................................... 33

Figura 4.5. Información por mes ....................................................................................................... 33

Figura 4.6. Información por día ......................................................................................................... 34

Figura 4.7. Información por hora ...................................................................................................... 34

Figura 4.8. Página principal y detección de incendios desde un teléfono móvil .............................. 35

Figura 4.9. Información por mes y por día desde un teléfono móvil................................................. 35

Figura 4.10. Información por hora desde un teléfono móvil ............................................................. 36

Figura I.1. Estado de Apache ........................................................................................................... 42

Figura I.2. Prueba de PHP ................................................................................................................ 43

Figura I.3. Configuración de PhpMyAdmin parte 1 ........................................................................... 44

Figura I.4. Configuración de PhpMyAdmin parte 2 ........................................................................... 44

Figura I.5. Configuración de PhpMyAdmin parte 3 ........................................................................... 45

Figura I.6. Configuración en el entorno de MySQL .......................................................................... 46

Figura I.7. Interfaz web de PhpMyAdmin .......................................................................................... 46

Figura I.8. Inserción de la base de datos en PhpMyAdmin .............................................................. 47

Figura II.1. Configuración del módulo Bluetooth HC-05 ................................................................... 48

Figura III.1. Incluir librerías en el IDE de Arduino ............................................................................. 49

Figura III.2. Librería del sensor DHT ................................................................................................ 49

Figura III.3. Biblioteca Adafruit Unified Sensor ................................................................................. 50

 Lista de tablas

Tabla 2.1. Características técnicas del Arduino UNO ........................................................................ 7

Tabla 2.2. Características técnicas del módulo Bluetooth HC-05 ...................................................... 8

Tabla 2.3. Características técnicas del módulo sensor DHT11........................................................ 10

Tabla 2.4. Características técnicas del sensor de llama .................................................................. 11

Tabla 2.5. Características técnicas del sensor de sonido ................................................................ 12

Tabla 2.6. Características técnicas del buzzer pasivo ..................................................................... 13

Tabla 2.7. Características técnicas del LED RGB ............................................................................ 14

Tabla 2.8. Características técnicas de la Raspberry Pi 3 model b ................................................... 16

 Lista de acrónimos

BLE Bluetooth Low Energy

CA Corriente Alterna

CC Corriente Continua

CSS Cascading Style Sheets

GPIO General Purpose Input Output

HTML HyperText Markup Language

IoT Internet of Things

ICSP In Circuit Serial Programming

LED Light Emitting Diode

NTC Coeficiente de Temperatura Negativa

PHP Hypertext Preprocessor

PWM Pulse Width Modulation

PCB Printed Circuit Board

RFCOMM Radio Frequency Communication

RGB Red Green Blue

SQL Structured Query Language

USB Universal Serial Bus

 Capítulo 1. Introducción

1.1. Objetivos del proyecto

El objetivo de este Trabajo de Fin de Grado es realizar el diseño y posterior implementación
de un sistema de telemetría basado en sensores conectados y controlados a través de
dispositivos embebidos de propósito general, como son Arduino y Raspberry Pi.
La elección de los sensores viene determinada por su funcionalidad, queriendo así
monitorizar la detección de un incendio además de la medición de la humedad y
temperatura del lugar. Éstos se conectarán a la placa Arduino, el cual leerá y escribirá en
cada caso sobre los sensores enviando dicha información a la Raspberry Pi. La
comunicación entre Arduino y Raspberry Pi será a través de la interfaz inalámbrica
Bluetooth.
Se creará, además, una interfaz web alojada en el servidor de la Raspberry Pi para que el
usuario visualice y pueda manejar todos los datos de telemetría relativa a los sensores.

1.2. Motivación personal

Decidí escoger este tema para el Trabajo de Fin de Grado porque nunca había trabajado
con placas como Raspberry Pi o Arduino y me parecía interesante aprender a manejarlas.
Considero que el uso de estas placas es algo que se utiliza bastante en los últimos años
junto al uso de sensores para enviar/recibir información, especialmente con el surgimiento
de la Internet de las Cosas (IoT, Internet of Things).
Además, tampoco había programado nunca en Python y quería aprender un poco sobre
este lenguaje tan demandado y utilizado hoy en día. También quería poner en práctica lo
aprendido sobre bases de datos, lenguaje PHP, HTML y CSS, los cuales tuve la
oportunidad de estudiar en la asignatura optativa de 3er curso “Sistemas de Bases de
Datos”, ya que considero que las páginas web dinámicas (son aquellas en las que la
información presentada se genera en ese momento a partir de una petición específica del
usuario) también son muy útiles y usadas actualmente.
En resumen, elegí este proyecto porque las tecnologías y los lenguajes que se usan son
algo muy práctico para todo el mundo y está a la orden del día. Además, te da la
oportunidad de iniciarte en la domótica, que es algo que muchas personas ya tienen en sus
casas, automóviles o empresas.

1
1.3. Estructura del documento
La organización del documento viene dada de la siguiente forma:
En el capítulo 2 se describen los elementos que han formado parte del hardware del
sistema, habiendo explicado anteriormente y de forma breve qué es la telemetría.
Seguidamente, en el capítulo 3, se describen las herramientas software utilizadas, así
como la manera de configurar tanto el Arduino como la Raspberry Pi. Después, en el
capítulo 4 se muestran las prestaciones del sistema. Finalmente, en el capítulo 5, se
exponen las conclusiones y líneas futuras que puede ofrecer el sistema de telemetría
desarrollado en este trabajo.
Por último, se agregan varios anexos que ayudan a mostrar la configuración del sistema
operativo de la Raspberry Pi, la instalación y configuración de Apache, MySQL MariaDB y
PHP, del módulo Bluetooth HC-05 y del sensor de temperatura y humedad del Arduino.

2
 Capítulo 2. Hardware del sistema

2.1. Telemetría
La palabra telemetría procede de las palabras griegas τῆlε (tele), que quiere decir a
distancia, y la palabra μετρον (metron), que quiere decir medida [1]. Es la medición en
forma remota de magnitudes físicas o químicas captadas a través de sensores. Las
señales o datos medidos se transmiten generalmente usando tecnología inalámbrica [2].
Los sistemas de telemetría son sistemas automatizados de comunicación que miden o
rastrean a tiempo real ondas, temperatura, vibración, presión, voltaje, altitud, velocidad,
tiempo, entre otras magnitudes, en lugares remotos (Figura 2.1).

Figura 2.1. Ejemplo de sistema de telemetría en camiones [3]

La telemetría facilita la monitorización a distancia de procesos o equipos, el envío de alertas

o alarmas a un centro de control o plataforma de visualización a través de Internet, con el
fin de que el funcionamiento sea seguro y eficiente.

Un sistema de telemetría funciona de la siguiente forma (Figura 2.2) [3]:

1. Recopilación de datos: Se obtiene información clave sobre el funcionamiento. Se
tomarán mejores decisiones en base a esos números.
2. Uso de aparatos externos a los equipos: Los datos se recogen con sensores
externos a los equipos (transductores), por lo que no interfieren en su
funcionamiento ni es necesario desmontar las piezas originales para su instalación.
3. Transmisión a un emisor instalado en el dispositivo del cuál se quieren
obtener medidas: Los datos recogidos pasan por transmisión inalámbrica, por
cable o por Internet a un dispositivo que codifica la información para poder leerla de
manera entendible. Este dispositivo puede ser un teléfono móvil u otro transmisor
conectado a una red por radio o comunicación satelital.
4. Levantamiento de datos: Los datos recogidos por los sensores son convertidos
en magnitudes comunes que pueden ser leídas rápidamente, tales como km/h,
temperatura, niveles de un líquido, presión o localización.
5. Comunicación inalámbrica: Ya sea por red móvil o por red satelital, los datos se
transmiten desde el dispositivo a una central ubicada a distancia, en la que se
centralizan los datos en tiempo real.
6. Retroalimentación inmediata: La central está en condiciones de recibir y evaluar
los datos en cualquier momento. Esto permite enviar órdenes de forma inmediata,
ya sea por contacto con un operador humano o por una orden automatizada.

3
 Figura 2.2. Funciones de un sistema de telemetría [3]

Un sistema de telemetría tiene, en consecuencia, cuatro componentes principales:

transductor, unidad terminal, medio de transmisión y receptor.
Los objetivos se pueden resumir en:
• Conocer el estado de procesos, sistemas y equipos.
• Alertar de necesidades de mantenimiento preventivo, incidencias o fallos.
• Alertar de violaciones de acceso, seguridad o robos.
• Recopilar mediciones para predecir sucesos naturales.
• Programar actividades de manera remota y desde un centro de control.
Algunas aplicaciones de la telemetría que se pueden mencionar son: el automotriz, la
aviación, la agricultura, la industria petrolera, la medicina, la biología, la minería, etc.

2.2. Evolución del proyecto

Desde un primer momento, estaba claro que el proyecto debía tener varios sensores
conectados al Arduino, además de un módulo Bluetooth que sirviera para conectarse a la
Raspberry Pi de forma inalámbrica para transmitirle los datos de los sensores. En la
Raspberry Pi se almacenarían estos datos en una base de datos y se crearía un servidor
web para mostrar los datos al usuario de una forma más gráfica y amigable.
A continuación, se comentarán los cambios que ha habido durante la evolución del
proyecto:

Figura 2.3. Despliegue de la versión 1.0

4
Siguiendo este primer esquema (Figura 2.3), a la hora de probar la conexión Bluetooth, el
módulo BLE 4.0, AT-09 CC2541 (HM-10) no funcionaba bien, a veces se conectaba y de
repente se desconectaba; otras veces ni siquiera se conectaba y no respondía a comandos
AT de configuración.
Debido a estos problemas, se decidió cambiarlo y utilizar el módulo Bluetooth HC-05, como
se puede ver en la Figura 2.4.

Figura 2.4. Despliegue de la versión 1.1

Como una primera aproximación al trabajo, estaba previsto desplegar diferentes sensores
sin un propósito específico, simplemente para recibir datos, por lo que algunos de ellos se
cambiaron por otros en una siguiente versión para darle un significado concreto al sistema
de telemetría.

Figura 2.5. Despliegue de la versión 2.0

5
La versión final (ver Figura 2.5) queda representada como un sistema de detección de
incendios, además de obtener datos del sensor de humedad y temperatura. Como
complemento, el sensor de sonido sirve para cambiar el estado del LED RGB cuando no
se detecta ningún incendio.

2.2. Arduino UNO

Para este proyecto se ha utilizado la placa original Arduino UNO (Figura 2.6). Es una
pequeña placa electrónica con un microcontrolador programable basado en ATmega328P
en su PCB, el cual también incluye una serie de pines que, programando el chip, pueden
usarse como entradas o salidas.

Figura 2.6. Arduino UNO [4]

El siguiente esquema (Figura 2.7) muestra los pines que ofrece esta placa:

Figura 2.7. Esquema del Arduino UNO [5] [6]

6
Tiene 14 pines GPIO (General Purpose Input/Output) de entrada/salida digital (de los
cuales 6 pueden usarse como salidas PWM), 6 entradas analógicas, un reloj/oscilador de
cerámica de 16 MHz, una conexión USB, un conector de alimentación, un cabezal ICSP
(In-Circuit Serial Programmer) y un botón de reinicio o reset [7].
Para alimentar la placa, se puede conectar directamente a un ordenador mediante un cable
USB o usando un adaptador de CA a CC.
Las características técnicas del Arduino UNO son las siguientes (Tabla 2.1):

Nombre Arduino UNO R3

Placa
SKU A000066
Microcontrolador ATmega328P
Conector USB USB-B
Pin LED incorporado 13
Nº pines de E/S digitales 14
Pines
Nº pines de entrada analógica 6
Nº pines PWM 6
UART Sí
Comunicación I2C Sí
SPI Sí
Voltaje de E/S 5V
Voltaje de entrada (nominal) 7-12 V
Energía
Corriente CC por pin de E/S 20 mA
Conector de fuente de
Barrel Plug
alimentación

Velocidad de Procesador principal ATmega328P 16 MHz

reloj Procesador serie USB ATmega16U2 16 MHz
2 KB SRAM, 32 KB FLASH,
Memoria ATmega328P
1 KB EEPROM
Peso 25 gramos
Dimensiones Anchura 53.4 mm
Longitud 68.6 mm

Tabla 2.1. Características técnicas del Arduino UNO [7]

7
2.2.1. Módulo Bluetooth HC-05

El módulo Bluetooth HC-05 es una pequeña placa con un consumo muy bajo que permite
agregar funcionalidades Bluetooth al Arduino. Este módulo contiene un chip con una placa
de desarrollo con los pines necesarios para la comunicación serie (Figura 2.8). El módulo
HC-05 puede actuar como maestro o esclavo, es decir, puede conectarse con un
dispositivo o esperar a que el dispositivo se conecte al propio módulo [8].

Figura 2.8. Módulo Bluetooth HC-05 [9]

Sus características son las siguientes (Tabla 2.2):

Protocolo Bluetooth v1.1 / 2.0

Frecuencia Banda ISM de 2.4 GHz
Modulación GFSK
Potencia de transmisión Menos de 4 dBm, Clase 2
Sensibilidad Menos de -84 dBm en el 0,1% VER
Ratio asíncronos 2.1 Mbps (máx.) / 160 Kbps
Síncrono 1 Mbps / 1 Mbps
Puerto serie Bluetooth
Perfiles de la ayuda
(maestro y esclavo)
Fuente de alimentación +3.3 VDC 50 mA (soporta de 3.3 a 6 V)
Temperatura de trabajo -5º C a 45º C

Tabla 2.2. Características técnicas del módulo Bluetooth HC-05 [10]

Este módulo puede alimentarse con una tensión de entre 3.3 y 6 V (normalmente 5 V), pero
los pines TC y RX utilizan niveles de 3.3 V, por lo que no se puede conectar directamente
a las placas de 5 V, sino que se deben utilizar 2 resistencias como divisor de tensión para
que no se estropee: una de 5.6 KΩ (bandas verde, azul, rojo) y otra de 10 KΩ (bandas
marrón, negro, naranja). También dispone de un pulsador para entrar en modo comandos,
aunque esto se puede hacer por software utilizando el pin EN [10].
Tiene un LED incorporado que indica el estado de la conexión y si está emparejado o no
en función de la velocidad de parpadeo.

8
El módulo se conectará al Arduino de la siguiente forma (Figura 2.9):

Figura 2.9. Conexión entre el módulo Bluetooth HC-05 y el Arduino

2.2.2. Sensor de temperatura y humedad DHT11 Módulo KY-015

El DHT11 (Figura 2.10) es un sensor de temperatura y humedad digital básico y de muy

bajo coste. Utiliza un sensor de humedad capacitivo y un termistor para medir el aire
circuncidante y emite una señal digital en el pin de datos (no se necesitan pines de entrada
analógica). Este sensor requiere una sincronización cuidadosa para obtener datos, ya que
solo puede obtener datos nuevos una vez cada dos segundos como mínimo [11].

Figura 2.10. Sensor DHT11 [11]

Este sensor mide la humedad relativa, que es la cantidad de vapor de agua en el aire.
Detecta el vapor de agua midiendo la resistencia eléctrica entre dos electrodos. El
componente sensor de humedad es un sustrato que retiene la humedad con electrodos
aplicados a la superficie. Cuando el vapor de agua es absorbido por el sustrato, éste libera
iones que aumentan la conductividad entre los electrodos. El cambio de resistencia entre
los dos electrodos es proporcional a la humedad relativa. Una humedad relativa más alta
disminuye la resistencia entre los electrodos, mientras que una humedad relativa más baja
aumenta la resistencia entre ambos.

9
Además, el DHT11 mide la temperatura con un sensor NTC montado en superficie
(termistor) integrado en la unidad.
Las características técnicas del sensor DHT11 son las siguientes (Tabla 2.3):

Tensión de alimentación 3-5 V

Corriente máxima de alimentación 2.5 mA
Rango de medición de humedad relativa 20%-80% con ±5% de error
Rango de medición de temperatura 0-50º C con ±2% de error
Frecuencia de muestreo < 1 Hz (una vez por segundo)
Tamaño del cuerpo 15.5 mm x 12 mm x 5.5 mm

Tabla 2.3. Características técnicas del módulo sensor DHT11 [12]

La versión utilizada en este proyecto viene montada en PCB e incluye una resistencia de
10 KΩ montada en superficie para la línea de señal, por lo que no se necesita añadir
ninguna resistencia externa en el pin de datos (signal).
Este sensor irá conectado al Arduino como se muestra en la Figura 2.11.

Figura 2.11. Conexión entre el sensor DHT11 y el Arduino

2.2.3. Sensor de llama Módulo KY-026

El módulo KY-026 (Figura 2.12) es un sensor de llama que, por medio de un LED receptor
de infrarrojos, detecta longitudes de onda de llama en un rango de 760 nm a 1100 nm.
Incorpora dos salidas, una digital y otra analógica, e incluye un potenciómetro para ajustar
la sensibilidad del sensor, el cual se deberá girar en sentido horario para aumentar la
sensibilidad o en sentido antihorario para disminuirla. Hay que girar el potenciómetro en
sentido antihorario hasta que se apague el LED rojo de la izquierda del sensor (LED de
Detección) para poder usarlo en modo digital. La señal digital será ALTA (se encenderá el
LED de detección) cuando el sensor detecte fuego [13].

10
 Figura 2.12. Sensor de llama [13]

Las características del sensor de llama son las siguientes (Tabla 2.4):

Voltaje de operación 3.3-5 V

Corriente de operación 15 mA
Rango de detección 760-1100 nm
Ángulo de detección 60º
Tipo de salidas Digital y analógica
Ajuste de sensibilidad Sí
Distancia de detección máxima 1 metro
Dimensiones 15 mm x 36 mm
Peso 3 gramos

Tabla 2.4. Características técnicas del sensor de llama [13]

Este sensor irá conectado al Arduino como se muestra en la Figura 2.13.

Figura 2.13. Conexión entre el sensor de llama y el Arduino

11
2.2.4. Sensor de sonido Módulo KY-037

El módulo KY-037 (Figura 2.14) está compuesto por [14]:

• Un micrófono sensible KY-037.

• Dos salidas:
o Salida “AO”: es una salida analógica por la que se obtiene el nivel de tensión
de salida en tiempo real del micrófono.
o Salida “DO”: es una señal digital que se activa cuando la intensidad del
sonido ha alcanzado un cierto umbral previamente configurado.

Figura 2.14. Sensor de sonido [14]

Incluye un potenciómetro con el cual se puede ajustar la sensibilidad del sensor, es decir,
configura el umbral de detección. Si se gira en el sentido horario, se aumentará la
sensibilidad [15].
Este potenciómetro también sirve para activar el modo digital o analógico del sensor. Por
defecto, el sensor tiene encendidos 2 LEDs rojos (LED Salida Digital Accionada y LED de
Alimentación). El LED de Alimentación debe estar siempre encendido. El LED de Salida
Digital Accionada indica que la salida digital está activa, se debe girar el potenciómetro en
sentido antihorario para que se apague, esto hará que la salida digital tenga un nivel bajo
y solo se activará con un sonido fuerte (dependiendo de cómo se haya configurado la
sensibilidad).
Las características del sensor de sonido son las siguientes (Tabla 2.5):

Voltaje de funcionamiento 5V
Tipo de salidas Digital y analógica
Temperatura -40º C a +85ª C
Permite ajustar un nivel de umbral de salida
Usa el micrófono Gao Gan grado, de alta sensibilidad
Interruptor digital de salida (0/1)
Dimensiones 35 mm x 15 mm x 14 mm
Peso 4 gramos

Tabla 2.5. Características técnicas del sensor de sonido [15]

Este sensor irá conectado al Arduino como se muestra en la Figura 2.15.

12
 Figura 2.15. Conexión entre el sensor de sonido y el Arduino

2.2.5. Buzzer pasivo Módulo KY-006

El módulo KY-006 (Figura 2.16) es un sensor piezoeléctrico el cual puede reproducir tonos
de sonido entre un rango de 1.5 Hz a 2.5 kHz dependiendo de la frecuencia de entrada, ya
sea mediante retardos o modulación de ancho de pulso (PWM). Permite convertir la señal
eléctrica en una onda de sonido al momento en que se manda una señal eléctrica para
conseguir el sonido deseado [16].

Figura 2.16. Buzzer pasivo [16]

Las características del buzzer son las siguientes (Tabla 2.6):

Voltaje de funcionamiento 1.5 - 5 V DC

Rango de generación de tonos 1.5Hz - 2.5kHz
Corriente de trabajo < 25 mA
Dimensiones 18 mm x 15 mm
Peso 4 gramos
Pines GND, VCC y Señal
Tabla 2.6. Características técnicas del buzzer pasivo [16]

Este sensor irá conectado al Arduino como se muestra en la Figura 2.17.

13
 Figura 2.17. Conexión entre el buzzer pasivo y el Arduino

2.2.6. LED RGB Módulo KY-016

El módulo KY-016 (Figura 2.18) consta de un LED RGB de 5mm que es capaz de emitir
luz de color por medio de la mezcla de los colores del sistema RGB. Cuenta con tres
resistencias de 150 Ω en su PCB para evitar que se dañe el dispositivo [17].

Figura 2.18. LED RGB [17]

Las características del LED RGB son las siguientes (Tabla 2.7):

Voltaje de funcionamiento 3.3-5 V DC

LED RGB de cátodo común
Diámetro del LED RGB 5 mm
Temperatura de funcionamiento -40º C a +85º C
Dimensiones 19 mm x 15 mm x 15 mm
Peso 2 gramos

Tabla 2.7. Características técnicas del LED RGB [17]

Este sensor irá conectado al Arduino como se muestra en la Figura 2.19.

14
 Figura 2.19. Conexión entre el LED RGB y el Arduino

2.3. Raspberry Pi 3 model b

La Raspberry Pi 3 Modelo B (Figura 2.20) es un pequeño ordenador personal completo del
tamaño de una pequeña placa de circuito. Está compuesta por un procesador ARMv8, 4
puertos USB, conexión HDMI, puerto Ethernet e interfaces Wi-Fi y Bluetooth, entre otras
características. Gracias a su procesador, soporta el rango completo de distribuciones ARM
GNU/Linux (Raspbian, XBMC, Snappy Ubuntu Core) y Microsoft Windows 10. Además,
soporta herramientas de software libre como KOffice, Python, GNU IceCat, etc. Permite un
uso flexible en: juegos, multimedia, trabajo, educación, proyectos, etc [18].

Figura 2.20. Raspberry Pi model b [19]

Este modelo de Raspberry Pi es la tercera generación y salió al mercado para reemplazar

al modelo 2B en febrero de 2016.
Las características de esta placa son las siguientes (Tabla 2.8):

15
 Chipset Broadcom BCM2387
Procesador
1.2 GHz de 4 núcleos ARM Cortex-A53
Dual Core VideoCore IV ® Multimedia Co-procesador @ 400 MHz
GPU Soporte de OP GL ES 2.0, OpenVG acelerado por hardware y 1080p
30fps, códec de alto perfil de decodificación
RAM 1 GB SDRAM LPDDR2
Ethernet socket Ethernet 10/100 BaseT
802.11 b/g/n LAN inalámbrica y Bluetooth 4.1 (Classic Bluetooth y LE)
HDMI rev 1.3 y 1.4
Salida de video
RCA compuesto (PAL y NTSC)
Conectividad Jack de 3.5 mm de salida de audio, HDMI
Salida de audio
USB 4 x Conector USB 2.0

40 clavijas de 2.54 mm (100 milésimas de

Conector GPIO pulgada) de expansión: 2x20 tira
27 pines GPIO, 3.3 V, +5 V y GND
Conector de la cámara MIPI interfaz en serie (CSI-2) de 15 pines
Pantalla de visualización, conector de la interfaz de serie (DSI), conector de 15 vías
plana flex cable con dos carriles de datos y un carril de reloj
Ranura de tarjeta de memoria empuje/tire Micro SDIO

Tabla 2.8. Características de la Raspberry Pi 3 model b [20]

16
 Capítulo 3. Software del sistema

3.1. Arduino UNO

El Arduino debe tener el programa que se encarga de transmitir los datos de los sensores
vía conexión Bluetooth a la Raspberry Pi. Para ello, desarrollaremos el código haciendo
uso del entorno de programación IDE Arduino para Windows [21].
Antes de comenzar con el código, se debe comprobar que en Herramientas  Placa 
Arduino UNO está seleccionada correctamente esta opción. Además, se debe seleccionar
el puerto en: Puerto  COM3 (Arduino UNO), que es el modelo de Arduino que se usa en
este proyecto.
Más adelante, se mostrará el programa “Enviar_datos_sensores.ino” utilizado en el sistema
de detección de incendios. Este programa define que el LED RGB, inicialmente apagado,
emita luz verde si el usuario hace un ruido fuerte, como una palmada, solamente cuando
no se detecte fuego; en cambio, el LED emitirá luz roja mientras el buzzer emite sonido
durante la detección de un incendio. De forma paralela a esto, se obtienen datos del sensor
de humedad y temperatura. Además, los valores del estado del LED, la detección de llama,
la humedad y temperatura se enviarán por Bluetooth a la Raspberry Pi.
A continuación, se describirá de una forma más explícita cada parte del programa.

Figura 3.1. Inicialización del programa “Enviar_datos_sensores.ino” de Arduino

17
Primero, se puede ver en la Figura 3.1 que se comienza incluyendo las librerías necesarias
para el establecimiento de la comunicación serie, la librería del sensor de humedad y
temperatura DHT11 así como la definición de los pines en los que se ha conectado cada
sensor.
Además, se definen los pines 10 y 11 como receptor y transmisor de los datos que se
enviarán vía Bluetooth, respectivamente.
También, se definen variables cuyos valores, correspondientes a cada sensor utilizado, se
irán actualizando a lo largo del programa.
Por último, en la función setup(), cuyo código se ejecuta una sola vez, se inicializa el puerto
serie, el puerto del módulo Bluetooth, los pines (ya sean de entrada o salida) y el puerto
del sensor de humedad y temperatura.

Figura 3.2. Void loop del programa “Enviar_datos_sensores.ino” de Arduino

En la función loop() (Figura 3.2), cuyo código se ejecuta en bucle, se obtiene el valor del
sensor de llama y del sensor de sonido. Si se detecta una palmada (sonido fuerte), se
cambia el valor de la variable que se usa para cambiar el estado (encendido/apagado) del
LED RGB. Sólo se realiza correctamente el cambio de esta variable si no se detecta llama,
como se puede ver en la estructura if, llamando a la función cambioLED(). En cambio, si

18
se detecta fuego, el programa cambia el valor de la variable estado_fuego y llama a la
función detectaFuego(), cuya funcionalidad se explicará más adelante.
Además, se introduce un retardo de 7 segundos en el programa para llamar a la función
humedad_temperatura() para evitar errores al tomar las muestras, ya que el módulo DHT11
es un sensor lento.
Por último, se envían los datos de los sensores por Bluetooth a la Raspberry Pi.

La función detectaFuego que se puede ver en la Figura 3.3, se encarga de hacer que el
buzzer suene con el tono que se ha inicializado en la primera parte del programa. Además,
se encarga de cambiar la luz verde que ha podido encender el usuario previamente por
una luz roja, cuyo significado se suele asociar a “peligro”.

Figura 3.3. Función detectaFuego() del programa “Enviar_datos_sensores.ino” de Arduino

La función cambioLED (Figura 3.4) se encarga de apagar la luz roja que ha podido ser
encendida por la detección de un incendio. Además, cambia el estado del LED
dependiendo del valor almacenado en la variable estado_led.

Figura 3.4. Función cambioLED() del programa “Enviar_datos_sensores.ino” de Arduino

Por último, la función humedad_temperatura() (Figura 3.5) hace uso de funciones propias
de la librería “DHT.h” para obtener los valores de la humedad y temperatura del sensor
DHT11. Además, envía estos datos vía Bluetooth a la Raspberry Pi.

19
 Figura 3.5. Función humedad_temperatura() del programa
“Enviar_datos_sensores.ino” de Arduino

3.2. Raspberry Pi 3 model b

3.2.1. Base de datos

Para almacenar los valores de los sensores recibidos, es necesario crear una base de
datos que se almacenará y gestionará mediante la herramienta phpMyAdmin (Figura 3.6),
que se encarga de la administración a través de comandos MySQL (Figura 3.6) y es
accesible utilizando un navegador web [22].

Figura 3.6. Logos de MySQL y phpMyAdmin [23]

Aunque, utilizando esta herramienta, la base de datos se puede crear de forma gráfica, se
ha preferido crear un programa en SQL (sistema_de_telemetria.sql) para hacerlo, ya que
la creación e inserción de toda la base de datos resulta muy fácil y rápida mediante
phpMyAdmin.

20
Primero, como se puede ver en la Figura 3.7, se crea la base de datos
sistema_de_telemetria. Esta base de datos tendrá una tabla por cada sensor de medición
de datos.

Figura 3.7. Creación de la base de datos y tablas correspondientes

A continuación, se define la tabla humedad (Figura 3.8) y la tabla temperatura (Figura 3.9)
en las que se almacenará la fecha (día, mes, año), la hora (hora, minutos, segundos) y un
campo que almacena el valor de la humedad/temperatura respectivamente que mide cada
sensor.

Figura 3.8. Creación de la tabla humedad

21
 Figura 3.9. Creación de la tabla temperatura

Por último, se definen las tablas sensor_llama (Figura 3.10) y sensor_sonido (Figura 3.11)
en las que se almacenará la fecha (día, mes, año), la hora (hora, minutos, segundos) y un
campo que almacena un 1 si cada respectivo sensor detecta fuego/sonido o un 0 si no
detecta nada.

Figura 3.10. Creación de la tabla sensor_llama

Figura 3.11. Creación de la tabla sensor_sonido

22
3.2.2. Recepción e inserción de datos del Arduino

En la Raspberry Pi se ejecutará el programa de Python “leer_arduino.py” para recibir los

datos enviados por Bluetooth y almacenarlos correctamente en la base de datos. Este
programa se ejecutará en una terminal ejecutando el comando python leer_arduino.py y se
detendrá con el teclado. El programa es el siguiente:

Figura 3.12. Inicialización del programa “leer_arduino.py”

En primer lugar, como se ve en la Figura 3.12, se deben importar las librerías

correspondientes al puerto serie, al manejo del tiempo, al conector de MySQL con Python
(ver Anexo I para la explicación de la instalación de este paquete) y la librería que nos dará
la fecha actual. Además, se establecerá la conexión serie con el Arduino a través del puerto
Bluetooth RFCOMM y se abrirá la conexión con la base de datos introduciendo la dirección
IP o nombre, el nombre de usuario, la contraseña y el nombre de la base de datos a la que
se quiere acceder.
También, se inicializa un contador que ayuda a ordenar la inserción de los datos en la base
de datos.

Figura 3.13. Bucle del programa “leer_arduino.py”

23
A continuación, en el bucle del programa (Figura 3.13) se obtienen los datos de la fecha y
hora actuales y se almacenan en una cadena de caracteres. En esta cadena se almacenará
cada dato recibido del Arduino según el contador i, declarado anteriormente, usando
comandos SQL.
En la inserción del valor de la humedad, se ha tenido especial cuidado ya que a veces no
lo recibe completo y vuelve a enviarlo, haciendo así que, si tiene que recibir “63%”, en
realidad se obtenga “663%”. Para ello, se ha hecho que el valor sea el módulo 100 de lo
que reciba.
Por último, se finaliza la conexión con la base de datos y con el Arduino.

3.2.3. Servidor web

El servidor web que se ha utilizado en este proyecto es Apache (Figura 3.14), que es un
servidor web HTTP de código abierto para los sistemas operativos modernos, incluidos
UNIX y Windows. El objetivo de esta plataforma es proporcionar un servidor seguro,
eficiente y extensible que proporcione servicios HTTP en sincronía con los estándares
HTTP actuales [24].
Apache se lanzó en 1995 y ha sido el servidor web más popular en Internet desde abril de
1996.

Figura 3.14. Logo del servidor Apache [24]

La funcionalidad principal de este servicio web es servir a los usuarios todos los ficheros
necesarios para visualizar la web, es decir, los textos, imágenes, estilos… que conforman
la portada de una página web de forma segura. Las solicitudes de los usuarios se hacen
normalmente mediante un navegador (Chrome, Firefox, Safari, etc.) [25].
La instalación de Apache se muestra en el Anexo I.

3.2.4. Aplicación web

De cara al usuario, se ha desarrollado una aplicación web para mostrar la información de

la base de datos de una forma más fácil y amigable. Esta aplicación se ha realizado
haciendo uso de HTML, CSS, PHP, SQL y MySQL.
HTML se usa para diseñar y crear la página web, mientras que CSS se utiliza para
configurar el estilo de ésta. La página web, como se verá más adelante, tiene el diseño de
una aplicación IoT moderna.
PHP, SQL y MySQL se usan para crear la funcionalidad de la aplicación web, es decir,
mediante comandos SELECT de SQL se accederá a la base de datos.

24
A continuación, se describirán los códigos utilizados para crear la página web, que están
disponibles en mi GitHub https://github.com/rmt707/TFG.
En la Raspberry Pi están localizados en la carpeta /var/www/html. Además, se han dado
permisos de ejecución, lectura y escritura al puerto de conexión con el Arduino ejecutando
el comando sudo chmod 777 /dev/rfcomm0 y dando también todos los permisos a la carpeta
Sistema_de_telemetria y a cada archivo dentro de esta para evitar cualquier error que
pueda ocasionar.
Primero, se describirá la página web principal “index.php”:

Figura 3.15. Lectura de valores de “index.php”

En la Figura 3.15 se puede ver que al principio del código se configura que la página se
refresque cada 7 segundos, ya que la página principal es la única que muestra los datos
de los sensores a tiempo real. Además, se establece la conexión con la base de datos
insertando la dirección, el usuario, la contraseña y el nombre de la base de datos a la que
se quiere acceder.
Seguidamente, mediante comandos SELECT de SQL, se obtienen los valores actuales de
la base de datos que se mostrarán al usuario.

Figura 3.16. Título y menú de “index.php”

25
En la Figura 3.16 se muestra el diseño del título y del menú por el que se puede mover el
usuario para acceder a las distintas páginas diseñadas.
Por último, en la Figura 3.17 se puede apreciar que se ha configurado que, si no se detecta
fuego, mostrará al usuario el texto “No se detecta fuego” en un rectángulo con fondo verde;
en cambio, si se detecta fuego, se mostrará el texto “Se detecta fuego” en un rectángulo
con fondo rojo.
Además, se ha configurado una funcionalidad parecida con la detección de sonido. Si el
LED RGB está apagado, muestra el texto “LED OFF” en un rectángulo con fondo blanco;
en cambio, si detecta sonido y el LED se enciende, muestra el texto “LED ON” en un
rectángulo con fondo verde.
También, se muestra una tabla que muestra el valor de la humedad y la temperatura actual.

Figura 3.17. Muestra de valores de “index.php”

Esta página principal viene acompañada del programa “main.css” (Figura 3.18), que se
encarga de configurar cómo se muestra visualmente el código anterior.

26
 Figura 3.18. Código de “main.css”

Como se ha podido apreciar en la Figura 3.16, hay distintas páginas diseñadas para
enseñar información específica al usuario. Estas páginas tendrán asociado el código
“sub_page.css”, cuyo único cambio respecto a “main.css” es el siguiente que se muestra
en la Figura 3.19:

Figura 3.19. Cambio del código de “sub_page.css” respecto a “main.css”

27
En la Figura 3.20 se puede observar que la página “deteccion_fuego.php” solo se encarga
de mostrar en una tabla las últimas 25 fechas en las que se ha detectado algún incendio.

Figura 3.20. Código de “deteccion_fuego.php”

Por último, se han diseñado 3 páginas muy parecidas entre sí, que son: “info_hora.php”,
“info_dia.php” y “info_mes.php”. Estas páginas se encargan de mostrar el valor máximo, el
promedio y el valor mínimo de la humedad y temperatura por horas/días/meses,
respectivamente.
La página de horas muestra los últimos 24 registros, teniendo intención de mostrar las
últimas 24 horas; la de días muestra los últimos 31 registros, teniendo intención de mostrar

28
el último mes; por último, la del mes muestra los últimos 12 registros, teniendo intención de
mostrar el último año.

Figura 3.21. Código de “info_hora.php”

29
Como se puede ver en la Figura 3.21, ese es el código de “info_hora.php”. Para el código
de “info_dia.php”, habría que eliminar lo subrayado en azul; y para el código de
“info_mes.php”, habría que eliminar lo subrayado en rojo, además de lo subrayado en azul.

3.3. Establecimiento de la conexión Bluetooth

Para realizar el establecimiento de la conexión Bluetooth, se utilizarán comandos
bluetoothctl a través de una ventana terminal.
Primero, se obtiene la dirección MAC del módulo Bluetooth HC-05 que, en este caso, es
00:21:10:1E:A5:81. Esta dirección se ha obtenido usando la aplicación móvil Serial
Bluetooth Terminal.
A continuación, se ejecutan los siguientes comandos (aquellos en gris sólo se ejecutan en
el primer establecimiento de la conexión Bluetooth) en el terminal de la Raspberry Pi [26]:
• sudo apt-get install bluez bluetooth blueman  Se usa para instalar bluez, Bluetooth y
blueman.
• sudo /etc/init.d/bluetooth status -1  Se utiliza para comprobar el estado del
Bluetooth.
• Si estuviera detenido el servicio  sudo systemctl start bluetooth
• sudo bluetoothctl  Con este comando se entra en la línea de comandos propia de
Bluetoothctl.
• power on  Para encender el Bluetooth (se debe ejecutar 2 veces si la 1ª vez da
error).
• pairable on  Para que la Raspberry Pi se pueda emparejar con otros dispositivos.
• discoverable on  Si da error, se debe salir de la línea de comandos de Bluetoothctl
ejecutando quit, volviendo al terminal. Seguidamente, se ejecutan las siguientes
líneas [27]:
o rfkill unblock all  Para desbloquear la lista de radio-frecuencia.
o bluetoothctl  Para volver a entrar a su línea de comandos.
o Se vuelve a ejecutar discoverable on para que la Raspberry Pi se vuelva
visible para otros dispositivos.
• scan on  Para buscar dispositivos que tengan el Bluetooth activado.
• pair 00:21:10:1E:A5:81  Para emparejar con el módulo HC-05.
• trust 00:21:10:1E:A5:81  Para guardar la configuración y establecer la relación de
confianza ambos los dispositivos.
Para conectar la Raspberry Pi con el dispositivo, se debe salir al terminal poniendo quit y
ejecutar el siguiente comando:
• sudo rfcomm connect hci 00:21:10:1E:A5:81

Finalmente, aparecerá en pantalla:

Connected /dev/rfcomm0 to 00:21:10:1E:A5:81 on channel 1
Press CTRL-C for hangup

30
Si hay algún problema o algún error que no deje avanzar (generalmente en el discoverable
on), se debe ejecutar:

• sudo systemctl restart bluetooth  Para reiniciar el sistema Bluetooth.

31
 Capítulo 4. Integración y validación del
sistema

En este capítulo se mostrará el diseño completo del sistema de telemetría y las

prestaciones que ofrece de cara al usuario.

Aunque en el proyecto se han colocado todos los sensores del Arduino en una misma
placa, como se puede ver en la Figura 4.1, el usuario podrá colocar cada sensor donde
quiera simplemente usando cables con la longitud suficiente para llegar a la localización
donde quiera instalarlos.

Figura 4.1. Esquema completo de la conexión entre los sensores y el Arduino

En la Raspberry Pi, el usuario tendrá que ejecutar los comandos descritos en el apartado
3.3. para realizar el establecimiento de la conexión Bluetooth. Además, tendrá que ejecutar
en otra terminal el comando python leer_arduino.py y, cuando quiera dejar de recibir datos
de los sensores, detendrá la ejecución de este programa usando el teclado, como se ha
mencionado en el apartado 3.2.2.

Por último, podrá acceder a la página web para ver los datos de una forma más visual
abriendo el navegador Chromium y accediendo a la dirección
http://127.0.0.1/Sistema_de_telemetria/index.php para acceder de forma local a la página
principal.

Si no se detecta ningún incendio y el LED RGB está apagado, la página se ve como en la

Figura 4.2.

32
 Figura 4.2. No se detecta fuego y el LED está apagado

En cambio, la página luce como en la Figura 4.3 si se detecta un incendio y el LED RGB
estaba encendido previamente.

Figura 4.3. Se detecta fuego y el LED está encendido

Si el usuario pincha en el elemento “Detecciones de incendios” (Figura 4.4) del menú, se

mostrarán, como máximo, las últimas 25 fechas en las que se ha detectado un incendio.

33
 Figura 4.4. Detecciones de incendios

La página de información por mes (Figura 4.5), la página de información por día (Figura
4.6) y la página de información por hora (Figura 4.7) muestran el valor máximo, promedio
y mínimo de la humedad y temperatura según la elección que se escoja.

Figura 4.5. Información por mes

34
 Figura 4.6. Información por día

Figura 4.7. Información por hora

Además, el usuario puede acceder a la página web si está conectado a la misma red WiFi
que la Raspberry Pi. Para ello, deberá obtener la dirección IP de la Raspberry con el
comando ifconfig y buscar en la barra del navegador de su dispositivo móvil o portátil la
dirección http://@IP_Raspberry/Sistema_de_telemetria/index.php para
visualizarla.
En las figuras 4.8, 4.9 y 4.10 se puede ver cómo se mostrará cada página al usuario en su
teléfono móvil con más datos obtenidos de los sensores.

35
Figura 4.8. Página principal y detección de incendios desde un teléfono móvil

Figura 4.9. Información por mes y por día desde un teléfono móvil

36
Figura 4.10. Información por hora desde un teléfono móvil

37
 Capítulo 5. Conclusiones y líneas futuras

5.1. Conclusiones
Actualmente, la automatización en la obtención, inserción y análisis de datos es muy útil e
importante, consiguiendo ahorrar retardos y optimizar los resultados obtenidos. En el caso
de este proyecto, un sistema de detección de incendios, es fundamental minimizar el
retardo en la detección de incendios.

En particular, los sensores que se han elegido para ser utilizados por Arduino han sido: el
sensor de llama con detección inmediata, el sensor de sonido con micrófono de alta
sensibilidad y el sensor de medición de información (humedad y temperatura) para su
posterior procesado de datos.

Arduino, a través del módulo Bluetooth, le transmite los datos obtenidos de los sensores a
la Raspberry Pi, la cual se encarga de almacenarlos en una base de datos. A su vez, ésta
será consultada por el servidor web para mostrar los resultados a través de una página
web de forma amigable al usuario, con un diseño intuitivo y actual.

Por último, se han hecho las correspondientes pruebas de validación del prototipo para
comprobar que, tanto los sensores, como la programación de las dos placas (Arduino y
Raspberry Pi) funcionaran correctamente, dando así por alcanzados los objetivos
previamente establecidos en este trabajo.

5.2. Líneas futuras

Una posible mejora, en cuanto al hardware, sería conectar la Raspberry Pi a una pantalla
táctil de 7” en lugar de un monitor de ordenador para acceder a su configuración, ya que
así resultaría menos aparatoso, sería más cómodo y ahorraría espacio.

Se podrían añadir más sensores del mismo o de otros tipos, ampliando así la zona de
cobertura monitorizada frente a incendios u otros tipos de peligros. Esto llevaría, a su vez,
a una posible ampliación del número de Arduinos desplegados no sólo en la misma zona,
sino en ubicaciones alejadas y estratégicamente situadas, todos ellos interconectados con
una Raspberry Pi que haría de concentrador, comunicándose en este caso a través de
tecnologías inalámbricas de mayor alcance como Wi-Fi.

Por otro lado, en la parte software del sistema, se podría configurar el sistema y la
Raspberry Pi en particular, para que se pudieran cargar los programas de Arduino vía
Bluetooth, para así actualizar o modificar su programación sin tener que mover el Arduino
de su ubicación física ni tener que conectarlo a un ordenador.

Además, mediante la modificación en la configuración del firewall de la LAN en la que se

encuentra el servidor web de la Raspberry Pi, se podría diseñar una aplicación móvil o
hacer la página web pública para mostrar los datos en cualquier dispositivo de Internet.

38
 Referencias

Todas las referencias web han sido visitadas y están online a fecha de 26 de junio de 2022.

[1] «Telemetria - ¿Qué es? - Aplicaciones - Casos de uso», Telemetrik.

https://telemetrik.co/telemetria-que-es-aplicaciones-casos-de-uso/
[2] M. Terol, «Telemetría: qué es y cuáles son sus beneficios y aplicaciones», Movistar blog, 6 de
agosto de 2021. https://www.movistar.es/blog/5g/telemetria-funcionamiento-componentes-
aplicaciones-servicios/
[3] Sitrack, «Qué es la telemetría y sus aplicaciones». https://landing.sitrack.com/telemetria-y-
sus-aplicaciones
[4] «Arduino Uno: placa controladora programable». https://www.micro-log.com/arduino/2324-
arduino-uno-rev-3.html
[5] «▷ Tutorial de Arduino Uno [Pinout] (2022)», 22 de abril de 2021.
https://elosciloscopio.com/tutorial-arduino-uno-pinout/
[6] J. Guerrero, «Arduino Uno: Especificaciones y características», PlusElectric, 21 de septiembre
de 2014. https://pluselectric.wordpress.com/2014/09/21/arduino-uno-especificaciones-y-
caracteristicas/
[7] «UNO R3 | Arduino Documentation». https://docs.arduino.cc/hardware/uno-rev3
[8] «Arduino + Bluetooth», DIYMakers, 2 de febrero de 2014. http://diymakers.es/arduino-
bluetooth/
[9] «Modulo Transceptor Bluetooth HC05». https://www.eymelectronica.com/inicio/66-modulo-
transceptor-bluetooth-hc05.html
[10] «Módulo Bluetooth HC-05 compatible con Arduino. BricoGeek HC-05-BT | BricoGeek.com».
https://tienda.bricogeek.com/modulos-bluetooth/800-modulo-bluetooth-hc-05.html
[11] «How to connect DHT11 Sensor with Arduino UNO», Arduino Project Hub.
https://create.arduino.cc/projecthub/pibots555/how-to-connect-dht11-sensor-with-arduino-
uno-f4d239
[12] «8. Sensor de temperatura y humedad DHT11 - Shield Picuino UNO - Picuino».
https://www.picuino.com/es/uno-doc/dht11.html
[13] «Módulo KY-026 Sensor de Flama», UNIT Electronics.
https://uelectronics.com/producto/modulo-ky-026-sensor-de-flama/
[14] «Modulo KY-037 Sensor de Sonido -». https://electronica-jm.com/product/modulo-ky-037-
sensor-de-sonido/
[15] «Módulo KY-037 Sensor de Sonido», UNIT Electronics.
https://uelectronics.com/producto/modulo-ky-037-sensor-de-sonido/
[16] «Zumbador Buzzer Pasivo Módulo KY-006 UNIT Electronics», UNIT Electronics.
https://uelectronics.com/producto/zumbador-buzzer-pasivo-modulo-ky-006/
[17] «Sensor Led RGB Módulo KY-016», UNIT Electronics. https://uelectronics.com/producto/ky-
016-modulo-ky-016-sensor-led-rgb/
[18] «Raspberry Pi 3B [descontinuado]», Naylamp Mechatronics - Perú.
https://naylampmechatronics.com/raspberry-pi/255-raspberry-pi-3-b.html

39
[19] «RASPBERRYPI3-MODB-1GB. - Ordenador Monoplaca, Raspberry Pi 3 Modelo B, CPU 1.2GHz,
RAM 1GB, WiFi/BLE, 40 Pines GPIO». https://es.farnell.com/raspberry-pi/raspberrypi3-modb-
1gb/sbc-raspberry-pi-3-modelo-b-ram/dp/2525226
[20] «Raspberry Pi 3 Modelo B | PcComponentes.com», PcComponentes.
https://pccomponentes.com/raspberry-pi-3-modelo-b
[21] «Software». https://www.arduino.cc/en/software
[22] phpMyAdmin contributors, «phpMyAdmin», phpMyAdmin. https://www.phpmyadmin.net/
[23] A. G. Morgado, «Instalando MySQL y PHPmyAdmin en CentOS – Webnoticiero».
https://www.webnoticiero.es/?p=89
[24] «Welcome! - The Apache HTTP Server Project». https://httpd.apache.org/
[25] «¿Qué es Apache y para qué sirve?», Ayuda | dinahosting, 8 de enero de 2019.
https://dinahosting.com/ayuda/que-es-apache-y-para-que-sirve/
[26] «Configurar Bluetooth desde Terminal - Raspbian, Debian, Ubuntu y familia xD», Altaruru, 16
de junio de 2019. https://www.altaruru.com/configurar-bluetooth-desde-terminal-raspbian-
debian-ubuntu-y-familia-xd/
[27] «bluetooth.service running, but bluetoothctl says “org.bluez.Error.NotReady”», Arch linux.
https://unix.stackexchange.com/questions/508221/bluetooth-service-running-but-
bluetoothctl-says-org-bluez-error-notready
[28] R. P. Ltd, «Operating system images», Raspberry Pi.
https://www.raspberrypi.com/software/operating-systems/#raspberry-pi-desktop
[29] «balenaEtcher - Flash OS images to SD cards & USB drives», balenaEtcher.
https://www.balena.io
[30] Manuel González, Nivel 35 - Python con Mysql - Reto 1 - Instalar el conector mysql-connector-
python, (15 de julio de 2021). [En línea]. Disponible en:
https://www.youtube.com/watch?v=iruYJ7y01Bs
[31] AlexPro, «Cómo instalar el servidor web Apache en Raspbian • AlexPro Sytes», AlexPro Sytes,
30 de octubre de 2018. https://alexpro.sytes.net/como-instalar-el-servidor-web-apache-en-
raspbian-stretch-9/
[32] «Cómo instalar el gestor de bases de datos MySQL MariaDB en Raspbian • AlexPro Sytes»,
AlexPro Sytes, 30 de octubre de 2018. https://alexpro.sytes.net/como-instalar-el-gestor-de-
bases-de-datos-mysql-mariadb-raspbian/
[33] «Cómo instalar PHP en Raspbian • AlexPro Sytes», AlexPro Sytes, 1 de noviembre de 2018.
https://alexpro.sytes.net/como-instalar-php-en-raspbian/
[34] «Como instalar PhpMyAdmin en Raspbian • AlexPro Sytes», AlexPro Sytes, 22 de marzo de
2019. https://alexpro.sytes.net/como-instalar-phpmyadmin-en-raspbian-stretch-9/
[35] C. goyal, «localhost/phpmyadmin giving page not found error», Stack Overflow, 24 de agosto
de 2019. https://stackoverflow.com/questions/17772413/localhost-phpmyadmin-giving-
page-not-found-error
[36] Bitwise Ar, Arduino desde cero en Español - Capítulo 24 - Bluetooth HC-05 Introducción y
comandos AT, (6 de agosto de 2017). Accedido: 24 de junio de 2022. [En línea]. Disponible en:
https://www.youtube.com/watch?v=5SmKOUHhmWk
[37] «How to connect DHT11 Sensor with Arduino UNO», Arduino Project Hub.
https://create.arduino.cc/projecthub/pibots555/how-to-connect-dht11-sensor-with-arduino-
uno-f4d239

40
 Anexo I. Configuración de la Raspberry Pi

I.1. Instalación del sistema operativo en la Raspberry Pi model 3 b

Lo primero que se debe hacer en la Raspberry Pi es descargar el sistema operativo
Raspberry Pi Desktop [28] desde otro ordenador. Luego, se usará el programa
BalenaEtcher [29] para insertar correctamente la imagen del SO en una tarjeta microSD
que se utilizará en la Raspberry Pi.

A continuación, se asigna usuario y contraseña que, en el caso de la Raspberry Pi usada

en el proyecto, se ha asignado “pi” y “telematica”, respectivamente. Además, hay que
conectarla a la red Wi-Fi para poder actualizar la lista de paquetes y aplicaciones
ejecutando los comandos:
• sudo apt-get update
• sudo apt-get upgrade

I.2. Instalación del paquete mysql-connector-python

Este paquete es necesario para que el programa Python pueda conectarse con la base de
datos. Para instalarlo basta con ejecutar el comando [30]:
• pip install mysql-connector-python

I.3. Instalación del servidor web Apache

Antes de comenzar, es recomendable actualizar el sistema operativo de la Raspberry Pi a
la última versión disponible; para ello, se ejecutan los dos comandos que se han descrito
en el apartado I.1.

A continuación, para instalar el servidor web Apache, se ejecuta el siguiente comando en

la ventana de terminal [31]:
• sudo apt install apache2

Tras esto, el servidor web ya estaría funcionando, aunque de momento sólo puede mostrar
páginas html.

Después de la instalación, se comprueba que el servidor funciona correctamente con el

comando (Figura I.1):
• sudo systemctl status apache2

41
 Figura I.1. Estado del servidor web Apache

I.4. Instalación de MySQL MariaDB

Para instalar MySQL MariaDB basta con ejecutar en el terminal [32]:
• sudo apt install mariadb-server

Una vez instalado, hay que ejecutar el siguiente comando para hacerlo más seguro:
• sudo mysql_secure_installation

A continuación, se deben seguir los siguientes pasos:

• Primero, pedirá la contraseña actual del usuario root de la base de datos, que no
es la misma que la del usuario del sistema operativo. Como se acaba de instalar,
no tiene contraseña, así que se puede pulsar la tecla Enter para continuar.
• Luego, recomienda poner una contraseña al usuario root de la base de datos para
que no se pueda conectar cualquier persona con ese usuario sin tener contraseña.
Se pulsa Enter para que ofrezca establecer la contraseña.
• Seguidamente, pide escribir una nueva contraseña, en este proyecto se ha
establecido la contraseña “telematica”. Tras escribirla y pulsar Enter, pedirá volver
a escribirla para asegurarse de que está escrita correctamente.
• Después, preguntará si se quiere eliminar al usuario anónimo que actualmente se
puede conectar al gestor de bases de datos. Se pulsa Enter para eliminarlo.
• El usuario root de la base de datos, por defecto, se puede conectar desde otros
equipos. Por motivos de seguridad es recomendable que sólo se pueda conectar
desde la misma máquina en la que está instalado MariaDB. Se pulsa Enter para
activar dicha restricción.
• Por defecto, MariaDB tiene una base de datos llamada “test” a la que cualquiera
puede acceder, la cual hay que borrar por motivos de seguridad pulsando Enter.
• Por último, pedirá si se quieren recargar todos los privilegios para asegurarse de
que todos los cambios surgen efecto. De nuevo, se pulsa Enter para aceptar.

42
Tras todo esto, ya está instalado y asegurado MySQL MariaDB. El puerto por defecto de la
base de datos es el 3306.

I.5. Instalación de PHP

Para instalar PHP en Raspbian, basta con ejecutar la siguiente orden en el terminal [33]:
• sudo apt install php libapache2-mod-php php-mysql

Luego, se debe reiniciar el servicio Apache con el comando:

• sudo systemctl restart apache2

Para comprobar si funciona, se crea un archivo con extensión php:

• sudo nano /var/www/html/info.php

El contenido de este archivo se rellena con <?php phpinfo(); ?>

A continuación, se abre el navegador y se busca la dirección URL http://localhost/info.php,

en la que debe aparecer lo que se muestra en la Figura I.2.

Figura I.2. Prueba de funcionamiento de PHP

43
I.6. Instalación de PhpMyAdmin
Por último, para instalar PhpMyAdmin, se ejecuta el siguiente comando en el terminal [34]:
• sudo apt install phpmyadmin

Tras esto, aparecerá una ventana (Figura I.3) preguntando con qué servidor web se quiere
configurar. En este caso, apache2 es la opción que viene marcada por defecto, así que
basta con pulsar Enter para continuar.

Figura I.3. Configuración de PhpMyAdmin parte 1

Ahora, preguntará si se quiere crear una base de datos necesaria para que funcione
PhpMyAdmin (Figura I.4), por lo que se pulsa Enter para continuar.

Figura I.4. Configuración de PhpMyAdmin parte 2

A continuación, pedirá una contraseña (Figura I.5), la cual guardará internamente y no es

necesario conocer para su funcionamiento, para que PhpMyAdmin se pueda comunicar
con la base de datos. El campo se dejará en blanco pulsando Enter para que se cree
automáticamente una aleatoria.

44
 Figura I.5. Configuración de PhpMyAdmin parte 3

Después de la instalación, se ejecutarán los dos siguientes comandos para asegurarse de

que PhpMyAdmin funciona, creando un par de enlaces simbólicos:
• sudo ln –s /etc/phpmyadmin/apache.conf /etc/apache2/conf-available/phpmyadmin.conf
• sudo ln –s /etc/apache2/conf-available/phpmyadmin.conf /etc/apache2/conf-enabled/phpmyadmin.conf

Luego, se reinicia el servicio apache2 con el comando:

• sudo systemctl restart apache2

I.7. Creación de un usuario de MySQL

Para poder gestionar las bases de datos mediante PhpMyAdmin, es necesario crear un
usuario de MySQL. Para ello, hay que entrar en el entorno de MySQL ejecutando el
comando [34]:
• sudo mysql –u root

Aparecerá una línea con la palabra MariaDB [(none)]> a la izquierda. En ese entorno hay
que ejecutar las siguientes líneas (Figura I.6) cambiando, en el caso de este proyecto, la
palabra “usuario” por “admin” y “contraseña” por “telematica”:
• USE mysql;
• CREATE USER 'usuario'@'localhost' IDENTIFIED BY '';
• GRANT ALL PRIVILEGES ON * . * TO 'usuario'@'localhost';
• UPDATE user SET plugin='mysql_native_password' WHERE User='usuario';
• SET PASSWORD FOR 'usuario'@'localhost' = password('contraseña');
• GRANT ALL ON *.* TO usuario@localhost IDENTIFIED BY "contraseña" WITH GRANT OPTION;
• FLUSH PRIVILEGES;
• exit;

45
 Figura I.6. Configuración en el entorno de MySQL

Ahora, ya se puede acceder a la interfaz web (Figura I.7) e iniciar sesión con el usuario y
contraseña establecidos.

Figura I.7. Interfaz web de PhpMyAdmin

Si apareciese el error 404 Not found al intentar abrir PhpMyAdmin, habría que seguir los
siguientes pasos [35]:
• Ejecutar el comando sudo nano /etc/apache2/apache2.conf en el terminal.
• Incluir la línea Include /etc/phpmyadmin/apache.conf al final del fichero.
• Reiniciar Apache ejecutando el comando /etc/init.d/apache2 restart

Por último, para importar la base de datos creada con SQL, se pulsa en “Seleccionar
archivo” en la pestaña “Importar” y después “Continuar”, como se muestra en la Figura I.8.

46
Figura I.8. Inserción de la base de datos en PhpMyAdmin

47
 Anexo II. Configuración del módulo
Bluetooth HC-05
Para activar el módulo Bluetooth HC-05 en modo configuración (comandos), se debe pulsar
el botón del módulo durante 5 segundos justo cuando se le conecta a la alimentación, o
bien, cuando está conectado el pin EN (enable) al pin de 5 V del Arduino. Entonces, se
verá que, en lugar de parpadear rápidamente el LED rojo, pasa a parpadear lentamente.
Es ahora cuando responderá a los comandos AT de configuración, esto se puede
comprobar enviando el comando AT y obteniendo la respuesta OK (Figura II.1).

Antes de empezar a escribir comandos, es importante seleccionar Ambos NL & CR (Figura

II.1) en el monitor serie para indicar que se envíen los caracteres de CR (Retorno de Carro)
y NL (Nueva Línea).

A continuación, ejecutando el comando AT+NAME? se obtiene que el nombre puesto por

defecto del dispositivo es “HC-05” y con el comando AT+PSWD? se obtiene que la
contraseña es “1234”. Ejecutando el comando AT+ROLE? se recibe la respuesta “1”, que
quiere decir que está en master (maestro); hay que cambiarle a modo esclavo con el
comando AT+ROLE=0. Por último, se debe cambiar la velocidad de comunicación a 38400
baudios escribiendo el comando AT+UART=3840000 (34800,0,0). Esta configuración se ve
reflejada también en la Figura II.1 [36].

Figura II.1. Configuración del módulo Bluetooth HC-05

Para salir del modo configuración y volver al modo usuario, el Arduino se debe desconectar
de la alimentación. El pin EN del módulo Bluetooth también se debe desconectar del pin
de 5 V del Arduino y se debe conectar al pin GND o quitar el cable para que tenga el estado
LOW. Luego, se vuelve a conectar el Arduino a la corriente. Con esto, se verá que el LED

48
rojo del módulo volverá a parpadear rápidamente, lo que quiere decir que ya no responderá
a los comandos AT y se podrá encontrar desde otros dispositivos Bluetooth.

Ahora, cuando el módulo Bluetooth HC-05 se enlace con otro dispositivo, el LED rojo del
módulo parpadeará en intervalos lentos de 2 ráfagas rápidas para indicar que está
conectado con el dispositivo, en este caso, con la Raspberry Pi.

49
Anexo III. Configuraciones previas del sensor
de temperatura y humedad

Para poder obtener datos del sensor DHT11, se debe instalar la librería “biblioteca de
sensores DHT” de Adafruit en el IDE de Arduino, como se puede ver en la Figura III.1 y en
la Figura III.2 [37].

Figura III.1. Incluir librerías en el IDE de Arduino

Figura III.2. Librería del sensor DHT

50
A partir de la versión 1.3.0 de la biblioteca DHT, también hay que instalar la biblioteca
“Adafruit Unified Sensor” (Figura III.3), que también está disponible a través del gestor de
librerías “Arduino Library Manager”.

Figura III.3. Biblioteca Adafruit Unified Sensor

Con esto, se podrán utilizar las funciones específicas de este sensor para obtener
correctamente los datos de la humedad y la temperatura.

51