Un guardiano delle piante per il davanzale

Oggi vorrei presentarvi un nuovo, interessante progetto multiparte con il versatile e potente ESP 32. Stiamo costruendo un custode per le nostre piante domestiche. Mentre stiamo dedicando la nostra attenzione ai nostri entusiasmanti progetti elettronici, questo dovrebbe monitorare il contenuto d'acqua del suolo della pianta e informarci quando l'umidità del suolo cala. Il nostro guardiano delle piante ha un semaforo a LED che si illumina di verde quando il terreno è umido e diventa rosso quando il terreno è asciutto. Prima di iniziare il progetto, tuttavia, dobbiamo pensare ad alcune cose prima di iniziare effettivamente il progetto. Ciò vale in particolare per l'uso del guardiano delle piante. Poiché il nostro custode dell'impianto determina l'umidità della terra attraverso una misurazione capacitiva del campo vicino, è necessario che l'umidità sia immagazzinata nelle immediate vicinanze del sensore. Di regola, il terreno normale (invasatura) delle piante dal negozio di ferramenta o dal supermercato soddisfa questa condizione, come nel caso degli Stati Uniti. I substrati idroponici o i substrati di orchidea non sono il caso! quindi:

Questo progetto è per piante idroponiche o Piante Airroot  (come le orchidee) non adatto!

Le piante hanno anche requisiti molto diversi per la loro irrigazione. Mentre alcune piante preferiscono un livello di umidità di base permanente (per lo più nessun ristagno), alcune piante sono piuttosto amanti dell'asciutto e raramente vogliono essere annaffiate. Poiché il nostro custode dell'impianto non è in grado di conoscere i requisiti individuali dell'impianto, l'interpretazione delle azioni necessarie (irrigazione o non irrigazione) sul display (semaforo) del custode dell'impianto è esclusivamente nelle mani dell'utente botanicamente competente 😊. 

Il guardiano delle piante non sostituisce quindi la cura responsabile e adeguata delle piante per le tue piante!

Nell'ulteriore corso del progetto e man mano che il campo di applicazione cresce, collegheremo ulteriori sensori e, naturalmente, aggiungeremo funzioni di comfort. Lasciati sorprendere!
Ma cominciamo con la base. Diamo un'occhiata ai componenti di cui abbiamo bisogno per il nostro tutore dell'impianto per iniziare:

• 1 x LED di colore verde (560nm); 5 mm
• 1x LED di colore giallo (605nm); 5 mm
• 1x LED di colore rosso (633nm); 5 mm
• 6x130kΩ tolleranza di resistenza ± 1%;
• 6x tolleranza di resistenza 47kΩ ± 1
• 3x 150Ω tolleranza di resistenza ± 1%;
• 1x sensore di umidità capacitivo
• 1x ESP32-38Pin variante generico; Tipo NodeMCU-32S; Gambe 38;
• 1x alimentatore per breadboard YwRobot

Colleghiamo i componenti come segue:

I resistori da 150 ohm sono utilizzati come resistori in serie per i LED. 130 KOhm insieme alla resistenza da 47 KOhm formano un divisore di tensione per l'uscita analogica del sensore di umidità.

Carichiamo il seguente codice sul nostro ESP 32:

#include <autista/adc.B>

// Definizione della porta principale
#define LED_Rot     5     // LED rosso 
#define LED_Gelb    14    // LED giallo
#define LED_Gruen   15    // LED verde

// Impostazioni LED PWM
#define pwmfreq 5000  // frequenza di base 5 kHz
#define PWMledChannelA  0
#define PWMledChannelB  1
#define PWMledChannelC  2
#define Risoluzione PWM  8 // Risoluzione a 8 bit
#define ADCAttenuation ADC_ATTEN_DB_11  // ADC_ATTEN_DB_11 = impostazione ADC smorzamento 0-3.6V
#define MaxSensors 1


struct MoistureSensorCalibrationData
{   int dati[MaxSensors * 2] = {0, 0}; // Dati di calibrazione per sensore di umidità. Nota il testo del progetto e regola i valori di conseguenza
};

struct MoistureSensorData
{   byte per cento[MaxSensors] = {0};  // Dati del sensore di umidità in percentuale
};

// Variabili globali
MoistureSensorCalibrationData MCalib;
MoistureSensorData MMeasure;
byte AttachedMoistureSensors; // Sensori di umidità attiva rilevati (conteggio)

vuoto configurazione() {   // inizializza la comunicazione seriale a 9600 bit al secondo:   pinMode(LED_Rot, PRODUZIONE);   pinMode(LED_Gelb, PRODUZIONE);   pinMode(LED_Gruen, PRODUZIONE);   Seriale.inizio(115200);   ledcSetup(PWMledChannelA, PWMfreq, PWMresolution);   ledcSetup(PWMledChannelB, PWMfreq, PWMresolution);   ledcSetup(PWMledChannelC, PWMfreq, PWMresolution);   ledcAttachPin(LED_Rot, PWMledChannelA);   // collega il canale al GPIO da controllare   ledcAttachPin(LED_Gelb, PWMledChannelB);   ledcAttachPin(LED_Gruen, PWMledChannelC);   SetLedConfig(20, 20, 20);   AttachedMoistureSensors = DetectMoistureSensors();   Seriale.println(F("Systemkonfiguration:"));   Seriale.Stampa(AttachedMoistureSensors);   Seriale.println(F("Bodenfeuchtigkeitsensor (en)"));
}

byte DetectMoistureSensors ()
{
#definire MinSensorValue 100   byte rilevato = 0;   per (int io = 0; io < MaxSensors; io++)   {     int MSensorRawValue = ReadMoistureSensorVal(io);     Se ( MSensorRawValue > MinSensorValue) {       rilevato++;     } altro {       rompere;     }   }   Se (rilevato < 1)   {     Seriale.println(F("Keine Bodenfeuchtigkeitssesoren erkannt. System angehalten."));     esp_deep_sleep_start();     mentre (1) {}   }   ritorno rilevato;
}

bool SetLedConfig(byte Rosso, byte giallo, byte verde)
{   ledcWrite(PWMledChannelA, Rosso); // LED Rote   ledcWrite(PWMledChannelB, giallo); // LED Gelbe   ledcWrite(PWMledChannelC, verde); // LED Gruene   ritorno vero;
}

int ReadMoistureSensorVal(byte Sensore)
{   int Valore di ritorno, io;   lungo somma = 0;
#definire NUM_READS 6   adc1_config_width(ADC_WIDTH_BIT_12);   // Intervallo 0-4095   interruttore (Sensore)   {     Astuccio 0:       {         adc1_config_channel_atten(ADC1_CHANNEL_0, ADCAttenuation);         per (io = 0; io < NUM_READS; io++) { // Algoritmo di media           somma += adc1_get_raw( ADC1_CHANNEL_0 ); // Leggi analogico         }         Valore di ritorno = somma / NUM_READS;         rompere;       }   }   ritorno Valore di ritorno;
}

bool GetMoistureData()
{   bool ReadisValid = vero;   per (int io = 0; io < AttachedMoistureSensors; io++)   {     Se ((MCalib.Dati[io] == 0) || (MCalib.Dati[io + 1] == 0)) // Valore MinADC Valore ADC maxADC     {       ReadisValid = falso;       ritorno ReadisValid;     }     int RawMoistureValue = ReadMoistureSensorVal(io);     RawMoistureValue = MCalib.Dati[io + 1] - RawMoistureValue;     RawMoistureValue = MCalib.Dati[io] + RawMoistureValue;     MMeasure.Per cento[io] = carta geografica(RawMoistureValue, MCalib.Dati[io], MCalib.Dati[io + 1], 0, 100);     Se (MMeasure.Per cento[io] > 100 ) {       ReadisValid = falso;     }   }   ritorno ReadisValid;
}

// Main Loop
vuoto ciclo continuo()
{   Se (GetMoistureData())   {     Seriale.Stampa(F("Feuchtigkeitswert Sensor 1 in Prozent:"));     Seriale.Stampa(MMeasure.Per cento[0]);     Seriale.println(F(" %"));     Se (MMeasure.Per cento[0] > 50)     {       SetLedConfig(0, 0, 20);     }     altro Se (MMeasure.Per cento[0] > 10)     {       SetLedConfig(0, 255, 0);     }     altro     {       SetLedConfig(255, 0, 0);     }   }   altro   {     Seriale.Stampa(F("Bodenfeuchtigkeitssensor nicht kalibriert.Bitte kalibrieren. RohDaten des Sensors 1:"));     Seriale.println(ReadMoistureSensorVal(0));     SetLedConfig(20, 20, 20);   }   ritardo(1000);        // ritardo tra le letture per stabilità
}

Come detto, Schritt müssen wir nun die Kalibrierung unseres Feuchtigkeitssensors durchführen. Die Kalibrierung des Sensors Legt Fest, era anche Trockene Erde (Wassergehalt 0%) ed era Nasse Erde (Wassergehalt 100%) erkannt wird. Dazu strecken wir den Feuchtigkeitssensor als erstes in assolut trockene Erde und lassen uns die Sensor-Rohdaten auf der seriellen Schnittselle ausgeben:

Wert 1: (Trocken)

Wir notieren uns den Wert (2276) und bewässern nun die Erde solange, bis sie komplett! durchnässt ist und kein Wasser mehr ausnehmen kann. Wir notieren unsden Wert 2: (Nasse Erde) (1648)

Wir addieren zu dem ersten Wert 2276, 10 dazu und ziehen von 1648, 10 ab. Es ergeben sich daraus die Werte 2286 und 1638

Wir tragen die Werte in unseren Codice ein:

struct MoistureSensorCalibrationData

Codice non carico di codice erneut hoch.

Wir erhalten folgende Ausgabe:

Allo stesso tempo, il nostro led mostra "semaforo" in verde. ci media  i colori:

verde: Umidità elevata.

giallo: Umidità moderata.

rosso: Secco

Divertiti a ricostruire e fino alla prossima parte della serie.