Repository navigation
Aplicación IoT
Un ESP32 es un conjunto de chips de baja gama que pueden ser utilizados como sistemas individuales o como componentes en la realización de proyectos sencillos. Puede ser considerado como un System on a Chip debido a que posee todos los elementos necesarios para acercarse al concepto de un computador. Al tener la capacidad de utilizar WiFi y Bluetooth, es en nuestro caso personal una muy buena opción para el desarrollo del proyecto final para la transmisión de datos. De la misma manera, es un sucesor del modelo ESP8266, placa ampliamente utilizada, lo que supone que mantendrá una buena compatibilidad con los sistemas utilizados para la realización del proyecto, como Arduino.
Como primer entorno de desarrollo integrado se encuentra Arduino, con el que se buscaba transmitir un _ a la base de datos de Firebase. Para ello, se hizo uso de un ESP32, desarrollado por Unit Electronics, que sería conectado a un puerto USB de la computadora. A continuación se elistan los pasos realizados para llevar a cabo este proceso.
Para subir una aplicación (o código de transferencia de datos en nuestro caso) se requería primero de instalar Arduino IDE. Para ello, nos dirigimos a la página oficial de Arduino en su apartado de software, y descargamos el instalador correspondiente a nuestro sistema operativo, en este caso Windows 10. En este apartado, se pregunta además si deseamos donar para la contribución de Arduino.
Se descomprime el archivo .zip y se ejecuta el archivo .exe sin modificar los parámetros de instalación predeterminados. Se da clic en el botón de "Siguiente" en cada paso, hasta llegar la finalización de la instalación. Una vez terminada esta, se ejecuta el programa de Arduino IDE.
Una vez dentro de la aplicación de Arduino IDE, nos dirigimos a la pestaña de Preferencias. En la casilla "Gestor de URLs Adicionales de Tarjetas", es necesario colocar la dirección URL de la tarjeta ESP32, en nuestro caso la desarrollada por Electronic Units. Por ello, colocamos la siguiente dirección:
Por ello, se va a Archivo -> Preferencias -> Gestor de URLs Tarjetas y se coloca la siguiente dirección:
https://dl.espressif.com/dl/package_esp32_index.json
Una vez realizado este paso, y habiendo dado clic en la opción de "Ok", es posible instalar la tarjeta. Para ello se va a la pestaña de Herramientas -> Placa -> Gestor de tarjetas y aquí se instala la placa "ESP32" por "Espressif Systems".
Para probar que la instalación se haya realizado correctamente, se va a la pestaña de Herramientas -> Placa -> ESP32 Arduino -> DOIT ESP32 DEVKIT V1. Tras esto se conecta la placa mediante un cable USB de tipo C y se selecciona el puerto COM asignado a la placa mediante Herramientas -> Puertos. Esto quiere decir que la placa es reconocida por el sistema.
Una vez instaladas las librerías, se necesitó de un código para transmitir los datos por medio del IoT a la base de datos de Firebase. El código completo puede ser consultado haciendo clic aquí.
A continuación se explica el funcionamiento de este:
Con el comando include se definen las librerías necesarias para el funcionamiento del sistema. Se tienen librerías que ayudan a utilizar WiFi con autenticación WPA2, Firebase, sets y gets, y el sensor DHT11:
#include <WiFi.h>
#include <esp_wpa2.h>
#include <Firebase_ESP_Client.h>
#include <addons/TokenHelper.h>
#include "Arduino.h"
#include "addons/RTDBHelper.h"
#include "DHT.h"
Con el comando define se define el pin del sensor de temperatura y humedad y se especifica el tipo, DHT11. Se definen también los pines del sensor de fuerza y de luz:
#define DHTPIN 4
#define DHTTYPE DHT11 // DHT 11
#define LIGHT_SENSOR_PIN 36 // ESP32 pin GIOP36 (ADC0)
#define FORCE_SENSOR_PIN 39 // ESP32 pin GIOP39 (ADC0)
Se define la red WiFi que se utilizará para acceder, así como los datos de inicio de sesión tanto en la red WiFi como en FireBase respectivamente:
const char* ssid = "Tec";
#define EAP_IDENTITY "a01234567@tec.mx"
#define EAP_PASSWORD "contraseña"
#define USER_EMAIL "a01234567@tec.mx"
#define USER_PASSWORD "contraseña"
En esta sección del código se define la API del proyecto, la dirección de la base de datos y se autentifica el usuario en Firebase:
// Llave API del Firebase
#define API_KEY "AIzaSyCkZtABLrWDkAvyqf8IRr5s3kIwp724vXo"//AIzaSyCush_8W74MW4SfN3NgmAFBr7GGDfwnjkA
// RTDB URLefine the RTDB URL
#define DATABASE_URL "https://corintios-5023e-default-rtdb.firebaseio.com"
// Definimos un objeto de datos Firebase
FirebaseData fbdo;
// Declaramos el autor para subir elementos en la base de datos
FirebaseAuth auth;
// Declaramos las configuraciones para subir elementos a la base de datos
FirebaseConfig config;
A continuación se declaran las variables utilizadas para almacenar los datos particulares, como el control de acceso y tiempos de espera. También se almacenan las variables de los sensores o salidas digitales del ESP32:
unsigned long sendDataPrevMillis = 0;
int intValue;
float floatValue;
String stringValue;
const int PIN_TO_SENSOR = 19; // Pin GIOP19 conectado a la salida del pin del sensor
int pinStateCurrent = LOW; // Estado actual del pin
int pinStatePrevious = LOW; // Estado previo del pin
bool signupOK = false;
int count = 0;
DHT dht(DHTPIN, DHTTYPE);
Se declaran los arreglos de los LEDs que permiten formar los dígitos en el cátodo.
int LEDs[] = {22,23,1,3,19,18,5}; // for ESP32 microcontroller
int zero[] = {0, 1, 1, 1, 1, 1, 1}; // cero
int one[] = {0, 0, 0, 0, 1, 1, 0}; // uno
int two[] = {1, 0, 1, 1, 0, 1, 1}; // dos
int three[] = {1, 0, 0, 1, 1, 1, 1}; // tres
int four[] = {1, 1, 0, 0, 1, 1, 0}; // cuatro
int five[] = {1, 1, 0, 1, 1, 0, 1}; // cinco
int six[] = {1, 1, 1, 1, 1, 0, 1}; // seis
int seven[] = {1, 0, 0, 0, 1, 1, 1}; // siete
int eight[] = {1, 1, 1, 1, 1, 1, 1}; // ocho
int nine[] = {1, 1, 0, 1, 1, 1, 1}; // nueve
int line[] = {1, 0, 0, 0, 0, 0, 0}; // nueve
Si se tiene el siguiente diagrama para el cátodo:
El orden en que se brindan las instrucciones es:
g, f, e, d, a, b, c
En la sección void setup() se configuran las instrucciones iniciales ejecutadas al iniciar el programa, las cuales se ejecutan una sola vez. A continuación se explican los segmentos de este:
Se declara la velocidad de transmisión de datos en bits en el puerto serial, tras lo cual se imprime una línea de prueba y se configura el pin del ESP32 para que este lea el valor del sensor.
Serial.begin(115200);
delay(1);
Serial.println(F("DHTxx test!"));
pinMode(PIN_TO_SENSOR, INPUT); // Configurar el pin del ESP32 para que este lea el valor del OUTPUT del sensor
Se inicia el DHT11 y se imprime el valor SSID de la red.
dht.begin();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
Se inicia sesión al protocolo WPA2 con los valores de la identidad del protocolo EAP
// WPA2 enterprise magic starts here
WiFi.disconnect(true);
WiFi.mode(WIFI_STA); //init wifi mode
Serial.print("MAC >> ");
Serial.println(WiFi.macAddress());
Serial.printf("Connecting to WiFi: %s ", ssid);
esp_wifi_sta_wpa2_ent_set_identity((uint8_t *)EAP_IDENTITY, strlen(EAP_IDENTITY));
esp_wifi_sta_wpa2_ent_set_username((uint8_t *)EAP_IDENTITY, strlen(EAP_IDENTITY));
esp_wifi_sta_wpa2_ent_set_password((uint8_t *)EAP_PASSWORD, strlen(EAP_PASSWORD));
esp_wifi_sta_wpa2_ent_enable();
Se conecta el sistema a la red WiFi configurada. Mientras la red no se pueda conectar, se mostrará una "pantalla" de carga.
WiFi.begin(ssid);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
Se asignan los valores de la llave API y la base de datos de Firebase, con los cuales se inicia sesión.
// Asignar la API key
config.api_key = API_KEY;
// Asignar la URL RTDB (Real Time Database)
config.database_url = DATABASE_URL;
//Iniciar sesión
if (Firebase.signUp(&config, &auth, "", "")){
Serial.println("ok");
signupOK = true;
}
else{
Serial.printf("%s\n", config.signer.signupError.message.c_str());
}
// Asignar la función de devolución para la tarea prolongada de generación de tokens
config.token_status_callback = tokenStatusCallback; //see addons/TokenHelper.h
//Ingresar a la base de datos
Firebase.begin(&config, &auth);
Firebase.reconnectWiFi(true);
//Impresión inicial de los números del 1 al 7 en el LED
for (int i = 0; i<7; i++) pinMode(LEDs[i], OUTPUT);
La sección de void loop(), por su parte, es la encargada de señalar las instrucciones que se repetirán indefinidamente. A continuación se explica esta:
Se declaran los estados actual y nuevo del PIN
pinStatePrevious = pinStateCurrent; // Leer el estado anterior
pinStateCurrent = digitalRead(PIN_TO_SENSOR); // Leer el estado actual
Se declaran las variables de lectura de los sensores.
int analogValue = analogRead(LIGHT_SENSOR_PIN);
int analogReading = analogRead(FORCE_SENSOR_PIN);
// Leer la humedad y la temperatura en Celsius (default) y en Fahrenheit
float h = dht.readHumidity();
float t = dht.readTemperature();
float f = dht.readTemperature(true);
Cálculo del índice de calor en grados Fahrenheit (default) y Celsius.
float hif = dht.computeHeatIndex(f, h);
float hic = dht.computeHeatIndex(t, h, false);
En el resto del código se escriben los ciclos necesarios para que se envíen los datos de los sensores a la base de datos. De la misma forma, se crean los ciclos necesarios para que se imprima el o los errores específicos si alguno de los envíos falla.
if (Firebase.ready() && signupOK && (millis() - sendDataPrevMillis > 1 || sendDataPrevMillis == 0)) {
sendDataPrevMillis = millis();
// Write an Int number on the database path test/int
if (Firebase.RTDB.setInt(&fbdo, "app_inventor/Luz", analogValue)){
Serial.println("PASSED");
Serial.println("PATH: " + fbdo.dataPath());
Serial.println("TYPE: " + fbdo.dataType());
}
else {
Serial.println("FAILED");
Serial.println("REASON: " + fbdo.errorReason());
}
//count++;
if (Firebase.RTDB.setFloat(&fbdo, "app_inventor/Humedad", h)){
Serial.println("PASSED");
Serial.println("PATH: " + fbdo.dataPath());
Serial.println("TYPE: " + fbdo.dataType());
}
else {
Serial.println("FAILED");
Serial.println("REASON: " + fbdo.errorReason());
}
// Write an Float number on the database path test/float
if (Firebase.RTDB.setFloat(&fbdo, "app_inventor/Temperatura",hic )){
Serial.println("PASSED");
Serial.println("PATH: " + fbdo.dataPath());
Serial.println("TYPE: " + fbdo.dataType());
}
else {
Serial.println("FAILED");
Serial.println("REASON: " + fbdo.errorReason());
}
// Write an Int number on the database path test/int
if (Firebase.RTDB.setInt(&fbdo, "app_inventor/Fuerza", analogReading)){
Serial.println("PASSED");
Serial.println("PATH: " + fbdo.dataPath());
Serial.println("TYPE: " + fbdo.dataType());
//delay(10);
//Firebase.RTDB.setInt(&fbdo, "ti/mov", pinStateP);
}
else {
Serial.println("FAILED");
Serial.println("REASON: " + fbdo.errorReason());
}
// Write an Int number on the database path test/int
if (Firebase.RTDB.setInt(&fbdo, "app_inventor/Movimiento", pinStateCurrent)){
Serial.println("PASSED");
Serial.println("PATH: " + fbdo.dataPath());
Serial.println("TYPE: " + fbdo.dataType());
delay(5000);{
Firebase.RTDB.setInt(&fbdo, "app_inventor/Movimiento", 0);
}
}
else {
Serial.println("FAILED");
Serial.println("REASON: " + fbdo.errorReason());
}
En el caso de la última variable, el número, esta se obtiene de la aplicación de AppInventor por medio de la base de datos, y se imprime en el cátodo común de 7 segmentos de acuerdo con las combinaciones de segmentos equivalentes a los números. Si el número es mayor a 9, se imprime un guión (-).
if (Firebase.RTDB.getString(&fbdo, "app_inventor/Numero")){
if (fbdo.dataType() == "string"){
stringValue = fbdo.stringData();
int n = stringValue.toInt();
if (n == 0){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], zero[i]);}
if (n == 1){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], one[i]);}
if (n == 2){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], two[i]);}
if (n == 3){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], three[i]);}
if (n == 4){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], four[i]);}
if (n == 5){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], five[i]);}
if (n == 6){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], six[i]);}
if (n == 7){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], seven[i]);}
if (n == 8){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], eight[i]);}
if (n == 9){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], nine[i]);}
if (n > 9){
for (int i = 0; i<7; i++) digitalWrite(LEDs[i], line[i]);}
Como notas finales del código:
- Es importante que las variables utilizadas no tengan un acento, puesto que, en caso de tenerlo, puede interferir en el funcionamiento del código, llegando a impedir la impresión (en el cátodo de 7 segmentos) de la variable ingresada en la aplicación de AppInventor, por ejemplo.
- Es necesario tomar en cuenta las especificaciones de la red WiFi a la que nos deseemos conectar al momento de establecer los datos de inicio de sesión.
Para la lectura de datos, se utiliza un ESP32 en conjunto con los sensores correspondientes. Para la lectura de los sensores se hizo uso de la aplicación de Arduino IDE, la cual nos permite conectar los sensores al ESP32 utilizado en las pruebas anteriores para el envío de datos. A continuación se listan los sensores utilizados para este proyecto:
Este sensor permite medir los parámetros de temperatura y humedad presentes en el ambiente. Referente a la temperatura, es posible encontrar un valor de lectura en grados C° y F°. En base a estos valores, es posible realizar distintos cálculos como el índice de calor.
El objetivo de este sensor es, como su nombre lo indica, sentir la fuerza aplicada a una membrana la cual cambia su resistencia interna y su presión. Puede medir así una fuerza proporcional a la presión aplicada sobre este, midiendo una presión de 100KΩ hasta 200Ω.
El sensor de presencia, o pasivo infrarrojo, tiene como objetivo detectar el movimiento mediante una lectura de radiación infrarroja que emiten todos los cuerpos proporcionalmente a su temperatura. De esta forma, es posible medir el movimiento que ocurre frente al sensor si se utilizan dos medidores infrarrojos y cada uno arroja señales distintas.
El sensor de luminosidad, o foto-resistor, se encarga de medir la cantidad de luz que recibe y transformar este valor en el de su resistencia eléctrica, lo que permite medir la iluminación que existe en un ambiente. En conjunto con el uso de resistencias, este sensor es de suma utilidad para modificar parámetros o simplemente medir la luminosidad en ambientes controlados o naturales.
Para comprobar el funcionamiento de los sensores, fue importante llevar a cabo una conexión con la cual el ESP32 pudiera comunicarse con cada uno de los sensores.
Las conexiones utilizadas se presentan a continuación:
Antes de ensamblar una versión que incluyese todos los componentes, fue necesario experimentar con códigos y conexiones individuales para asegurarse de que estos funcionasen de forma correcta. A continuación se señalan estas conexiones realizadas:
- DHT11
- Sensor de Fotoresistencia
- Sensor de Movimiento
- Sensor de Fuerza
- Display de 7 segmentos
Una vez realizadas estas conexiones individuales, fue posible generar una versión final la cual tuviera todos estos mecanismos integrados. Este es el resultado:

Como aclaraciones finales de las conexiones:
- Se ajusto el tiempo de disparo y la distancia del sensor PIR (Motion sensor) en 3 segundos y 3 metros.
- El sensor de temperatura y humedad cuenta con 3 pinouts en lugar de 4, se siguió la imagen de a continuación para cambiar las conexiones del circuito.
- Los sensores de fuerza y fotoresistencia fueron conectados a convertidores analogicos individuales arrojando lecturas diferentes y no compartidas (errores de los primeros diseños de las conexiones)
- Los cambios en los pinouts también se aplicaron en los respectivos códigos
Tal y como se puede apreciar, en este sistema se logran colocar todos los sensores necesarios. De la misma forma, utilizamos cables macho-hembra, macho-macho y hembra-hembra para llevar a cabo las conexiones. La colocación de los sensores es igualmente importante, pues en conjunto con el código, de esta depende el resultado.
Python es un lenguaje de programación de alto nivel creado en 1991. Es conocido por su facilidad de desarrollo gracias a su sintaxis, gran biblioteca de códigos. Es modular, de código abierto y es utilizado en múltiples áreas de desarrollo, como análisis de datos, inteligencia artificial, desarrollo web, gráficos, videojuegos, etc. Puede también ser utilizado para el envío y lectura de datos por medio de bases de datos.
En esta ocasión, utilizamos los códigos de Python para hacer lo siguiente:
- Leer la información mandada a la base de datos, más en específico la que corresponde el campo "Número"
- Evaluar dicho dato y ver si, este, es mayor a 9
- En caso de ser mayor, el código deberá ser capaz de modificar el campo "Usuario" a "Elemento mayor a 9"
Antes de siquiera poder pensar en leer y enviar información, lo primero es crear un código que nos permita acceder a la base de datos. El código completo puede ser encontrado aquí. A continuación se explica el uso de las piezas de código:
Se importó la librería "pyrebase", que nos brinda las funcionalidades necesarias para interactuar con la base de datos en Firebase:
import pyrebase
Se agregan todos lo aspectos necesarios para que se acceda a NUESTRA base de datos en Firebase, como apiKey, databaseURL, etc:.
config = {
"apiKey": "AIzaSyCkZtABLrWDkAvyqf8IRr5s3kIwp724vXo",
"authDomain": "corintios-5023e.firebaseapp.com",
"databaseURL": "https://corintios-5023e-default-rtdb.firebaseio.com/",
"projectId": "corintios-5023e",
"storageBucket": "corintios-5023e.appspot.com",
"messagingSenderId": "65486733713",
"appId": "1:65486733713:web:cbe0776a0cf8fadefbda30",
"measurementId": "G-SBB7DD27KG"
}
Se inicializa el acceso a nuestra base de datos:
firebase = pyrebase.initialize_app(config)
#accesing database in firebase
db = firebase.database()
Ya habiendo accedido a la base de datos toca leer los datos que nos conciernen; para esto, se utilizaron las siguientes piezas de código:
Se crea una variable llamada "all_users" que almacena todos los campos almacenados en la sección "app_inventor" de nuestra base de datos:
all_users = db.child("app_inventor").get()
Se crea un ciclo para leer cada dato guardado en "all_users" y lo almacena en "users"; cabe mencionar que, el contador, se hizo para poder asegurar que, el ultimo dato leído, sea el correspondiente al campo "Número" para, así, asegurar que se trabaja con lo que nos concierne:
i = 0
for users in all_users.each():
if (i == 4):
break
print(users.val())
i = i + 1
El valor guardado en "users", que es un string, se convierte en un int para que se pueda trabajar con él:
num = int(users.val())
print("Valor de Número: ")
print(num)
Ya teniendo almacenado el valor que nos importa, solo falta analizarlo y, si es el caso, modificar la base de datos; para esto, se utilizaron la siguiente pieza de código:
Se hace un condicional que checa si, "num" es mayor a 9; si sí, se accede al campo usuario y se modifica su contenido al texto "Elemento mayor a 9"; si no, no modifica nada en la base de datos:
if (num > 9):
db.child("app_inventor").update({"Usuario":"Elemento mayor a 9"})
print("Actualizado")
else:
print("No Actualizado")