Prevención del molde con la envidia AZ - Parte 2

La siguiente publicación del blog nos fue enviada por el autor invitado, Niklas Heinzel. Diviértase leyendo y experimentando:

La segunda parte de esta serie de blogs se trata del uso de la placa de desarrollo ambiental AZ-Envy para la prevención temprana del moho en los espacios habitados. Después de conocer en la Parte 1 los factores de construcción en los que es más probable que se produzca el crecimiento del moho, ahora revisamos los aspectos técnicos del problema, o cómo implementarlo con la placa de Desarrollo AZ-Envy.

De la Parte 1 hemos tomado los siguientes principios básicos, que ahora se deben considerar en la aplicación técnica:

"En la discusión técnica se debe intentar medir la Temperatura del aire de la habitación, la Humedad relativa (<65%) y la Temperatura del punto de rocío (<temperatura del aire de la habitación). Estos valores se deben evaluar y almacenar automáticamente".

Además de la interconexión correcta de todos los componentes de hardware, el proyecto requiere un algoritmo adecuado que compruebe los tres valores mencionados anteriormente a través de los sensores. Para escribir el algoritmo apropiado, utilicé el software de código abierto Arduino IDE, con adaptación para el microcontrolador ESP12-F de la familia ESP8266 utilizado.

La ventaja de este entorno de desarrollo es la sencilla integración de bibliotecas, que sirven para simplificar los comandos y la hacerlos más prácticos. Estas bibliotecas están disponibles para una amplia variedad de sensores y otros componentes. También, ofrecen una gran variedad de ejemplos de programación para aprender el lenguaje de programación C++ o C. Por lo tanto, he evitado deliberadamente el uso de otros entornos de desarrollo que normalmente utilizo yo mismo, para evitar dificultades innecesarias a la hora de cargar o debido a la sintaxis.

Como de habitual en casi todos los lenguajes de programación, primero se integran las librerías. En mi caso, se trata de librerías para facilitar la lectura de los valores del sensor de los sensores SHT30 y las librerías que permiten construir al microcontrolador ESP12-F construir su propio sitio web.

Después de inicializar todos los sensores, se procede a conectar a la red local a través de WLAN con los datos de acceso almacenados en la memoria interna. Si no se dispone de datos de acceso, por ejemplo, cuando el usuario inicia el sistema por primera vez, se crea un sitio web con información sobre el dispositivo y una página de acceso. Allí se introduce el nombre de la WLAN (SSID) y la contraseña de la WLAN. Estos datos se almacenan en la memoria interna, la EEPROM y se conservan incluso después de desconectar la fuente de alimentación del dispositivo. UNA EEPROM es lo que se conoce una Electrically Erasable Programmable Rread-only Memory, es decir, una memoria programable y borrable eléctricamente que está reservada exclusivamente para el proceso de lectura y que se puede programar o eliminar por diferencias de voltaje. La capacidad de almacenamiento permanente y la capacidad de modificar la memoria son ideales para mantener las credenciales seguras.

Una vez que el usuario ha introducido los datos, éstos quedan almacenados de forma permanente y no es necesario otro proceso de inicio de sesión después de un reinicio corto. El microcontrolador se conecta a través de la red doméstica a la base de datos de Firebase de Google, una solución gratuita para almacenar pequeños conjuntos de datos. Para esto, solo se debe crear una cuenta y se pueden enviar los datos a través de la API vinculada. Una API es una interfaz de programación que recibe datos de usuarios o dispositivos y los transmite para el propósito específico de la aplicación, según una sintaxis predeterminada. La clave única de la API utilizada para la autenticación, también se almacena en la EEPROM y está vinculada a la cuenta. Después de establecer la conexión con la base de datos Firebase, se leen los sensores SHT30 y MQ-2. A continuación, estos datos se redondean a dos decimales y se cargan en la base de datos. Este almacenamiento central en una base de datos permite recuperar los datos en cualquier momento, incluso cuando se está fuera de la red doméstica, de vacaciones o a través de la red móvil.

Para que la recuperación y evaluación de los datos sea fácil de usar para el usuario, he programado una aplicación de Android para este propósito con el entorno de desarrollo Android Studio.

Dado que la aplicación no tiene una inferfaz de usuario con la que sería posible cambiar la clave de la API, etc., esto sólo pretende proporcionar una idea para el desarrollo de una aplicación propia.

Esto permite la descarga automática de los datos actuales del sistema de alerta de moho con un retraso de unos pocos segundos, así como la evaluación completa de los datos. La humedad del aire (izquierda), la calidad del aire interior (derecha), y el peligro general del moho (arriba) se presentan de forma clara y sencilla. La corona que rodea los valores cambia de color de verde a rojo en función del potencial riesgo y muestra de nuevo, por ejemplo, en el caso de la humedad relativa, el valor de 0 a 100%.

Para poder reaccionar de manera rápida y eficaz sin necesidad de conocimientos especializados, se ha integrado debajo de los valores un botón animado que se actualiza constantemente. Dependiendo de la situación de peligro, este botón muestra una marca verde o una cruz roja para aclarar rápidamente el peligro al usuario.

Al hacer clic en el botón, se proponen medidas como la ventilación, la calefacción u otras medidas técnicas de construcción en función de los parámetros de riesgo. Con el uso de una barra de navegación en el campo de visión inferior, el usuario de la aplicación también puede cambiar entre la página de inicio, una página de contacto y una página de material de información adicional.

La aplicación es, por lo tanto, una solución todo en uno para la prevención del moho basada en IoT que presenta y evalúa de forma inteligente los valores medidos desde la placa de forma sencilla.

Aquí he ilustrado todo en forma de diagrama de flujo:

Por lo tanto, también es posible que el usuario sin conocimientos previos, pueda prevenir eficazmente la mayoría de los factores que conducen a la formación de moho observando las medidas sugeridas por la aplicación.

Dado que varias veces la interferencia de temperatura entre el sensor de gas calentado y el sensor de temperatura se señalaron:

Desafortunadamente, en la versión actual de AZ-Envy, este es un problema conocido que se puede contener creando valores de compensación para corregir artificialmente la temperatura hacia abajo o mediante cambios estructurales. Esto implica una carcasa de impresión 3D con una pared entre los dos sensores o, alternativamente, el sensor de gas se puede soldar y colocar más lejos mediante un cable.

¡Dado que ahora se han aclarado todos los detalles, encontrará aquí el código para el Arduino IDE, que también le servirá con algunos ajustes (SSID, contraseña, clave API)!

En primer lugar, aquí está el cableado para la carga una vez más:

 
Sigue el sketch para el Arduino IDE:

 // Azenvy
 // © niklas heinzel
 //2021
 //Ver.3.1
 ​
 // - Libarios - //
 #include  // i2c biblioteca
 #include  // sht30 libary
 #include  // ESP8266 WI-FI LIBARY
 #include  // DNS Server Lary
 #include  // Servidor Libary
 #include  // WiFi Manager Libary
 #include  // MATHE-LIBARY
 #inClude "Firebaseesp8266.H"
 ​
 Sht3x Sht30(0x44);
 ​
 #Define Firebase_Host "Inserte el enlace aquí" // enlace a la base de datos en tiempo real de Firebase
 #Define Firebase_Auth "Inserte el código secreto aquí" // Código secreto para leer y escribir a la nube.
 Firebasedata Firebasedata;
 ​
 contaminar En t analoginpin = A0;  // ADC PIN de la ESP-12F
 En t SensorValue = 0;  // Valor entero para PIN de ADC (leyendo el sensor de gas)
 Cuerda Ssid = "Azenvy"; // ssid del portal de configuración
 contaminar Char * clave = "Azenvy"; // contraseña de la red de la ESP12
 ​
 Cuerda Enrutador_ssid; // enrutador de cadena SSID
 Cuerda Enrutador; // Contraseña de enrutador de cadena
 ​
 ​
 // Función para mostrar el estado de la conexión
 vacío HeartBeatPrint(vacío)
 {
   estático En t entumecido = 1;
 ​
   SI (Wifi.estado() == Wl_connected){
     De serie.imprimir("Conectado a WLAN".);  // significa conectado a wlan
   }Demás{
     De serie.imprimir("¡No conectado a WLAN!");} // no significa conectado a WLAN
   
   SI (entumecido == 80) 
   {
     De serie.Prender();
     entumecido = 1;
   }
   Demás SI (entumecido++ % 10 == 0) 
   {
     De serie.imprimir(" ");
   }
 } 
 // Función para verificar el estado en el intervalo
 vacío COMPROBAR ESTADO()
 {
   estático ulongón Checkstatus_timeout = 0;
   #define heartbeat_interval 30000l
   // Intervalo de 10 segundos
   SI ((milis() > Checkstatus_timeout) || (Checkstatus_timeout == 0))
   {
     HeartBeatPrint();
     Checkstatus_timeout = milis() + Heartbeat_Interval;
   }
 }
 ​
 vacío configurar() {
 ​
  De serie.Comenzar(115200); // Iniciar conexión en serie con una velocidad de baudios de 115200
  De serie.Prender("------------------------------"); // emitir al monitor en serie
  De serie.Prender("------------ Azenvy ------------"); // emitir al monitor en serie
  De serie.Prender("----- Por Niklas Heinzel -------"); // emitir al monitor en serie
  De serie.Prender("------------------------------"); // emitir al monitor en serie
  
  // - WiFi Manager - //
  no firmado largo fecha de inicio = milis();
  
   Esp_wifimanager Esp_wifimanager; // Intitryization of the WiFi Manager
 ​
   Enrutador_ssid = Esp_wifimanager.Wifi_sid(); // Variable para guardar en la EEPROM
   Enrutador = Esp_wifimanager.Wifi_pass(); // Variable para guardar en la EEPROM
   
   De serie.Prender("¡Abra el portal de configuración de la WLAN!"); // emitir al monitor en serie
   De serie.Prender("------------------------------");
   
   SI (Enrutador_ssid != "")
   {
     Esp_wifimanager.setconfigportaltimaltimeut(10); // Tiempo de espera del portal de configuración
     De serie.Prender("Tiempo de espera: 10 segundos"); // emitir al monitor en serie
   }
   Demás{
     De serie.Prender("¡No hay tiempo de espera!");} // emitir al monitor en serie
     De serie.Prender("---------------------------");
 ​
   SI(!Esp_wifimanager.Startconfigportal((contaminar Carbonizarse *) Ssid.C_str(), clave)){ // Inicie el portal de configuración y espere la entrada del usuario
     De serie.Prender("No se puede conectar a la red".); // emitir al monitor en serie
     De serie.Prender("---------------------------");}
   Demás{ 
     De serie.Prender("¿Conectado a WLAN!"); // emitir al monitor en serie
     De serie.Prender("---------------------------");}
 ​
   // constante //
   #define wifi_connect_timeut 10000l
   #define whilere_loop_delay 200l
   #define wehene_loop_steps (wifi_connect_timeout / (3 * while_loop_delay))
   
   fecha de inicio = milis();
   
   Tiempo ( (Wifi.estado() != Wl_connected) && (milis() - fecha de inicio < Wifi_connect_timeout ) )
   {   
     En t I = 0;
     Tiempo((!Wifi.estado() || Wifi.estado() >= Wl_disconnectected) && I++ < While_loop_steps)
     {
       demora(While_loop_delay);
     }    
   }
 ​
   De serie.imprimir((milis()- fecha de inicio) / 1000); // emitir al monitor en serie
   De serie.imprimir("El estado de la conexión es"); // emitir al monitor en serie
 ​
   SI (Wifi.estado() == Wl_connected) // si está conectado, pasa algo
   {
     De serie.imprimir("Conectado, dirección IP local:"); // emitir al monitor en serie
     De serie.Prender(Wifi.Localizar()); // Salir al monitor en serie de la IP
   }
   Demás{
     De serie.Prender(Esp_wifimanager.consiguiendo(Wifi.estado()));} // Salir al monitor en serie del estado
 ​
   // - Firebase - //
   Barbase.Comenzar(Firebase_HOST, Firebase_Auth); // Conectar con la nube debajo de la información de inicio de sesión declarada
 ​
   mono(SensorValue,Aporte); // Establecer PIN de ADC para ingresar 
   mono(2,PRODUCCIÓN); // Place integrado LED en la salida
 ​
 }
 ​
 ​
 vacío lazo() {
 ​
  COMPROBAR ESTADO(); // Función al marcador de estado
 ​
  flotador Firebasemp = Redonda((Sht30.Ctemp) * 100) / 100;
  flotador Firebasehum = Redonda((Sht30.humedad) * 100) / 100;
 ​
  // - sht30 - //
    SI(Sht30.obtener()==0){
     De serie.imprimir("Inn Temperature =");
     De serie.Prender(Sht30.Ctemp);
     De serie.imprimir("Humedad =");
     De serie.Prender(Sht30.humedad);
     De serie.Prender();
     escritura digital(2,ELEVADO); // Apague el LED integrado
   }
   Demás
   {
     De serie.Prender("¡Error al leer el sht30!");
   }
 ​
 ​
  // - MQ-2 - //
   De serie.Prender("----------------------------------------------"); // emitir al monitor en serie
   SensorValue = análoga(analoginpin); // leyendo el PIN de ADC (convertidor analógico-digital) de MQ-2
   De serie.imprimir("Valor de Gassensor:"); // emitir en el monitor en serie
   De serie.Prender(SensorValue); // Salida del valor analógico en el monitor en serie
   De serie.Prender("----------------------------------------------"); // emitir al monitor en serie
 ​
  SI(Barbase.gimnasio(Firebasedata, "Molde-preventivo / temperatura", Firebasemp)){
      De serie.Prender("¡Cargue los datos con éxito!");
   }Demás{
     De serie.imprimir("Error al subir:");
     De serie.Prender(Firebasedata.Errado());
   }
   
   SI(Barbase.gimnasio(Firebasedata, "Molde, preventivo / humedad", Firebasehum)){
      De serie.Prender("¡Cargue los datos con éxito!");
   }Demás{
     De serie.imprimir("Error al subir:");
     De serie.Prender(Firebasedata.Errado());
   }
   
  SI(Barbase.gimnasio(Firebasedata, "Molde, preventivo / gas", SensorValue)){
      De serie.Prender("¡Cargue los datos con éxito!");
   }Demás{
     De serie.imprimir("Error al subir:");
     De serie.Prender(Firebasedata.Errado());
   }
 ​
 ​
  demora(5000);
 ​
 }

Puedes descargar el sketch aquí.

Después de cargar del sketch por primera vez, use un teléfono móvil, para conectarse a la red WLAN de AZ-Envy, e ingrese un sitio web de inicio de sesión. Allí se selecciona la red deseada a la que la placa se debe conectar siempre después de la configuración y después de un reinicio los datos serán enviados.

Para crear una base de datos correspondiente, solo es necesario crear una base de datos en tiempo real en https://firebase.google.com. En la configuración, también encontrará el código secreto con el que la placa puede acceder a la base de datos. Una posible disposición es la siguiente aquí (en consecuencia, el código de Arduino también se debe cambiar si el nombre es diferente):

A partir de este punto, puede usar los datos para muchas aplicaciones, por ejemplo, leer aplicaciones de Android, mostrar una pantalla, etc.

¡Así que le deseo mucha diversión con la placa de Desarrollo AZ-Envy y ya estoy muy emocionado por ver qué nuevos proyectos se basarán en él!

Niklas heinzel