Guardia d'impianto per la parte 4 di davanzale – temperatura e misurazione di umidità aerea

Ciao, e sia il benvenuto in un'altra parte della fila di guardie d'impianto.

Oggi daremo alla guardia d'impianto a 2 in 1 sensore ambientale, così come attueremo un po' di ottimizzazione di (CONDOTTO-) il hardware così come il codice. Il sensore che colleghiamo in questa parte è la temperatura di DHT 22 conosciuta e il sensore di umidità aereo. Con esso la nostra guardia d'impianto può afferrare in umidità d'Aria e di Temperatura di parametro ambientale importante futura accanto all'umidità di terra adesso anche per impianti nei Suoi dintorni. Certamente anche estenderemo la nostra APPLICAZIONE di telefonino adeguatamente inoltre. Prima di tutto facciamo un cambiamento di Beschaltung del LED's prima.

Usiamo inoltre RGB CONDOTTO del modulo KY-016 e colleghiamo questo direttamente come segue:
Rosso in Spillo 0, verde in Spillo 15, e azzurro in Spillo.

I vantaggi di questo modulo sono che salviamo da un lato con installazione in un posto di caso (1/3 del posto di caso), ma anche da controllo PWM dei canali soli si liberano dello spettro pieno RGB di colori, in modo che su questo più che originariamente solo 3 stati possa esser indicato.
(Per esempio, brilla il CONDOTTO nella fase d'inizializzazione adesso in bianco). Ci salviamo non da ultimo la preopposizione, perché questi sono integrati adesso già sul modulo. Gli Spilli in cui il LED's RGB sono collegati all'ESP32 sono stati scelti secondo il criterio «per calcolare il hardware incritico adeguatamente». Lo sfondo è che gli Spilli gli sono collegati le cause di prodotto CONDOTTE, esperte durante un'oscillazione di ripresa di sistema (PWM) prima che sono inizializzati, e perciò non sono adatti per calcolare il hardware critico (come il DHT22).

Un cambiamento si è anche alzato nella funzionalità e la rappresentazione dell'esposizione CONDOTTA: Perché noi che solo uno e non sei LED's RGB deve registrare intorno a Statis della guardia, dobbiamo riassumere le informazioni più importanti su esso.

Inoltre ricorriamo alla considerazione seguente: Per noi sono le informazioni più importanti se devono versare a uno di 6 impianti massimi o no. Cioè questo deve essere riconoscibile su un'occhiata. Inoltre definiamo il verde a colori (Sufficiente umidità) in un tal modo intorno a cui TUTTI i 6 impianti sufficiente umidità hanno, in modo che prendiamo un'esposizione «verde». Se uno di sei sensori doveva fare il meno di 50% di umidità di terra detektiere, la nostra esposizione su salti «gialli». Con il meno di 10% su «rosso». Perciò conosciamo noi la nostra APPLICAZIONE di guardie d'impianto deve iniziare a venire a sapere quale di sei impianti devono versare. A causa dello Spillo di sensore termico e umido DHT 22 3,3 V e sono compatibili con logica, lo colleghiamo direttamente al porto 4 dell'ESP. Qui vede Beschaltung completo:

La parte di attualità elenca con le parti di hardware richieste. (Con collegamento di relazione)

Invece di primo DHT 22 elencato di sensore anche il sensore più a buon mercato DHT 11 sono usati da un'installazione facile della linea «il DHTTYPE DHT22». Tuttavia, il DHT non è così esatto dalla misurazione come DHT 22.

Qui se le differenze di entrambi i sensori sono ancora trovate qualche volta al controllo su.

Se DHT 11 Senor deve esser usato, la linea deve andare

#define DHTTYPE DHT22

in

#define DHTTYPE DHT11

sono cambiati. Altri cambiamenti non sono necessari.

Il Pinbelegung questo ESP32 è come segue

Questo è stato già i cambiamenti di hardware necessari. Per essere capaci di usare il sensore con il suo proprietärem un Protocollo Di filo metallico nel nostro schizzo al DHT22 / DHT 11, dobbiamo integrare come le due prossime altre biblioteche nel nostro IDE.

Questo è da un lato gerneralisierte „Adafruit sensore Unificato Libary“: così come il reale Biblioteca di sensore di DHT. Entrambe le biblioteche sono basate sull'un l'altro e devono esser aggiunte alle nostre biblioteche dell'IDE, perché sono necessari dal nostro progetto.

Aggiungendo le biblioteche e l'adattamento dei parametri nel codice, come in Parte 3 di questa fila, descritta carichiamo il codice seguente secondo il nostro ESP in alto:

#include <guidatore/adc.H>
#include <WiFi.H>
#include <WiFiClient.H>
#include <BlynkSimpleEsp32.H>
#include «EEPROM.h»
#include <Preferenze.H>
#include «DHT.h»    //RICHIEDE le biblioteche di Arduino seguenti:
//-Sensor biblioteca di DHT: https://github.com/adafruit/DHT-sensor-library
Sensore//-Adafruit Unificato Lib: https://github.com/adafruit/Adafruit_Sensor

//Il modulo di Portedefinierung RGP CONDOTTO
#define LED_Rot     0     //Il rossore CONDOTTO 
#define LED_Blau    14    //Azzurro CONDOTTO
#define LED_Gruen   15    //Verde CONDOTTO

//Le installazioni hanno CONDOTTO PWM
#define PWMfreq 5000  //5 chilohertz di frequenza bassa per esposizione CONDOTTI
#define PWMledChannelA  0
#define PWMledChannelB  1
#define PWMledChannelC  2
#define PWMresolution  8 //8 pezzettini di risoluzione per PWM CONDOTTO

//Altre definizioni
#define ADCAttenuation ADC_ATTEN_DB_11    //ADC_ATTEN_DB_11 = inumidimento 0-3,6V ADC (ampliamento ADC
#define MoisureSens_Poll_Interval 300000   //Intervallo tra due misurazioni di umidità di terra durante millisecondi  -> tutti i 5 minuti di pacco di dati a telefonino mandano
#define DHT_Poll_Interval 400000           //Intervallo tra due Temeperatur e Luftfreuchtemessungen durante millisecondi  -> tutti i 6 minuti di pacco di dati a telefonino mandano
#define MaxSensors 6                      //Numero massimo in sensori umidi connectable
#define StartInit vero
#define Tempo diretto falso
#define Sens_Calib vero
#define Sens_NOTCalib falso
#define EEPROM_SIZE 512                  //Dimensioni di EEPROMS interno

//Definizioni APPLICATIVE di Blynk
#define BLYNK_GREEN     «#23C48E»
#define BLYNK_BLUE      «#04C0F8»
#define BLYNK_YELLOW    «#ED9D00»
#define BLYNK_RED       «#D3435C»
#define BLYNK_BLACK     "#000000"
#define BLYNK_PRINT Seriale
#define BLYNK_NO_BUILTIN
#define BLYNK_NO_FLOAT
//#define BLYNK_DEBUG

//Configurazione DHT
#define DHTPIN 4     //Digitalmente lo spillo ha collegato al sensore DHT
#define DHTTYPE DHT22   //DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21//DHT 21 (AM2301)

struct MoistureSensorCalibrationData
{   intervallo Dati[MaxSensors * 2] = {1651, 2840, 1652, 2840, 1653, 2840, 1654, 2840, 1655, 2840, 1656, 2840}; //Dati di taratura per sensore di umidità. Per favore, segua il testo di progetti e adatti valori ensprechend   //Dati internazionali [MaxSensors*2] = {0,0,0,0,0,0,0,0,0,0,0,0};//Dati di Taratura per sensore di umidità. Per favore, segua il testo di progetti e adatti valori ensprechend   byte StatusBorderPercentValues[MaxSensors * 2][2] = { {10, 50},     //L'Assortimento di Zweidimensinonales per il percento limita valori (il semaforo) in ogni caso a singoli per sensore umido (1-6)     {10, 50},     {10, 50},     {10, 50},     {10, 50},     {10, 50}   };   Spago Nome di sensore[MaxSensors + 2] = {«Impianto 1», «Impianto 2», «Impianto 3», «Impianto 4», «Impianto 5», «Impianto 6», «Umidità di Aerial», «Temperatura»}; //Il nome di sensore che è anche indicato nell'APPLICAZIONE come un'intestazione

};

struct MoistureSensorData
{   intervallo Il percento[MaxSensors] = {0, 0, 0, 0, 0, 0};  //Dati di sensore di umidità nel percento   byte Old_Percent[MaxSensors] = {0, 0, 0, 0, 0, 0}; //Precedente _ dati di sensore di umidità nel percento (scopo: la quantità di Dati fa economie.)   bool DataValid [MaxSensors] = {falso, falso, falso, falso, falso, falso};
};

struct DHTSensorData
{   galleggiante Umidità = 0 ;      //Dati di sensore di umidità aerei nel percento   galleggiante Temperatura = 0;   galleggiante Old_Humidity = 0 ;      //Dati di sensore di umidità aerei nel percento   galleggiante Old_Temperature = 0;   bool DataValid  = falso;   bool SensorEnabled  = falso;
};

DHT dht(DHTPIN, DHTTYPE); //DHP Instalz initalisieren


//Variabile mondiale


lavoro a giornata auth[] = «xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx»; //Qui in conformità con istruzioni il Segno di Auth dere Blynk posa l'applicazione (la posta elettronica).
//I Suoi dati di accesso di WiFi.
lavoro a giornata ssid[] = «Deine_WLAN_SSID»;                 //Per favore, per possedere WLAN SSID si adattano
lavoro a giornata adatto[] = «Dein _WLAN _Passwort!»;           //Per favore, per possedere la parola d'ordine WLAN si adattano
MoistureSensorCalibrationData MCalib;
MoistureSensorData MMeasure;
DHTSensorData  DHTMeasure;

byte AttachedMoistureSensors; //Umidità Attiva scoperta di sensore (Numero)
non firmato a lungo Moisure_ServiceCall_Handler = 0;  //Variabili di ritardo per Ritardo tra Letture Moisure
non firmato a lungo DHT_ServiceCall_Handler = 0;  //Variabili di ritardo per Ritardo tra Letture DHT


vuoto situazione() {   pinMode(LED_Rot, USCITA);   pinMode(LED_Blau, USCITA);   pinMode(LED_Gruen, USCITA);   Seriale.cominciare(115200);   //inizializzi la comunicazione seriale A 115.200 pezzettini da secondo:   ledcSetup(PWMledChannelA, PWMfreq, PWMresolution);   ledcSetup(PWMledChannelB, PWMfreq, PWMresolution);   ledcSetup(PWMledChannelC, PWMfreq, PWMresolution);   ledcAttachPin(LED_Rot, PWMledChannelA);   //attacchi il canale al GPIO da Esser controllato   ledcAttachPin(LED_Blau, PWMledChannelB);   ledcAttachPin(LED_Gruen, PWMledChannelC);   SetLedConfig(255, 255, 255);   Seriale.println(E IL SEGUENTE(«Configurazione di sistema»:));   se (!EEPROM.cominciare(EEPROM_SIZE))   {     Seriale.println(E IL SEGUENTE(«fallito per inizializzare EEPROM»));   } altro   { Seriale.println(EEPROM_SIZE);     Seriale.println(E IL SEGUENTE(«Byte EEPROM»));   }   AttachedMoistureSensors = DetectMoistureSensors();   Seriale.stampa(AttachedMoistureSensors);   Seriale.println(E IL SEGUENTE(«Bodenfeuchtigkeitsensor (in)»));   dht.cominciare();   DHTMeasure.SensorEnabled  = Run_DHTSensor (StartInit);   se (DHTMeasure.SensorEnabled)   {     Seriale.println(E IL SEGUENTE(«1 sensore DHT 22»));   }   Seriale.stampa(E IL SEGUENTE(«Connessione con WLAN»));   ritardo(500);   Blynk.cominciare(auth, ssid, adatto);  //WiFi-connessione di Initalize sopra biblioteca Blync   Seriale.println(E IL SEGUENTE(«con successo».));   SetLedConfig(0, 0, 0);   Init_Blynk_APP();   Run_MoistureSensors(StartInit);   per (intervallo io = AttachedMoistureSensors; io < 6; io++) {     Update_Blynk_APP(io, Sens_Calib);   };
}

byte DetectMoistureSensors ()
{
#define MinSensorValue 100   byte Scoperto = 0;   per (intervallo io = 0; io < MaxSensors; io++)   {     intervallo MSensorRawValue = ReadMoistureSensor_Raw_Val(i);     if ( MSensorRawValue > MinSensorValue) {       Detected++;     } else {       break;     }   }   if (Detected < 1)   {     Seriale.println(F(" Non è stata rilevata alcuna luce di umidità del suolo. Sistema in pausa. "));     esp_deep_sleep_start();     while (1) {}   }   return Detected;
}

booli SetLedConfig(byte Red, byte Verde, byte Blue)
{   ledcWrite(PWMledChannelA, Red); // LED rosso   ledcWrite(PWMledChannelB, Blue); // LED azzurro   ledcWrite(PWMledChannelC, Verde); // LED gru   return true;
}

int ReadMoistureSensor_Raw_Val(byte sensore)
{   int ReturnValue, i;   long sum = 0;
" #define " NUM_READS 6   adc1_config_width(ADC_WIDTH_BIT_12);   // Range 0 - 4095   switch (sensore)   {     case 0:       {         adc1_config_channel_atten(ADC1_CHANNEL_0, ADCAttenuation);         per (i = 0; i < NUM_READS; i++) { // Averaging algorithm           sum += adc1_get_raw( ADC1_CHANNEL_0 ); // Read analogico         }         ReturnValue = sum / NUM_READS;         break;       }     case 1:       {         adc1_config_channel_atten(ADC1_CHANNEL_3, ADCAttenuation);         per (i = 0; i < NUM_READS; i++) { // Averaging algorithm           sum += adc1_get_raw( ADC1_CHANNEL_3 ); // Read analogico         }         ReturnValue = sum / NUM_READS;         break;       }     case 2:       {         adc1_config_channel_atten(ADC1_CHANNEL_6, ADCAttenuation);         per (i = 0; i < NUM_READS; i++) { // Averaging algorithm           sum += adc1_get_raw( ADC1_CHANNEL_6 ); // Read analogico         }         ReturnValue = sum / NUM_READS;         break;       }     case 3:       {         adc1_config_channel_atten(ADC1_CHANNEL_7, ADCAttenuation);         per (i = 0; i < NUM_READS; i++) { // Averaging algorithm           sum += adc1_get_raw( ADC1_CHANNEL_7 ); // Read analogico         }         ReturnValue = sum / NUM_READS;         break;       }     case 4:       {         adc1_config_channel_atten(ADC1_CHANNEL_4, ADCAttenuation);         per (i = 0; i < NUM_READS; i++) { // Averaging algorithm           sum += adc1_get_raw( ADC1_CHANNEL_4 ); // Read analogico         }         ReturnValue = sum / NUM_READS;         break;       }     predefinito:       {         adc1_config_channel_atten(ADC1_CHANNEL_5, ADCAttenuation);         per (i = 0; i < NUM_READS; i++) { // Averaging algorithm           sum += adc1_get_raw( ADC1_CHANNEL_5 ); // Read analogico         }         ReturnValue = sum / NUM_READS;         break;       }   }   return ReturnValue;
}

void Init_Blynk_APP()
{   Blynk.file setProperty(V1, "label", MCalib.SensorName[0]);   Blynk.file setProperty(V2, "label", MCalib.SensorName[1]);   Blynk.file setProperty(V3, "label", MCalib.SensorName[2]);   Blynk.file setProperty(V4, "label", MCalib.SensorName[3]);   Blynk.file setProperty(V5, "label", MCalib.SensorName[4]);   Blynk.file setProperty(V6, "label", MCalib.SensorName[5]);   Blynk.file setProperty(V7, "label", MCalib.SensorName[6]);   Blynk.file setProperty(V8, "label", MCalib.SensorName[7]);
}

void Update_Local_Display()
{   byte red1 = 0;   byte yellow1 = 0;   byte green1 = 0;   per (byte i = 0; i < SensedMoistureSensors; i++)   {     if (MMeasure.DataValid[i])     {       if ( MMeasure.Percent[i] > MCalib.StatusBorderPercentValues[i][1])       {         green1++;       } else if ( MMeasure.Percent[i] > MCalib.StatusBorderPercentValues[i][0])       {         yellow1++;       } else       {         red1++;       }     }   }   if (red1 > 0)   {     SetLedConfig(255, 0, 0);   }   else if (yellow1 > 0)   {     SetLedConfig(255, 255, 0);   }   else if (green1 > 0)   {     SetLedConfig(0, 255, 0);   }   else   {     SetLedConfig(0, 0, 255);   }
}

void Update_Blynk_APP(byte sensore, booli Calibrated)
{   switch (sensore)   {     case 0:       {         if ((MMeasure.DataValid[0]) & (Calibrated))         {           if ( MMeasure.Percent[0] > MCalib.StatusBorderPercentValues[0][1])           {             Blynk.file setProperty(V1, "color", BLYNK_GREEN);           } else if ( MMeasure.Percent[0] > MCalib.StatusBorderPercentValues[0][0])           {             Blynk.file setProperty(V1, "color", BLYNK_YELLOW);           } else           {             Blynk.file setProperty(V1, "color", BLYNK_RED);           }           delay(100);           Blynk.virtualWrite(V1, MMeasure.Percent[0]);         } else         {           if (Calibrated)           {             Blynk.file setProperty(V1, "label", "Disattivato");             delay(100);             Blynk.virtualWrite(V1, 0);             delay(100);             Blynk.file setProperty(V1, "color", BLYNK_BLACK);           }           else           {             Blynk.virtualWrite(V1, 0);             delay(100);             Blynk.file setProperty(V1, "color", BLYNK_BLUE);           }         }         break;       }     case 1:       {         if ((MMeasure.DataValid[1]) & (Calibrated))         {           if ( MMeasure.Percent[1] > MCalib.StatusBorderPercentValues[1][1])           {             Blynk.file setProperty(V2, "color", BLYNK_GREEN);           } else if ( MMeasure.Percent[1] > MCalib.StatusBorderPercentValues[1][0])           {             Blynk.file setProperty(V2, "color", BLYNK_YELLOW);           } else           {             Blynk.file setProperty(V2, "color", BLYNK_RED);           }           delay(100);           Blynk.virtualWrite(V2, MMeasure.Percent[1]);         } else         {           if (Calibrated)           {             Blynk.file setProperty(V2, "label", "Disattivato");             delay(100);             Blynk.virtualWrite(V2, 0);             delay(100);             Blynk.file setProperty(V2, "color", BLYNK_BLACK);           }           else           {             Blynk.virtualWrite(V2, 0);             delay(100);             Blynk.file setProperty(V3, "color", BLYNK_BLUE);           }         }         break;       }     case 2:       {         if ((MMeasure.DataValid[2]) & (Calibrated))         {           if ( MMeasure.Percent[2] > MCalib.StatusBorderPercentValues[2][1])           {             Blynk.file setProperty(V3, "color", BLYNK_GREEN);           } else if ( MMeasure.Percent[2] > MCalib.StatusBorderPercentValues[2][0])           {             Blynk.file setProperty(V3, "color", BLYNK_YELLOW);           } else           {             Blynk.file setProperty(V3, "color", BLYNK_RED);           }           delay(100);           Blynk.virtualWrite(V3, MMeasure.Percent[2]);         } else         {           if (Calibrated)           {             Blynk.file setProperty(V3, "label", "Disattivato");             delay(100);             Blynk.virtualWrite(V3, 0);             delay(100);             Blynk.file setProperty(V3, "color", BLYNK_BLACK);           }           else           {             Blynk.virtualWrite(V3, 0);             delay(100);             Blynk.file setProperty(V3, "color", BLYNK_BLUE);           }         }         break;       }     case 3:       {         if ((MMeasure.DataValid[3]) & (Calibrated))         {           if ( MMeasure.Percent[3] > MCalib.StatusBorderPercentValues[3][1])           {             Blynk.file setProperty(V4, "color", BLYNK_GREEN);           } else if ( MMeasure.Percent[3] > MCalib.StatusBorderPercentValues[3][0])           {             Blynk.file setProperty(V4, "color", BLYNK_YELLOW);           } else           {             Blynk.file setProperty(V4, "color", BLYNK_RED);           }           delay(100);           Blynk.virtualWrite(V4, MMeasure.Percent[3]);         } else         {           if (Calibrated)           {             Blynk.file setProperty(V4, "label", "Disattivato");             delay(100);             Blynk.virtualWrite(V4, 0);             delay(100);             Blynk.file setProperty(V4, "color", BLYNK_BLACK);           }           else           {             Blynk.virtualWrite(V4, 0);             delay(100);             Blynk.file setProperty(V4, "color", BLYNK_BLUE);           }         }         break;       }     case 4:       {         if ((MMeasure.DataValid[4]) & (Calibrated))         {           if ( MMeasure.Percent[4] > MCalib.StatusBorderPercentValues[4][1])           {             Blynk.file setProperty(V5, "color", BLYNK_GREEN);           } else if ( MMeasure.Percent[4] > MCalib.StatusBorderPercentValues[4][0])           {             Blynk.file setProperty(V5, "color", BLYNK_YELLOW);           } else           {             Blynk.file setProperty(V5, "color", BLYNK_RED);           }           delay(100);           Blynk.virtualWrite(V5, MMeasure.Percent[4]);         } else         {           if (Calibrated)           {             Blynk.file setProperty(V5, "label", "Disattivato");             delay(100);             Blynk.virtualWrite(V5, 0);             delay(100);             Blynk.file setProperty(V5, "color", BLYNK_BLACK);           }           else           {             Blynk.virtualWrite(V5, 0);             delay(100);             Blynk.file setProperty(V5, "color", BLYNK_BLUE);           }         }         break;       }     case 5:       {         if ((MMeasure.DataValid[5]) & (Calibrated))         {           if ( MMeasure.Percent[5] > MCalib.StatusBorderPercentValues[5][1])           {             Blynk.file setProperty(V6, "color", BLYNK_GREEN);           } else if ( MMeasure.Percent[5] > MCalib.StatusBorderPercentValues[5][0])           {             Blynk.file setProperty(V6, "color", BLYNK_YELLOW);           } else           {             Blynk.file setProperty(V6, "color", BLYNK_RED);           }           delay(100);           Blynk.virtualWrite(V6, MMeasure.Percent[5]);         } else         {           if (Calibrated)           {             Blynk.file setProperty(V6, "label", "Disattivato");             delay(100);             Blynk.virtualWrite(V6, 0);             delay(100);             Blynk.file setProperty(V6, "color", BLYNK_BLACK);           }           else           {             Blynk.virtualWrite(V6, 0);             delay(100);             Blynk.file setProperty(V6, "color", BLYNK_BLUE);           }         }         break;       }     case 6:       {         if (DHTMeasure.DataValid)         {           Blynk.virtualWrite(V7, DHTMeasure.Humidity);         } else         {           Blynk.file setProperty(V7, "label", "Disattivato");           delay(100);           Blynk.virtualWrite(V7, 0);           delay(100);           Blynk.file setProperty(V7, "color", BLYNK_BLACK);         }         break;       }     case 7:       {         if (DHTMeasure.DataValid)         {           Blynk.virtualWrite(V8, DHTMeasure.Temperature);         } else         {           Blynk.file setProperty(V8, "label", "Disattivato");           delay(100);           Blynk.virtualWrite(V8, 0);           delay(100);           Blynk.file setProperty(V8, "color", BLYNK_BLACK);         }         break;       }   } // Switch di fine
}

void Get_Moisture_DatainPercent()
{   byte Offset CalibDataOffset = 0;   per (byte i = 0; i < SensedMoistureSensors; i++)   {     Offset CalibDataOffset =  i * 2;     int RawMoistureValue = ReadMoistureSensor_Raw_Val(i);     if ((MCalib.Data[Offset CalibDataOffset] == 0) || (MCalib.Data[Offset CalibDataOffset + 1] == 0)) // MinADC Value maxADC ADC Value     {       MMeasure.Percent[i] = RawMoistureValue;       MMeasure.DataValid[i] = false;     } else     {       RawMoistureValue = MCalib.Data[Offset CalibDataOffset + 1] - RawMoistureValue;       RawMoistureValue = MCalib.Data[Offset CalibDataOffset] + RawMoistureValue;       MMeasure.Percent[i] = mappa(RawMoistureValue, MCalib.Data[Offset CalibDataOffset], MCalib.Data[Offset CalibDataOffset + 1], 0, 100);       if ((MMeasure.Percent[i] > 100 ) | (MMeasure.Percent[i] < 0 ))       {         MMeasure.Percent[i] = RawMoistureValue;         MMeasure.DataValid[i] = false;       } else  {         MMeasure.DataValid[i] = true;       }     }   }   return ;
}



void Run_MoistureSensors (booli Init)   // la funzione principale per il funzionamento dei sensori di umidità del suolo
{   byte MinSensValue = 100;   if ((millis() - Moisure_ServiceCall_Handler >= MoisureSens_Poll_Interval) | (Init))   {     Moisure_ServiceCall_Handler = millis();     Get_Moisture_DatainPercent();     per (int i = 0; i < SensedMoistureSensors; i++)     {       if (MMeasure.DataValid[i])       {         if (MMeasure.Percent[i] != MMeasure.Old_Percent[i])         {           MMeasure.Old_Percent[i] = MMeasure.Percent[i];           if (MMeasure.Percent[i] < MinSensValue ) {             MinSensValue = MMeasure.Percent[i];           };           Seriale.print(F("Sensore di umidità"));           Seriale.print(i);           Seriale.print(F("in percentuale:"));           Seriale.print(MMeasure.Percent[i]);           Seriale.println(F(" %"));           Update_Blynk_APP(i, Sens_Calib);    // Aggiornare i valori del gestore         }       } else       {         Update_Blynk_APP(i, Sens_NOTCalib);    // Aggiornare i valori del gestore         Seriale.print(F("Sensore"));         Seriale.print(i);         Seriale.print(F(" non calibra. Calibrare il valore dei dati grezzi: ";));         Seriale.println(MMeasure.Percent[i]);       }     }     Update_Local_Display();           // Aggiornamento di Led (Local Area Network) locale   }
}

booli Run_DHTSensor (booli Init)   //
{   if ((millis() - DHT_ServiceCall_Handler >= DHT_Poll_Interval) | (Init))   {     DHT_ServiceCall_Handler = millis();     DHTMeasure.Humidity = dotto.readHumidity();     DHTMeasure.Temperature = dotto.readTemperature(false);   // Read temperature as Celsius (isFahrenheit = true)     if (isnan(DHTMeasure.Humidity) || isnan(DHTMeasure.Temperature) )     {       Seriale.println(F("Failed to read from DHT sensor!"));       DHTMeasure.DataValid  = false;       return false;     }     DHTMeasure.DataValid  = true;     if (DHTMeasure.Humidity != DHTMeasure.Old_Humidity)     {       DHTMeasure.Old_Humidity = DHTMeasure.Humidity;       Update_Blynk_APP(6, true); // LED di umidità dell'aria     }     if (DHTMeasure.Temperature !=  DHTMeasure.Old_Temperature)     {       DHTMeasure.Old_Temperature = DHTMeasure.Temperature;       Update_Blynk_APP(7, true); // LED di temperatura     }   }   return true;
}


// Main Loop
void loop()
{   Run_MoistureSensors(RunTime);   if (DHTMeasure.SensorEnabled) {     Run_DHTSensor(RunTime);   }   Blynk.run();   // Execute Blync Basic - Functions
}

Non sono stati aggiunti altri parametri, in quanto il DHT 22 e il DHT 11 hanno un valore interno di calibrazione che non ha più bisogno di ulteriori aggiustamenti.

Ora che il codice è stato adattato e caricato sul nostro ESP e il nostro ESP si è collegato con successo al Wi-Fi, dobbiamo riprendere il nostro APP anche in questa parte.

A tale scopo, aggiungiamo altri due elementi "LEVEL H" nella nostra APP e ne configurano il primo elemento per la luce aerea come segue:

Colore: bianco
Input Pin: V7 (virtualizzato)
Valore minimo: 0
Valore massimo: 100
Reading Rate: PUSH

Il secondo "Livello H" per la temperatura viene configurato nel modo seguente:

Colore: bianco
Input Pin: V8 (virtualizzato)
Valore minimo: -20
Valore massimo: 60
Reading Rate: PUSH

La nostra specie di piante deve essere quindi simile a:

Dopo aver premuto il "Start" Button, ora, nella APP, oltre ai livelli attuali di umidità del suolo, abbiamo anche indicato la temperatura e l'umidità attuali grazie al nostro sensore di DHT.

I miei migliori auguri per la costruzione, e per la prossima volta.