Subido por Miguel Ortíz

Base de datos - Interfaz

Anuncio
TECNOLÓGICO DE ESTUDIOS
SUPERIORES DE ECATEPEC
FACULTAD DE
INGENIERÍA EN
INFORMÁTICA
Materia: Tópicos de Base de Datos
Maestra: María Dolores Sabido Montejo
Integrantes:
-Sampedro Higuera Eder Esteban-Cazares Islas Jessica Jovana-Ortiz Vázquez Miguel Alberto-Espejel Dueñas Adrián-
INFORME
TÉCNICO DEL
PROYECTO
TERMINAL
ÍNDICE
INTRODUCCIÓN ............................................................................................................................ 1
REQUERIMIENTOS ....................................................................................................................... 2
ANALISIS DE LOS REQUERIMIENTOS ....................................................................................... 3
Arduino IDE y librerias .................................................................................................................... 3
Simulador wokwi ............................................................................................................................. 4
Xampp ............................................................................................................................................. 4
Visual Studio Code.......................................................................................................................... 5
Microcontrolador ESP32 ................................................................................................................. 5
Sensor DHT11................................................................................................................................. 6
Controlador CP210x........................................................................................................................ 8
Prototipo incial ............................................................................................................................... 11
Diseño y montaje en placa de pruebas.........................................................................................11
Codificación .................................................................................................................................13
Codigos PHP ............................................................................................................................16
Codigo Arduino .........................................................................................................................22
Verificación de funcionamento ..................................................................................................28
Prototipo final ................................................................................................................................ 30
Interfaz grafica .............................................................................................................................30
Códigos .......................................................................................................................................30
Implementación física del prototipo final. ......................................................................................44
INFORME TÉCNICO
INTRODUCCIÓN
El presente informe técnico tiene como objetivo explicar desde los recursos utilizados, como se fueron
utilizando para construir el prototipo final del sistema de monitoreo de temperatura y humedad para un
invernadero.
El objetivo del proyecto es poder construir un circuito y una interfaz gráfica que involucre tecnologías
como una base de datos, Internet de las cosas, manejo de solicitudes vía HTTP (usando métodos post y get),
uso de microcontroladores y componentes electrónicos. El conjunto de estas tecnologías podrá ayudar a
monitorear la temperatura y humedad dentro de un invernadero, el cual por su naturaleza es de especial
cuidado saber las temperaturas con las que se maneja para mantener en un estado optimo las diferentes
especies de plantas que se encuentran dentro de él, así el tener este tipo de control y mostrarlo en una
interfaz gráfica intuitiva es de gran ayuda para los administradores de estos invernaderos en poder cumplir
su trabajo.
Este sistema obtendrá a través de un sensor DHT11, el cual tiene integrado en su placa sensores de
temperatura y humedad, estos datos se enviarán al microcontrolador ESP32, este último enviara por medio
de internet, concretamente por Wi-Fi, a una base de datos toda la información para almacenarla y tener un
registro. La interfaz gráfica que será por medio de una página web contendrá esta información y así mismo,
se podrá controlar ciertos elementos desde esta misma (en el caso del prototipo se controlan unos diodos de
luz).
1
INFORME TÉCNICO
REQUERIMIENTOS
2
Los requerimientos tanto de software, hardware y otros (como madera para simular el invernadero)
para la realización el prototipo es:
Software
Hardware
Arduino IDE
Microcontrolador ESP32 Devkit4
Librería “JSON” para Arduino IDE
Sensor de temperatura y humedad DHT11
Librería “DHT11” para Arduino IDE
Diodos de luz (Led’s)
Simulador de Circuitos Web “Wokwi”
Jumpers
Software XAMPP (MySQL y Apache)
Resistencias (220 ohms)
Visual Studio Code
Cable USB a micro B
CP210x Universal Windows Driver
Fuente de alimentación regulado a 5 volts
Otros
Caja de madera con plantas para simular el invernadero
INFORME TÉCNICO
ANALISIS DE LOS
REQUERIMIENTOS
Para saber a más a detalle el cómo se utilizaron los anteriores materiales se debe tener en cuenta la
siguiente información, donde se habla sobre lo que son, para que sirven y que necesitamos en exactitud de
ellos.
ARDUINO IDE Y LIBRERIAS
El entorno de desarrollo integrado (IDE) de Arduino es una aplicación multiplataforma (para Windows,
macOS, Linux) la cual se utiliza para escribir y cargar programas en placas compatibles con Arduino, pero
también, con la ayuda de núcleos de terceros se puede usar con placas de desarrollo de otros proveedores.
La versión que utilicemos tiene que ser una reciente, pero no las más nueva para que sea estable la versión,
además de que se puedan incluir librerías sin ningún problema.
Las librerías para incluir son:
•
Arduino_JSON by Arduino. Esta librería nos ayudara al envió y recibo de los datos en formato
JSON, podremos leerlos correctamente para su uso.
•
DHT sensor library by Adafruit. Esta librería trae los elementos necesarios para el manejo
del sensor DHt11.
Todas las demás librerías que se utilizaran como para la conexión WiFi y en envió y recibo de datos
vía HTTP ya están incluidas por defecto al instalar el IDE.
Este IDE nos ayudara a programar el microcontrolador ESP32, le meteremos todo el código necesario
y además obtendremos lecturas en tiempo real gracias a su monitor serial, donde podemos imprimir cierta
información relevante para ver el proceso de ejecución del programa y saber si falla en alguna sección en
específico para poder resolver el problema rápidamente.
3
INFORME TÉCNICO
SIMULADOR WOKWI
Wokwi es un simulador online y gratuito que permite a los usuarios crear y probar circuitos
electrónicos que incorporen dispositivos como Arduino, ESP32 o similar.
Para razones de este proyecto se utilizó para hacer una simulación de como deberían quedar los
componentes antes de su ensamblaje en el prototipo. Es una buena herramienta para dar una idea y probarla
sin riesgo de cortocircuito o necesidad de cargar constantemente un programa en físico.
XAMPP
XAMPP es una distribución de Apache que incluye diferentes softwares libres. El nombre es un
acrónimo compuesto por las iniciales de los programas que lo constituyen:
•
Linux: Es el sistema operativo donde estará instalado nuestra aplicación. A diferencia de
Windows, Linux es una distribución libre que es segura, no requiere pago de licencias y tiene
alto rendimiento.
•
Apache: el servidor web de código abierto es la aplicación usada globalmente para la entrega
de contenidos web.
•
MySQL/MariaDB: XAMPP cuenta con uno de los sistemas relacionales de gestión de bases
de datos más populares del mundo. En combinación con el servidor web Apache y el lenguaje
PHP, MySQL sirve para el almacenamiento de datos para servicios web.
•
PHP: es un lenguaje de programación de código de lado del servidor que permite crear
páginas web o aplicaciones dinámicas. Es independiente de plataforma y soporta varios
sistemas de bases de datos.
•
Perl: este lenguaje de programación se usa en la administración del sistema, en el desarrollo
web y en la programación de red.
Para el caso de este prototipo solo utilizaremos lo que es Apache y MySQL, entonces con instalar
esos dos complementos es más que suficiente.
4
INFORME TÉCNICO
VISUAL STUDIO CODE
Visual Studio Code (VS Code) es un editor de código fuente desarrollado por Microsoft. Es software
libre y multiplataforma, está disponible para Windows, GNU/Linux y macOS. VS Code tiene una buena
integración con Git, cuenta con soporte para depuración de código, y dispone de un sinnúmero de
extensiones, que básicamente te da la posibilidad de escribir y ejecutar código en cualquier lenguaje de
programación.
Utilizamos VS Code en este proyecto para poder manipular los códigos con extensión .php que
hayamos estado creando. Es un IDE muy atractivo visualmente, rápido y flexible, lo cual lo hace perfecto para
estar trabajando.
MICROCONTROLADOR ESP32
ESP32 es una familia de microcontroladores de la empresa Espressif Systems. Incluye Wifi, Bluetooth
y otras potentes características extra.
ESP32 tiene varios pines digitales y análogos los cuales no son útiles en este proyecto, por ejemplo,
para cuestión de leer los datos de un sensor se utilizan sensores análogos, porque el voltaje que envían no
es fijo con 1 y 0 (según el lenguaje binario), sino que varía por milésimas, entonces una entrada análoga lee
correctamente esta información y ya solo nosotros a través de prácticas de codificación lo interpretamos.
Después las entradas digitales envían valores de 1 o 0, así que son útiles para encendido de componentes
como los LED’s.
Se elegio esta placa en particular por su módulo de WiFi integrado, lo cual nos ayuda a conectarnos
a alguna red WiFi que detecte y desde ahí poder acceder a dispositivos en esa misma red y realizar la tarea
correspondiente.
De igual manera sus otros pines con funcionales como suministro de voltaje nos ayudan para no tener
que recurrir a fuentes externas y agrandar los requerimientos.
Otra ventaja es su compatibilidad con Arduino IDE.
5
INFORME TÉCNICO
6
Ilustración 1. Diagrama de partes del microcontrolador ESP32.
SENSOR DHT11
El sensor DHT11 es capaz de realizar mediciones de humedad relativa y temperatura con un costo
muy bajo. A pesar de no ser la opción más precisa del mercado, es ideal cuando el costo es una preocupación
y por lo tanto funciona de maravilla para las aplicaciones experimentales, escolares y de hobby.
Su funcionamiento está basado internamente en un termistor para medir temperatura y un material
cuya capacitancia cambia dependiendo de la humedad en el ambiente (sensor capacitivo).
El sensor integra un convertidor analógico a digital (ADC) en su interior, por lo que aquellos
microcontroladores y microprocesadores que no dispongan de un ADC podrán tomar mediciones con este
sensor sin requerir hardware adicional.
Características:
•
Modelo: DHT11
•
Marca: ASAIR (AOSONG)
•
Tipo de sensor: temperatura, humedad relativa
•
Principio de funcionamiento: termistor, sensor de humedad capacitivo
•
Voltaje de alimentación: 3.5 a 5.5 VDC
•
Corriente típica en operación: 300 uA
INFORME TÉCNICO
•
Corriente típica en reposo: 60 uA
•
Especificaciones de sensor de humedad:
•
o
Rango: 20 a 90 % RH
o
Resolución: 16 bits
o
Precisión: ± 5% RH (a 25 °C)
Especificaciones de sensor de temperatura:
o
Rango: 0 a 50 °C
o
Resolución: 16 bits
o
Precisión: ± 2 °C
•
Frecuencia de muestreo: 1 vez cada dos segundos (0.5 Hz)
•
Conector: 4 pines con espaciado de 0.1 pulgadas
•
Interfaz: 4 conexiones
o
VDD
o
DATA
o
NC
o
GND
Ilustración 2. Diagrama de conexiones del sensor DHT11.
7
INFORME TÉCNICO
CONTROLADOR CP210X
Los controladores CP210x USB to UART Bridge Virtual COM Port (VCP) son necesarios para el
funcionamiento del dispositivo como un puerto COM virtual para facilitar la comunicación del host con los
productos CP210x. Estos dispositivos también pueden interactuar con un host mediante el controlador de
acceso directo.
Este controlador es necesario para que al conectar con el cable USB al ESP32 lo reconozca como
puerto COM y permita una correcta comunicación entre ellos. Ya que sin este controlador al conectar el
ESP32 a la computadora no lo reconocerá y por tanto no se podrán cargar programas en el ESP32.
La pagina de descarga directa es:
•
Controladores CP210x USB a UART Bridge VCP - Silicon Labs (silabs.com)
Dentro de esta página se debe descargar la primera opción o dependiendo del sistema operativo que
se esté utilizando cambiara la descarga.
Ilustración 3. Opciones de descarga dentro de la página oficial del controla dor (Silicon Labs).
8
INFORME TÉCNICO
Requerimientos funcionales
<CU>
Lectura
y envió de
datos
del sensor e
interpretación en ESP32
9
Versión
1.0
Autor
Ortiz Vázquez Miguel Alberto
Objetivos
El sensor recolectara los datos y se interpretaran
dentro del código.
Requisitos Asociados
Sensor DHT11 funcional.
Descripción
El sensor recolecta
toda la
información de
temperatura y humedad, la envía a través de voltaje
al pin del ESP32, el cual con el código cargado
interpretara dicha información para convertirla en
información útil y comprensible para el usuario
Precondición
Se deberá tener alimentada la placa ESP32 para
que pueda alimentar al sensor y empezar a capturar
datos.
Secuencia
1.
Alimentar
el
microcontrolador
con
voltaje
regulado.
2. Alimentar el sensor con el ESP32.
3. El sensor comenzara a recibir información.
4. El sensor enviara voltaje al pin conectado al
ESP32,
el
cual
a
través
de
programación
interpretara esa información.
5. El ESP32 mostrara por el monitor serial dicha
información ya comprensible.
Postcondición
Se tendrá le temperatura en grados celcius y
humedad en porcentaje.
Excepciones
Si es que el sensor no llega a funcionar por algún
fallo físico, no se ejecutara el programa.
Frecuencia
Se hace cada 7 segundos
Urgencia
Se tiene que hacer seguido para tener mejores
lecturas para posibles cambios de temperatura.
INFORME TÉCNICO
<CU>
Envió de datos de temperatura a la base de datos
Versión
1.0
Autor
Ortiz Vázquez Miguel Alberto
Objetivos
Los datos recolectados del sensor se envían a la
base de datos.
Requisitos Asociados
Sensor DHT11 funcional, conexión a la base de
datos y creación de la misma con sus respectivas
tablas.
Descripción
Los datos recolectados, en grados celcius y
porcentaje de humedad se enviarán a la tabla
“Actualización” en la base de datos.
Precondición
El sensor deberá enviar datos correctamente al
ESP32
Secuencia
1. Verificación de datos antes de enviarlos para ver
que están correctos.
2. Transformarlos a formato JSON.
3. Enviarlos vía HTTP POST a la base de datos
establecida.
4. Monitoreo en monitor serial los datos enviados.
5. Verificación en la base de datos la información
actualizada.
Postcondición
Se guardará la información en la base de datos.
Excepciones
Si los datos no se guardan correctamente en
formato JSON no se procederá al guardado.
Frecuencia
Se hace cada 10 segundos.
Urgencia
Se hace cada 10 segundos para ir actualizando en
la base de datos y por ende la interfaz grafica se ve
actualizada.
10
INFORME TÉCNICO
DESARROLLO
El desarrollo del proyecto se llevó en dos fases, la primera llamada “Prototipo inicial” donde se
probaron los componentes, la codificación y funcionamiento general del proyecto, después la última fase
“Prototipo final” donde se creó una interfaz gráfica y su montaje dentro del invernadero.
PROTOTIPO INCIAL
Diseño y montaje en placa de pruebas
Lo primero a realizar dentro del prototipo inicial es un diseño dentro de Wokwi, para ver cómo debería
quedar el montaje de nuestros componentes, el cual es el siguiente:
Ilustración 4. Diagrama del prototipo inicial. En este se muestran las conexiones, a que puertos y como irán
distribuidos los componentes.
11
INFORME TÉCNICO
Una vez teniendo ya el diseño de como se vera procedemos a montarlo dentro de una placa de
pruebas o “protoboard”, quedando de esta manera.
Ilustración 5. Montaje del prototipo inicial en protoboard.
En este proceso se debe conectar el microcontrolador a la computadora por medio de un cable USB
a micro B, ya que la computadora dentro de sus puertos USB da un voltaje regulado de 5 volts, lo cual es útil
para alimentar la placa, además de que es el medio por el cual subiremos el programa con nuestro proyecto.
12
INFORME TÉCNICO
Codificación
La parte de la codificación es la más importante, primero empezaremos creando la base de datos
dentro de phpMyAdmin, para ello accederemos desde nuestro navegador a lo siguiente: “localhost”, nos
mostrara una pantalla como esta:
Ilustración 6. Pantalla inicial de XAMPP en el navegador.
Después daremos clic en “phpMyAdmin” y seguido nos mostrara una pantalla donde meteremos
nuestras credenciales para el inicio de sesión en el servidor. Colocaremos las que habíamos colocado antes
al configurar (cuando instalamos XAMPP) y al acceder tendremos esta ventana:
13
INFORME TÉCNICO
14
Ilustración 7. Ventana principal dentro de phpMyAdmin.
Aquí empezaremos a crear nuestra base de datos y las tablas necesarias para nuestra práctica. Esto
lo haremos a través de lenguaje transactSQL, por lo cual meteremos comandos en la pestaña “SQL” que se
encuentra en la parte superior.
El primero es la creación de la base de datos:
•
“create database esp32_mc_db”
INFORME TÉCNICO
Los demás es para la creación de las tablas y ejecución de registros (en el caso de la tabla
Actualización).
15
Ilustración 8. Código para la creación de la tabla "Ac tualización" e inserción de su primer registro de cada columna.
Esta tabla servirá para recibir e ir actualizando en un solo registro los valores del sensor y estado de los led's.
Una vez ejecutado podremos visualizarla de esta manera:
INFORME TÉCNICO
16
Ilustración 9. Código para la creación de la tabla "Registros" la cual se utilizará para guardar todos los registros que
se vayan registrando, teniendo la misma información que en la tabla "Actualización" pero en diferentes re gistros.
CODIGOS PHP
Ya una vez creadas las bases de datos, procedemos con los códigos que nos permitirán él envió,
recibo, actualización de información. Los nombrare por el nombre del archivo y se explicara en general su
funcionamiento y propósito, ya el código esta comentado para su mejor entendimiento. Al final se dará la
muestra de donde se tiene que guardar estos archivos.
database.php
Esta clase servirá básicamente para la conexión a la base de datos, daremos las credenciales nombre
de la base de datos en específico que se utilizará, así como las funciones de conexión y desconexión a esta
misma. Estamos hablando que es orientado a objetos por lo cual se podrá utilizar estas mismas funciones en
otras clases.
INFORME TÉCNICO
17
Ilustración 10. Archivo "database.php" con la clase Database.
INFORME TÉCNICO
obtener_datos.php
Esta clase tiene la finalidad de la obtención de los datos de la tabla “Actualización”, primero accede a
al servicio de base de datos y a la base de datos especifica a través de las funciones creada en
“database.php”, por eso se importa en un inicio, se van obteniendo los datos y validación de que si se tiene
una respuesta a través de una solicitud POST.
Guarda los registros en un objeto y después por medio de un bucle for recorre dichos registros y los
almacena. Estos datos después serán visualizados en el monitor serial de Arduino.
Ilustración 11. Archivo obtener_datos.php
18
INFORME TÉCNICO
actualizar_datos_sensor_tabla.php
Este código nos ayudara a poder actualizar los datos de la tabla “Actualización” y “Registros”,
anteriormente en “obtener_datos.php” solo accedíamos al registro de la tabla, pero no lo actualizábamos,
aquí si actualizamos dicho registro en todos sus campos, generamos claves de identificación únicas para los
registros de la tabla “Registros” y guardamos los valores correspondientes. Los valores que tengamos en
“Actualizacion” se guardaran en “Registros” periódicamente.
Ilustración 12. Archivo "actualizar_datos_sensor_tabla.php", parte 1.
19
INFORME TÉCNICO
20
Ilustración 13. Archivo "actualizar_datos_sensor_tabla.php", parte 2.
INFORME TÉCNICO
actualizarLEDs.php
Este código servirá para actualizar el estado de los led’s, si están encendidos o apagados, así
también que cada vez que cambie el estado, se actualice el estado del led correspondiente.
Todo esto mediante lo que se obtenga de la tabla “Actualizacion”.
Ilustración 14. Archivo "actualizarLED's.php"
RUTA DE ALMACENAMIENTO
Una parte importante para mencionar es la ubicación de estos archivos, ya que para que funcione y
podamos usarlos correctamente se tienen que guardar en una ruta especifica, en el caso de este proyecto es
la siguiente:
•
C:\xampp\htdocs\ESP32_MySQL_Database\Final
La ruta siempre debe ser la misma hasta “htdocs”, desde ahí se puede crear una nueva carpeta para
almacenar el proyecto.
21
INFORME TÉCNICO
CODIGO ARDUINO
Ahora dentro del IDE Arduino se introduce el siguiente código, el cual se cargará directamente al
ESP32, este código contendrá las funciones de lectura, establecer pines, envió de los datos y recibimiento
de los mismo mandando a llamar los archivos anteriormente mencionados.
El nombre que se le dé al archivo y su ruta no tiene relevancia y no afecta al funcionamiento del
proyecto. Solo hay que verificar que tenemos instaladas las librerías que se mencionaron en el Análisis de
Requerimientos para que no exista ningún error. También verificar y asegurarse que la dirección IP, el nombre
de la red WiFi (SSID) y su contraseña, así como la ruta donde se acceden a los archivos (Los que creamos
antes en Códigos PHP), sean correctos y si es que hay modificaciones en alguno de estos campos,
actualizarlos en el código.
Ilustración 15. Código en lenguaje C utilizando Arduino para subir a la placa, parte 1.
22
INFORME TÉCNICO
23
Ilustración 16. Código en lenguaje C utilizando Arduino para subir a la placa, parte 2.
INFORME TÉCNICO
24
Ilustración 17. Código en lenguaje C utilizando Arduino para subir a la placa, parte 3.
Ilustración 18. Código en lenguaje C utilizando Arduino para subir a la placa, parte 4
INFORME TÉCNICO
25
Ilustración 19. Código en lenguaje C utilizando Arduino para subir a la placa, parte 5.
INFORME TÉCNICO
26
Ilustración 20. Código en lenguaje C utilizando Arduino para subir a la placa, parte 6.
INFORME TÉCNICO
27
Ilustración 21. Código en lenguaje C utilizando Arduino para subir a la placa, parte 7.
Este código procederemos a subirlos a la placa, una vez que este este conectada. Solo
presionaremos en el botón con forma de flecha hacia enfrente (dentro del Arduino IDE) lo cual compilará el
código y subirá. Si todo se hizo correctamente y se instaló el controlador mencionado en los requerimientos
no debe existir ningún problema y el ESP32 junto con el sensor DHT11 empezaran a mandar información y
recibiéndola, así mismo todo por medio de una red WiFi.
INFORME TÉCNICO
VERIFICACIÓN DE FUNCIONAMENTO
Una vez cargado el programa y mientras este ejecutándose, accederemos al monitor serial que viene
integrado dentro del Arduino IDE, aquí podemos visualizar todas las impresiones que tenemos en el código
anterior para saber en que proceso va y si hubo un error o fue exitoso.
Ilustración 22. Monitor serial durante la ejecución del código en el ESP32.
Vemos que conecta exitosamente a la red y muestra el SSID y dirección IP, también como llamada al archivo
“obtener_datos.php” y obtiene los respectivos datos, como se está en control de los LED’s, la lectura del
sensor y envió de estas lecturas a la base de datos.
Ahora si accedemos a phpMyAdmin y checamos las tablas vemos como todos sus registros se están
actualizando.
28
INFORME TÉCNICO
29
Ilustración 23. Registro actualizado de la tabla "Actualizacion".
Ilustración 24. Registros agregados en la tabla "Registros".
Por motivos del proyecto se actualizan los datos aproximadamente cada 7 segundos por lo cual se
añade un nuevo registro en la tabla “Registros” en ese tiempo. Este tiempo puede modificarse solo poniendo
un delay dentro del Código en Arduino IDE, para que de más tiempo de espera.
INFORME TÉCNICO
PROTOTIPO FINAL
Interfaz grafica
Como añadido final se pensó realizar una interfaz gráfica a través de una página web, esta interfaz
mostrara le temperatura y humedad, así mismo como los botones para el control de los LED’s, toda eta
información obtenido de la tabla “Actualizacion” de la base de datos. Otra página ligada a esta mostrara una
tabla donde se muestran todos los registros existentes en la tabla “Registros” dentro de nuestra base de
datos.
De esta manera el usuario puede visualizar de una forma más sencilla e intuitiva la información para
administrar el invernadero.
Para lograr esta interfaz, se necesitaron dos archivos extra con código en lenguaje php, estos archivos
mandaran a llamar los archivos ya existentes.
Códigos
inicio.php
En este archivo se creará la página principal normalmente conocida como “inicio”, se mostrará la
temperatura y humedad en tiempo real, un controlador de los LED’s e información extra como si el sensor
está funcionando, el ultimo registro recibido y un botón para abrir la tabla de registros.
En el mismo archivo se maneja el lenguaje php, html y css. Todo está en conjunto para evitar el uso
de archivos extra, aunque la recomendación es que los diseños (css) se hagan en un archivo diferente.
30
INFORME TÉCNICO
31
Ilustración 25. Código del archivo "inicio.php", parte 1.
INFORME TÉCNICO
32
Ilustración 26. Código del archivo "inicio.php", parte 2.
INFORME TÉCNICO
33
Ilustración 27. Código del archivo "inicio.php", parte 3.
INFORME TÉCNICO
34
Ilustración 28. Código del archivo "inicio.php", parte 3.
INFORME TÉCNICO
35
Ilustración 29. Código del archivo "inicio.php", parte 4.
Ilustración 30. Código del archivo "inicio.php", parte 5.
INFORME TÉCNICO
36
Ilustración 31. Código del archivo "inicio.php", parte 6.
INFORME TÉCNICO
Una vez completado dichos códigos, se cargarán en la misma carpeta donde se cargaron los
anteriores, en el caso de este proyecto es esta:
•
C:\xampp\htdocs\ESP32_MySQL_Database\Final
Y para acceder a verlos, colocaremos dentro del url de búsqueda del navegador web, en el caso de
este proyecto la ruta puede variar (ESP32_MySQL_Database) dependiendo si se guardó y con que nombre
en alguna carpeta, pero básicamente debe estar dentro de “htdocs”:
•
http://localhost/ESP32_MySQL_Database/Final/inicio.php
La interfaz gráfica ya terminada se ve de esta manera:
Ilustración 32. Interfaz gráfica en página web del prototipo final.
37
INFORME TÉCNICO
tabla_registros.php
En este último código sirve para la creación y darle estilos a la tabla que mostrara los registros, así
mismo como la paginación de estos, ya que suelen ser muchos registros es necesario agregar un algoritmo
de paginación para evitar un sobrecargo de información en una sola pagina y tener un mejor orden.
Ilustración 33. Código del archivo "tabla_registro.php", parte 1.
38
INFORME TÉCNICO
39
Ilustración 34. Código del archivo "tabla_registro.php", parte 2.
INFORME TÉCNICO
40
Ilustración 35. Código del archivo "tabla_registro.php", parte 3.
INFORME TÉCNICO
41
Ilustración 36. Código del archivo "tabla_registro.php", parte 4.
INFORME TÉCNICO
42
Ilustración 37. Código del archivo "tabla_registro.php", parte 5.
Ilustración 38. Código del archivo "tabla_registro.php", parte 6.
INFORME TÉCNICO
43
Ilustración 39. Código del archivo "tabla_registro.php", parte 7.
Una vez terminado el código, desde la página inicio al picar el botón de “Abrir tabla de registros” nos
llevara a esta nueva página donde veremos en una tabla los registros existentes así mismo como la
paginación.
INFORME TÉCNICO
44
Ilustración 40. Interfaz gráfica de la tabla que muestra todos los registros.
Una vez terminada la interfaz grafica para el monitoreo de los datos y control de LED’s, solo falta la
implementación física dentro de un invernadero a escala para mostrar su posible aplicación.
Implementación física del prototipo final.
Para la implementación física del prototipo final se utilizo una caja de madera, a la cual se le colocaron
plantas, tierra, piedras y agua para simular un miniinvernadero, a esta caja se le colocaron los componentes
teniendo en cuenta que el sensor debe ir en la parte de adentro para una mejor medición de la temperatura
y humedad de esta.
Aquí podemos alimentar al ESP32 con una fuente externa y no con la computadora, y el
funcionamiento seria el mismo, solo que con la computadora podemos leer el monitor serial y saber si existe
algún problema.
INFORME TÉCNICO
45
Ilustración 41. Evidencia de la implementación física del prototipo final.
INFORME TÉCNICO
46
Ilustración 42. Evidencia de la implementación física del prototipo final.
INFORME TÉCNICO
CONCLUSIONES
Después de concluir el proyecto llegamos a destacar ciertos puntos importantes los cuales se fueron
recabando a lo largo de la realización del proyecto:
•
Integración de tecnologías: El proyecto demuestra la capacidad de integrar diversas
tecnologías
para
desarrollar
soluciones
completas.
La
combinación
de
IDE,
microcontroladores, solicitudes HTTP, manejo de archivos o formatos JSON, manejo y
administración de bases de datos y servicios Web, creación de interfaces a través de lenguaje
HTML y dándoles diseño con CSS, uso de monitor serial y demás, muestra cómo se pueden
utilizar diferentes herramientas para lograr un objetivo en común.
•
Internet de las cosas (IoT): El uso del IDE Arduino con ESP32 para recopilar datos y enviarlos
a través de protocolos HTTP POST y GET revela la aplicación practica del internet de las
cosas. La capacidad de conectar dispositivos físicos a Internet y transmitir información abre
un amplio abanico ante posibilidades de escalar el proyecto.
•
Almacenamiento y manejo de datos: La utilización de XAMPP y Apache para la base de datos
y cómo gestionar y almacenar la información recopilada incrementa la capacidad de
resolución de problemas y amplia el conocimiento sobre las bases de datos, el cual es un área
fundamental en la informática. Estas herramientas permiten crear una base sólida para el
almacenamiento, consulta y gestión eficiente de los datos generados por los dispositivos
conectados. De igual manera el manejo de archivos y formatos JSON es un aprendizaje
importante ya que la mayoría de los servicios web, por ejemplo, las API se manejan con este
tipo de archivo y conocer como manejarlo es de vital importancia.
47
INFORME TÉCNICO
REFERENCIAS
Como generar claves aleatorias:
•
https://code.tutsplus.com/generate-random-alphanumeric-strings-in-php--cms-32132t
Manejo de HTTP POST y GET:
•
https://randomnerdtutorials.com/esp32-http-get-post-arduino/
•
https://www.youtube.com/watch?v=nmzt-a-WtWw&ab_channel=Techtutorialsx
•
https://www.youtube.com/watch?v=s_2cw0k6lgs&ab_channel=Techtutorialsx
JSON en PHP
•
https://www.w3schools.com/js/js_json_php.asp
Arduino y JSON
•
https://www.luisllamas.es/arduino-json/
Manejo de horarios
•
https://stackoverflow.com/questions/35127109/date-and-time-in-24-hoursformat/65439792#65439792
Paginación:
•
https://stackoverflow.com/questions/68452939/pure-javascript-table-rowpagination/68453319#68453319
Diseño de tablas con css:
•
https://dev.to/dcodeyt/creating-beautiful-html-tables-with-css-428l
48
Descargar