Monitor de planta para el alféizar de la ventana Parte 4 - Medición de temperatura y humedad

Hola y bienvenidos a otra parte de la serie de observadores de plantas.

Hoy vamos a donar un sensor ambiental 2 en 1 al monitor de la planta, así como implementar algunas optimizaciones del hardware (LED), así como el código. El sensor que conectamos en esta parte es el conocido sensor de temperatura y humedad DHT 22. Además de la humedad del suelo, nuestro monitor de planta ahora será capaz de registrar los parámetros ambientales de temperatura y humedad, que son importantes para las plantas en su entorno. Por supuesto, también ampliaremos nuestra aplicación móvil adecuadamente. En primer lugar, realizamos un cambio en el cambio de los LED.

Utilizamos el módulo KY-016 LED RGB y lo conectamos directamente de la siguiente manera:
Rojo en el pin 0, verde en el pin 15, y azul en el pin.

Las ventajas de este módulo son, por un lado, ahorramos espacio cuando se instala en una carcasa (1/3 del espacio de la vivienda), pero también tenemos el espectro completo RGB de colores a través del control PWM de los canales individuales, por lo que más de originalmente sólo se pueden mostrar 3 estados.
(Por ejemplo, el LED ahora se ilumina en blanco durante la fase de inicialización). Por último, pero no menos importante, nos ahorramos las resistencias, ya que ya están integradas en el módulo. Los pines a los que están conectados los LED RGB al ESP32 se han seleccionado según el criterio "adecuado para cronometrar hardware no crítico". El fondo es que los pines a los que está conectado el LED, el firmware vibran condicionalmente durante un reinicio del sistema (PWM) antes de que se inicialicen y, por lo tanto, no son adecuados para cronometrar hardware crítico (como el DHT22).

También ha habido un cambio en la forma en que funciona la pantalla LED y cómo se muestra: ya que sólo tenemos uno y no seis LED RGB para mostrar las estadísticas del guardián, tenemos que resumir la información más importante sobre ella.

Para ello, utilizamos la siguiente consideración: Para nosotros, la información más importante es si una de las 6 plantas como máximo debe ser regada o no. Esto significa que esto debería ser evidente de un vistazo. Para ello, redefinimos el color verde (humedad suficiente) para que TODAS las 6 plantas tengan suficiente humedad para obtener una pantalla "verde". Así que si uno de los seis sensores detecta menos del 50% de humedad del suelo, nuestra pantalla salta a "amarillo". A menos del 10% en "rojo". Así que sabemos que debemos comenzar nuestra APP de alcaide de plantas para averiguar cuál de las seis plantas debe ser regada. Dado que el sensor de temperatura y humedad DHT 22 es compatible con 3,3 V pin y lógica, lo conectamos directamente al puerto 4 de los ESP. Aquí puede ver la conexión completa:

La lista de piezas actual con las piezas de hardware necesarias. (Con enlace de referencia)

En lugar del primer sensor DHT 22 listado, el sensor DHT 11 más barato se puede utilizar simplemente ajustando la línea "DHTTYPE DHT22". Sin embargo, el DHT 11 no es tan preciso como el DHT 22.

Aquí las diferencias entre los dos sensores también se pueden leer de nuevo.

Si se va a utilizar el DHT 11 Senor, la línea debe

#define DHTTYPE DHT22

En

#define DHTTYPE DHT11

ser cambiado. No se pueden realizar más cambios.

LA asignación de pines ESP32 es la siguiente

Estos ya eran los cambios de hardware necesarios. Para utilizar el sensor DHT22/DHT 11 con su protocolo de alambre patentado en nuestro boceto, necesitamos incluir dos bibliotecas más en nuestro IDE a continuación.

Por un lado, este es el más popular "Adafruit Unified Sensor Libary" : así como el Biblioteca de sensores DHT. Ambas bibliotecas se basan entre sí y deben agregarse a nuestras bibliotecas IDE según las necesite según nuestro proyecto.

Después de agregar las bibliotecas y ajustar los parámetros en el código, como en el Parte 3 en esta serie, descrita cargamos el siguiente código a nuestro ESP:

#include <Conductor/Adc.H>
#include <Wifi.H>
#include <WiFiClient.H>
#include <BlynkSimpleEsp32.H>
#include "EEPROM.h"
#include <Preferencias.H>
#include "DHT.h"    REQUIERE las siguientes bibliotecas Arduino:
- Biblioteca de sensores DHT: https://github.com/adafruit/DHT-sensor-library
- Adafruit Sensor Unificado Lib: https://github.com/adafruit/Adafruit_Sensor

Módulo LED RGP edefinición de puerto
#define LED_Rot     0     LED rojo 
#define LED_Blau    14    LED azul
#define LED_Gruen   15    Gruene LED

Ajustes de LED PWM
#define PWMfreq 5000  Frecuencia base de 5 Khz para la pantalla LED
#define PWMledChannelA  0
#define PWMledChannelB  1
#define PWMledChannelC  2
#define Resolución PWM  8 Resolución de 8 bits para LED PWM

Otras definiciones
#define ADCAttenuation ADC_ATTEN_DB_11    ADC_ATTEN_DB_11 ADC de atenuación de 0-3.6V (extensión ADC
#define MoisureSens_Poll_Interval 300000   Intervalo entre dos mediciones de humedad del suelo en milisegundos -> enviar paquete de datos al teléfono móvil cada 5 minutos
#define DHT_Poll_Interval 400000           Intervalo entre dos mediciones temeperature y de aire-fractario en milisegundos -> enviar paquete de datos al teléfono móvil cada 6 minutos
#define MaxSensors 6                      Número máximo de sensores de humedad conectables
#define StartInit Verdad
#define Ejecución Falso
#define Sens_Calib Verdad
#define Sens_NOTCalib Falso
#define EEPROM_SIZE 512                  Tamaño del EEPROMS Interno

Definiciones de Blynk APP
#define BLYNK_GREEN     "#23C48E"
#define BLYNK_BLUE      "#04C0F8"
#define BLYNK_YELLOW    "#ED9D00"
#define BLYNK_RED       "#D3435C"
#define BLYNK_BLACK     "#000000"
#define BLYNK_PRINT Serial
#define BLYNK_NO_BUILTIN
#define BLYNK_NO_FLOAT
#define BLYNK_DEBUG

Configuración de DHT
#define DHTPIN 4     Pin digital conectado al sensor DHT
#define DHTTYPE DHT22   DHT 22 (AM2302), AM2321
#define DHTTYPE DHT21 * DHT 21 (AM2301)

Estructura MoistureSensorCalibrationData
{   Int Datos[MaxSensors * 2] = {1651, 2840, 1652, 2840, 1653, 2840, 1654, 2840, 1655, 2840, 1656, 2840}; Datos de calibración para sensor de humedad. Observe el texto del proyecto y ajuste los valores en consecuencia   int Data[MaxSensors*2] á .0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"  Datos de calibración para sensor de humedad. Observe el texto del proyecto y ajuste los valores en consecuencia   Byte StatusBorderPercentValues[MaxSensors * 2][2] = { {10, 50},     Matriz de dos dimensiones para límites porcentuales (luz de tráfico) individual por sensor de humedad (1 -6)     {10, 50},     {10, 50},     {10, 50},     {10, 50},     {10, 50}   };   Cadena SensorName[MaxSensors + 2] = {"Planta 1", "Planta 2", "Planta 3", "Planta 4", "Planta 5", "Planta 6", "Humedad", "Temperatura"}; Nombre del sensor que también aparece como un encabezado en la APP

};

Estructura MoistureSensorData
{   Int Por ciento[MaxSensors] = {0, 0, 0, 0, 0, 0};  Datos del sensor de humedad en porcentaje   Byte Old_Percent[MaxSensors] = {0, 0, 0, 0, 0, 0}; Anterior _ Datos del sensor de humedad en porcentaje (propósito: Guardar dataCantidad.)   Bool DataValid [MaxSensors] = {Falso, Falso, Falso, Falso, Falso, Falso};
};

Estructura DHTSensorData
{   Flotador Humedad = 0 ;      Porcentaje de datos del sensor de humedad   Flotador Temperatura = 0;   Flotador Old_Humidity = 0 ;      Porcentaje de datos del sensor de humedad   Flotador Old_Temperature = 0;   Bool DataValid  = Falso;   Bool SensorEnabled  = Falso;
};

Dht Dht(DHTPIN, DHTTYPE); DHP Instalz initalisieren


Variables globales


Char Auth[] = "xxxxxxxxxxxxxxxxxxxxxxxxxx"; Anleitung Auth Token dere Blynk App eintragen (Correo electrónico).
Deine WiFi Zugangsdaten.
Char Ssid[] = "Deine_WLAN_SSID";                 Bitte anigene WLAN SSID anpassen
Char Pasar[] = "Dedein _WLAN _Passwort!";           Bitte anigene WLAN Passwort anpassen
MoistureSensorCalibrationData MCalib;
MoistureSensorData MMeasure;
DHTSensorData  DHTMeasure;

Byte AttachedMoistureSensors; Sensores de humedad activos detectados (recuento)
Unsigned Largo Moisure_ServiceCall_Handler = 0;  Variable de retardo para retardo entre lecturas de moisure
Unsigned Largo DHT_ServiceCall_Handler = 0;  Variable de retardo para retardo entre lecturas DHT


Vacío Configuración() {   pinMode(LED_Rot, Salida);   pinMode(LED_Blau, Salida);   pinMode(LED_Gruen, Salida);   Serial.Comenzar(115200);   inicializar la comunicación en serie a 115200 bits por segundo:   ledcSetup(PWMledChannelA, PWMfreq, PWMresolution);   ledcSetup(PWMledChannelB, PWMfreq, PWMresolution);   ledcSetup(PWMledChannelC, PWMfreq, PWMresolution);   ledcAttachPin(LED_Rot, PWMledChannelA);   conectar el canal al GPIO para ser controlado   ledcAttachPin(LED_Blau, PWMledChannelB);   ledcAttachPin(LED_Gruen, PWMledChannelC);   SetLedConfig(255, 255, 255);   Serial.println(F("Systemkonfiguration:"));   Si (!Eeprom.Comenzar(EEPROM_SIZE))   {     Serial.println(F("no se ha podido inicializar EEPROM"));   } Más   { Serial.println(EEPROM_SIZE);     Serial.println(F(" Bytes EEPROM"));   }   AttachedMoistureSensors = DetectMoistureSensors();   Serial.Impresión(AttachedMoistureSensors);   Serial.println(F(" Bodenfeuchtigkeitsensor(es)"));   Dht.Comenzar();   DHTMeasure.SensorEnabled  = Run_DHTSensor (StartInit);   Si (DHTMeasure.SensorEnabled)   {     Serial.println(F("1 Sensor DHT 22"));   }   Serial.Impresión(F("Verbindung zu WLAN"));   Retraso(500);   Blynk.Comenzar(Auth, Ssid, Pasar);  Initalize WiFi-Connection over Blync Library   Serial.println(F(" erfolgreich."));   SetLedConfig(0, 0, 0);   Init_Blynk_APP();   Run_MoistureSensors(StartInit);   Para (Int Ⅰ = AttachedMoistureSensors; Ⅰ < 6; Ⅰ++) {     Update_Blynk_APP(Ⅰ, Sens_Calib);   };
}

Byte DetectMoistureSensors ()
{
#define MinSensorValue 100   Byte Detectado = 0;   Para (Int Ⅰ = 0; Ⅰ < MaxSensors; Ⅰ++)   {     Int MSensorRawValue = ReadMoistureSensor_Raw_Val(Ⅰ);     Si ( MSensorRawValue > MinSensorValue) {       Detectado++;     } Más {       Romper;     }   }   Si (Detectado < 1)   {     Serial.println(F("Keine Bodenfeuchtigkeitssesoren erkannt. Sistema angehalten."));     esp_deep_sleep_start();     Mientras (1) {}   }   devolución Detectado;
}

Bool SetLedConfig(Byte Rojo, Byte Verde, Byte Azul)
{   ledcWrite(PWMledChannelA, Rojo); Rote LED   ledcWrite(PWMledChannelB, Azul); Blaue LED   ledcWrite(PWMledChannelC, Verde); Gruene LED   devolución Verdad;
}

Int ReadMoistureSensor_Raw_Val(Byte Sensor)
{   Int ReturnValue, Ⅰ;   Largo Suma = 0;
#define NUM_READS 6   adc1_config_width(ADC_WIDTH_BIT_12);   Rango 0-4095   Interruptor (Sensor)   {     Caso 0:       {         adc1_config_channel_atten(ADC1_CHANNEL_0, ADCAttenuation);         Para (Ⅰ = 0; Ⅰ < NUM_READS; Ⅰ++) { Algoritmo de promediación           Suma += adc1_get_raw( ADC1_CHANNEL_0 ); Leer analógico         }         ReturnValue = Suma / NUM_READS;         Romper;       }     Caso 1:       {         adc1_config_channel_atten(ADC1_CHANNEL_3, ADCAttenuation);         Para (Ⅰ = 0; Ⅰ < NUM_READS; Ⅰ++) { Algoritmo de promediación           Suma += adc1_get_raw( ADC1_CHANNEL_3 ); Leer analógico         }         ReturnValue = Suma / NUM_READS;         Romper;       }     Caso 2:       {         adc1_config_channel_atten(ADC1_CHANNEL_6, ADCAttenuation);         Para (Ⅰ = 0; Ⅰ < NUM_READS; Ⅰ++) { Algoritmo de promediación           Suma += adc1_get_raw( ADC1_CHANNEL_6 ); Leer analógico         }         ReturnValue = Suma / NUM_READS;         Romper;       }     Caso 3:       {         adc1_config_channel_atten(ADC1_CHANNEL_7, ADCAttenuation);         Para (Ⅰ = 0; Ⅰ < NUM_READS; Ⅰ++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_7 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         descanso;       }     caso 4:       {         adc1_config_channel_atten(ADC1_CHANNEL_4, Atenuación ADCA);         para (yo = 0; yo < NUM_READS; yo++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_4 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         descanso;       }     defecto:       {         adc1_config_channel_atten(ADC1_CHANNEL_5, Atenuación ADCA);         para (yo = 0; yo < NUM_READS; yo++) { // Algoritmo promedio           suma += adc1_get_raw( ADC1_CHANNEL_5 ); // Leer análogo         }         Valor de retorno = suma / NUM_READS;         descanso;       }   }   regreso Valor de retorno;
}

vacío Init_Blynk_APP()
{   Blynk.setProperty(V1, "etiqueta", MCalib.Nombre del sensor[0]);   Blynk.setProperty(V2, "etiqueta", MCalib.Nombre del sensor[1]);   Blynk.setProperty(V3, "etiqueta", MCalib.Nombre del sensor[2]);   Blynk.setProperty(V4, "etiqueta", MCalib.Nombre del sensor[3]);   Blynk.setProperty(V5, "etiqueta", MCalib.Nombre del sensor[4]);   Blynk.setProperty(V6, "etiqueta", MCalib.Nombre del sensor[5]);   Blynk.setProperty(V7, "etiqueta", MCalib.Nombre del sensor[6]);   Blynk.setProperty(V8, "etiqueta", MCalib.Nombre del sensor[7]);
}

vacío Update_Local_Display()
{   byte rojo1 = 0;   byte amarillo1 = 0;   byte verde1 = 0;   para (byte yo = 0; yo < Sensores de humedad adjuntos; yo++)   {     Si (MMeasure.DataValid[yo])     {       Si ( MMeasure.Por ciento[yo] > MCalib.StatusBorderPercentValues[yo][1])       {         verde1++;       } más Si ( MMeasure.Por ciento[yo] > MCalib.StatusBorderPercentValues[yo][0])       {         amarillo1++;       } más       {         rojo1++;       }     }   }   Si (rojo1 > 0)   {     SetLedConfig(255, 0, 0);   }   más Si (amarillo1 > 0)   {     SetLedConfig(255, 255, 0);   }   más Si (verde1 > 0)   {     SetLedConfig(0, 255, 0);   }   más   {     SetLedConfig(0, 0, 255);   }
}

vacío Update_Blynk_APP(byte Sensor, bool Calibrado)
{   cambiar (Sensor)   {     caso 0:       {         Si ((MMeasure.DataValid[0]) & (Calibrado))         {           Si ( MMeasure.Por ciento[0] > MCalib.StatusBorderPercentValues[0][1])           {             Blynk.setProperty(V1, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[0] > MCalib.StatusBorderPercentValues[0][0])           {             Blynk.setProperty(V1, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V1, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V1, MMeasure.Por ciento[0]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V1, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V1, 0);             retrasar(100);             Blynk.setProperty(V1, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V1, 0);             retrasar(100);             Blynk.setProperty(V1, "color", BLYNK_BLUE);           }         }         descanso;       }     caso 1:       {         Si ((MMeasure.DataValid[1]) & (Calibrado))         {           Si ( MMeasure.Por ciento[1] > MCalib.StatusBorderPercentValues[1][1])           {             Blynk.setProperty(V2, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[1] > MCalib.StatusBorderPercentValues[1][0])           {             Blynk.setProperty(V2, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V2, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V2, MMeasure.Por ciento[1]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V2, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V2, 0);             retrasar(100);             Blynk.setProperty(V2, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V2, 0);             retrasar(100);             Blynk.setProperty(V3, "color", BLYNK_BLUE);           }         }         descanso;       }     caso 2:       {         Si ((MMeasure.DataValid[2]) & (Calibrado))         {           Si ( MMeasure.Por ciento[2] > MCalib.StatusBorderPercentValues[2][1])           {             Blynk.setProperty(V3, "color", BLYNK_GREEN);           } más Si ( MMeasure.Por ciento[2] > MCalib.StatusBorderPercentValues[2][0])           {             Blynk.setProperty(V3, "color", BLYNK_YELLOW);           } más           {             Blynk.setProperty(V3, "color", BLYNK_RED);           }           retrasar(100);           Blynk.virtualWrite(V3, MMeasure.Por ciento[2]);         } más         {           Si (Calibrado)           {             Blynk.setProperty(V3, "etiqueta", "Deaktiviert");             retrasar(100);             Blynk.virtualWrite(V3, 0);             retrasar(100);             Blynk.setProperty(V3, "color", BLYNK_BLACK);           }           más           {             Blynk.virtualWrite(V3, 0);             retrasar(100);             Blynk.setProperty(V3, "color", BLYNK_BLUE);           }         }         descanso;       }     caso 3:       {         Si ((MMeasure.DataValid[3]) & (Calibrado))         {           Si ( MMeasure.Por ciento[3] > MCalib.StatusBorderPercentValues[3][1])           {             Blynk.Setproperty(V4, "color", BLYNK_GREEN);           } Más Si ( MMeasure.Por ciento[3] > MCalib.StatusBorderPercentValues[3][0])           {             Blynk.Setproperty(V4, "color", BLYNK_YELLOW);           } Más           {             Blynk.Setproperty(V4, "color", BLYNK_RED);           }           Retraso(100);           Blynk.virtualWrite(V4, MMeasure.Por ciento[3]);         } Más         {           Si (Calibrado)           {             Blynk.Setproperty(V4, "etiqueta", "Deaktiviert");             Retraso(100);             Blynk.virtualWrite(V4, 0);             Retraso(100);             Blynk.Setproperty(V4, "color", BLYNK_BLACK);           }           Más           {             Blynk.virtualWrite(V4, 0);             Retraso(100);             Blynk.Setproperty(V4, "color", BLYNK_BLUE);           }         }         Romper;       }     Caso 4:       {         Si ((MMeasure.DataValid[4]) & (Calibrado))         {           Si ( MMeasure.Por ciento[4] > MCalib.StatusBorderPercentValues[4][1])           {             Blynk.Setproperty(V5, "color", BLYNK_GREEN);           } Más Si ( MMeasure.Por ciento[4] > MCalib.StatusBorderPercentValues[4][0])           {             Blynk.Setproperty(V5, "color", BLYNK_YELLOW);           } Más           {             Blynk.Setproperty(V5, "color", BLYNK_RED);           }           Retraso(100);           Blynk.virtualWrite(V5, MMeasure.Por ciento[4]);         } Más         {           Si (Calibrado)           {             Blynk.Setproperty(V5, "etiqueta", "Deaktiviert");             Retraso(100);             Blynk.virtualWrite(V5, 0);             Retraso(100);             Blynk.Setproperty(V5, "color", BLYNK_BLACK);           }           Más           {             Blynk.virtualWrite(V5, 0);             Retraso(100);             Blynk.Setproperty(V5, "color", BLYNK_BLUE);           }         }         Romper;       }     Caso 5:       {         Si ((MMeasure.DataValid[5]) & (Calibrado))         {           Si ( MMeasure.Por ciento[5] > MCalib.StatusBorderPercentValues[5][1])           {             Blynk.Setproperty(V6, "color", BLYNK_GREEN);           } Más Si ( MMeasure.Por ciento[5] > MCalib.StatusBorderPercentValues[5][0])           {             Blynk.Setproperty(V6, "color", BLYNK_YELLOW);           } Más           {             Blynk.Setproperty(V6, "color", BLYNK_RED);           }           Retraso(100);           Blynk.virtualWrite(V6, MMeasure.Por ciento[5]);         } Más         {           Si (Calibrado)           {             Blynk.Setproperty(V6, "etiqueta", "Deaktiviert");             Retraso(100);             Blynk.virtualWrite(V6, 0);             Retraso(100);             Blynk.Setproperty(V6, "color", BLYNK_BLACK);           }           Más           {             Blynk.virtualWrite(V6, 0);             Retraso(100);             Blynk.Setproperty(V6, "color", BLYNK_BLUE);           }         }         Romper;       }     Caso 6:       {         Si (DHTMeasure.DataValid)         {           Blynk.virtualWrite(V7, DHTMeasure.Humedad);         } Más         {           Blynk.Setproperty(V7, "etiqueta", "Deaktiviert");           Retraso(100);           Blynk.virtualWrite(V7, 0);           Retraso(100);           Blynk.Setproperty(V7, "color", BLYNK_BLACK);         }         Romper;       }     Caso 7:       {         Si (DHTMeasure.DataValid)         {           Blynk.virtualWrite(V8, DHTMeasure.Temperatura);         } Más         {           Blynk.Setproperty(V8, "etiqueta", "Deaktiviert");           Retraso(100);           Blynk.virtualWrite(V8, 0);           Retraso(100);           Blynk.Setproperty(V8, "color", BLYNK_BLACK);         }         Romper;       }   } Interruptor de extremo
}

Vacío Get_Moisture_DatainPercent()
{   Byte CalibDataOffset = 0;   Para (Byte Ⅰ = 0; Ⅰ < AttachedMoistureSensors; Ⅰ++)   {     CalibDataOffset =  Ⅰ * 2;     Int RawMoistureValue = ReadMoistureSensor_Raw_Val(Ⅰ);     Si ((MCalib.Datos[CalibDataOffset] == 0) || (MCalib.Datos[CalibDataOffset + 1] == 0)) Valor MinADC maxADC Valor ADC     {       MMeasure.Por ciento[Ⅰ] = RawMoistureValue;       MMeasure.DataValid[Ⅰ] = Falso;     } Más     {       RawMoistureValue = MCalib.Datos[CalibDataOffset + 1] - RawMoistureValue;       RawMoistureValue = MCalib.Datos[CalibDataOffset] + RawMoistureValue;       MMeasure.Por ciento[Ⅰ] = Mapa(RawMoistureValue, MCalib.Datos[CalibDataOffset], MCalib.Datos[CalibDataOffset + 1], 0, 100);       Si ((MMeasure.Por ciento[Ⅰ] > 100 ) | (MMeasure.Por ciento[Ⅰ] < 0 ))       {         MMeasure.Por ciento[Ⅰ] = RawMoistureValue;         MMeasure.DataValid[Ⅰ] = Falso;       } Más  {         MMeasure.DataValid[Ⅰ] = Verdad;       }     }   }   devolución ;
}



Vacío Run_MoistureSensors (Bool Init)   HauptFunktion zum Betrieb der Bodenfeuchtesensoren
{   Byte MinSensValue = 100;   Si ((Millis() - Moisure_ServiceCall_Handler >= MoisureSens_Poll_Interval) | (Init))   {     Moisure_ServiceCall_Handler = Millis();     Get_Moisture_DatainPercent();     Para (Int Ⅰ = 0; Ⅰ < Sensores de humedad adjuntos; yo++)     {       Si (MMeasure.DataValid[yo])       {         Si (MMeasure.Por ciento[yo] != MMeasure.Porcentaje antiguo[yo])         {           MMeasure.Porcentaje antiguo[yo] = MMeasure.Por ciento[yo];           Si (MMeasure.Por ciento[yo] < MinSensValue ) {             MinSensValue = MMeasure.Por ciento[yo];           };           De serie.impresión(F("Sensor Feuchtigkeitswert"));           De serie.impresión(yo);           De serie.impresión(F("en Prozent:"));           De serie.impresión(MMeasure.Por ciento[yo]);           De serie.println(F(" %"));           Update_Blynk_APP(yo, Sens_Calib);    // Aktualisiere Handywerte         }       } más       {         Update_Blynk_APP(yo, Sens_NOTCalib);    // Aktualisiere Handywerte         De serie.impresión(F("Sensor"));         De serie.impresión(yo);         De serie.impresión(F("nicht kalibiert. Bitte kalibrieren. Rohdatenwert:"));         De serie.println(MMeasure.Por ciento[yo]);       }     }     Update_Local_Display();           // Aktualisiere lokales Pflanzenwächter Display (Led)   }
}

bool Run_DHTSensor (bool En eso)   //
{   Si ((millis() - DHT_ServiceCall_Handler >= DHT_Poll_Interval) | (En eso))   {     DHT_ServiceCall_Handler = millis();     DHTMeasure.Humedad = dht.leer Humedad();     DHTMeasure.Temperatura = dht.temperatura de lectura(falso);   // Leer la temperatura en grados Celsius (isFahrenheit = true)     Si (isnan(DHTMeasure.Humedad) || isnan(DHTMeasure.Temperatura) )     {       De serie.println(F("¡Error al leer desde el sensor DHT!"));       DHTMeasure.DataValid  = falso;       regreso falso;     }     DHTMeasure.DataValid  = cierto;     Si (DHTMeasure.Humedad != DHTMeasure.Humedad Antigua)     {       DHTMeasure.Humedad Antigua = DHTMeasure.Humedad;       Update_Blynk_APP(6, cierto); // Luftfeuchteanzeige     }     Si (DHTMeasure.Temperatura !=  DHTMeasure.Old_Temperature)     {       DHTMeasure.Old_Temperature = DHTMeasure.Temperatura;       Update_Blynk_APP(7, cierto); // Temperaturanzeige     }   }   regreso cierto;
}


// Bucle principal
vacío lazo()
{   Run_MoistureSensors(RunTime);   Si (DHTMeasure.Sensor habilitado) {     Run_DHTSensor(RunTime);   }   Blynk.correr();   // Ejecutar Blync Basic- Funciones
}

Weitere unbedingt anzupassende Parámetro sind nicht hinzugekommen, da der DHT 22 und auch der DHT 11 Sensor eine interne Werte Kalibrierung hat, die keiner weiteren Anpassung mehr Bedarf.

Nachdem wir den Code nun angepasst und auf unseren ESP hochgeladen haben und sich unser ESP erfolgreich in das WLAN eingeloggt hat (Weiße LED geht aus) müssen wir auch in diesem Teil wieder unsere APP erweitern.

Dazu fügen wir insere APP zwei weitere „LEVEL H“ Elemente hinzu und konfigurieren das erste Element für die Luftfeuchte wie folgt:

 • Color: blanco
 • Pin de entrada: V7 (virtuell)
 • Wert mínimo: 0
 • Peso máximo: 100
 • Velocidad de lectura: PUSH

Das zweite „Nivel H“ Elemento para la temperatura configurada en el siguiente:

 • Color: blanco
 • Pin de entrada: V8 (virtuell)
 • Wert mínimo: -20
 • Peso máximo: 60
 • Velocidad de lectura: PUSH

Anschließend sollte unsere Pflanzen App wie folgt aussehen:

Nach drücken des „Start“ Buttons bekommen wir nun in der APP neben den aktuellen Bodenfeuchtesensorwerten auch die aktuelle Temperatur und Luftfeuchtigkeit dank unserem DHT Sensor angezeigt.

Ich wünsche viel Spaß beim Nachbauen, und bis zum nächsten Mal.