Wir möchten immer ein perfektes Klima für unsere Pflanzen im Garten oder Gewächshaus schaffen. Manchmal jedoch vergessen wir vielleicht, sie zu gießen und das hat unerwünschte Folgen für die Pflanzen, besonders bei heißem Wetter.

Mit diesem Projekt, dass Sie auch an Ihre Bedürfnisse anpassen können, werden wir etwas entspannter mit unseren Pflanzen umgehen können, da die Bewässerung völlig autonom ist und bei Hitze und übermäßiger Feuchtigkeit, die Luft im Gewächshaus erneuert wird.

Wir werden den Bodenfeuchtigkeitssensor mit Bewässerungswarnung verwenden. Dadurch werden den Bodenfeuchtigkeitswert ablesen, um die automatische Bewässerung zu aktivieren. Das geschieht, indem wir (zum Beispiel) ein Elektroventil aktivieren. Wir werden auch einen Feuchtigkeits- und Temperatursensor verwenden, um diese Umweltparameter zu erfassen. Alle Daten werden dann auf einem TFT-Bildschirm angezeigt.

Benötigte Materialien

• Boden Alarm Feuchtigkeitssensor Pflanzenbewässerungs-Modul
• MB 102 Breadboard Kit - 830 Breadboard, Netzteil Adapter 3,3V 5V, 65Stk Steckbrücken
• Jumper Wire Kabel 40 STK. je 20 cm F2M Female to Male
• Mikrocontroller Board ATmega328 mit USB-Kabel
• DHT11 Breakout Modul mit Platine und Kabel Temperatursensor und Luftfeuchtigkeitssensor
• 1,8 Zoll SPI TFT Display 128 x 160 Pixel
• PCA9548A I2C IIC Multiplexer
• 4-Relais Modul 5V mit Optokoppler Low-Level-Trigger
• Aktive Mini-Lüfter

 

Benötigte Software

• Arduino IDE
• ino sketch
• Wire library (Wire.h) (integriert)
• SPI library (SPI.h) (integriert)
• TFT library (TFT.h) (Bibliotheksverwalter)
• Library for DHT-11 sensor (DHT.h) (Bibliotheksverwalter)

Schaltung und Beschreibung der verwendeten Module

Download des Schaltplans

Die Hauptidee dieses Projekts ist es, die Feuchtigkeit des Bodens unserer Pflanzen durch die Bodenfeuchtesensor und, im Falle des Baus eines Gewächshauses, die Feuchtigkeit und die Temperatur der Umgebung mit dem DHT-11-Sensor zu messen. Die erhaltenen Daten sollen auf dem 1,8-Zoll-TFT-Bildschirm präsentiert werden. Wenn nötig, wird das System die betroffene Pflanze bewässern und die Belüftung aktivieren. Im Schaltplan haben wir drei Bewässerungsmagnetventile und eine 24 Vdc-Stromversorgung am Ausgang des Relaismoduls platziert. Diese Komponenten sind als Beispiel dafür gedacht, was am Ausgang der Relais installiert werden könnte. Jeder Leser kann die Komponente, die gesteuert werden soll, an seine Bedürfnisse anpassen.

Die Feuchtigkeitsfühler, die wir verwenden werden, haben alle die gleiche I2C-Adresse, so dass wir einen Mechanismus benötigen, um die Daten von jedem von ihnen getrennt zu erhalten. Um dies zu tun, werden wir das Modul PCA9548A verwenden. Dieses Modul bietet uns die Steuerung von 8 I2C-Geräten. Außerdem verfügt es über drei Konfigurationspins, um eine Adressen zu konfigurieren. Damit ergibt sich die beeindruckende Zahl von insgesamt 64 Geräten, die wir durch I2C-Kommunikation steuern können. BEEINDRUCKEND !!!

Außerdem werden wir, wie bereits erwähnt, ein 4-Relais-Modul verwenden, da wir unseren Mikrocontroller elektrisch isolieren wollen, wenn die Lüfter und zum Beispiel die Magnetventile für die Bewässerung der Pflanzen, aktiviert werden.

Alle Daten der Sensoren werden auf dem TFT-Bildschirm angezeigt. Die Bodenfeuchtesensoren bieten drei Feuchtigkeitszustände: trocken, optimal und feucht. Sie liefern auch die Werte der Feuchtigkeit und Temperatur der Umgebung.

Die normale Art, den Sensor zu verwenden, besteht darin, die 3,3 Vdc-Batterie zu installieren, den Knopf zu drücken, um den Wert für die Erkennung von trockenem Boden zu speichern. Wenn der Boden trocken ist, ertönt ein Warnton, um uns mitzuteilen, dass wir die Pflanze gießen sollten. Wir gehen noch einen Schritt weiter und arbeiten mit den Messwerten der Sonde über deren I2C-Port. Dazu müssen wir die 6 Pins (wie im elektronischen Schaltplan zu sehen) in den ISP-Programmierport des Sensors löten. Damit wird die Versorgungsspannung von 3,3 Vdc. und die I2C-Kommunikation mit dem PCA9548A-Modul verbunden, ohne den normalen Betriebsmodus zu deaktivieren.

Für den korrekten Betrieb der Sensoren muss beim Anlegen der Spannung an die Baugruppe darauf geachtet werden, dass die Sensor-LEDs beim Blinken etwa eine Sekunde lang leuchten. Wenn sie kürzer leuchten, muss der Sensorknopf mindestens 5 Sekunden lang gedrückt gehalten und dann losgelassen werden. Außerdem muss darauf geachtet werden, dass die LED während des Blinkens eine Sekunde lang leuchtet. Andernfalls ist der Messwert fehlerhaft.

Laut Dokumentation auf Github liefert dieses Modul Messwerte zur Bodenfeuchtigkeit durch Messung der Kapazität, wenn die Sonde in Kontakt mit dem Pflanzensubstrat, der Temperatur und dem Licht ist. Um diese Daten zu erhalten, müssen wir sie mit den richtigen Methoden auslesen. Nachstehend finden Sie eine Tabelle mit den hexadezimalen Adressen der Parameterregister, die wir lesen und ändern können, sowie die Länge dieser Daten in Bytes. Die Register zum Auslesen der Kapazität und zum Zurücksetzen des Sensors wurden hervorgehoben. Diese werden wir verwenden.

Name	Register	Read/Write	Data length
GET_CAPACITANCE	0x00	(r)	2
SET_ADDRESS	0x01	(w)	1
GET_ADDRESS	0x02	(r)	1
MEASURE_LIGHT	0x03	(w)	0
GET_LIGHT	0x04	(r)	2
GET_TEMPERATURE	0x05	(r)	2
RESET	0x06	(w)	0
GET_VERSION	0x07	(r)	1
SLEEP	0x08	(w)	0
GET_BUSY	0x09	(r)	1

 

Beschreibung der Montage und des Sketches

Wie wir im Bauplan sehen können, haben wir drei Bodenfeuchtigkeitssensoren verwendet, die die Daten aufnehmen und über das PCA9548A Modul an unseren Mikrocontroller übertragen. Der DHT-11-Sensor sendet die Temperatur- und Feuchtigkeitsdaten direkt an den Mikrocontroller. Die empfangenen Daten werden auf dem TFT-Bildschirm angezeigt, und je nach den Werten, die wir für den trockenen, optimalen und feuchten Boden, sowie für die Umgebungstemperatur und -feuchtigkeit konfiguriert haben, müssen die Magnetventile und der Lüfter aktiviert werden. Das Relais-Modul empfängt das Statussignal LOW, um den Ausgang "Normally Open" zu aktivieren und somit das entsprechende Magnetventil zu aktivieren.

Kommen wir nun zur Beschreibung des Sketches. Bei der Initialisierung des Sketches eines Projekts sollten immer zuerst die erforderlichen Bibliotheken eingebunden werden, um die Komponenten, die sie benötigen, steuern zu können. Wir müssen die Bibliotheken für die I2C-Kommunikation mit den Bodenfeuchtigkeitssonden, die SPI-Kommunikations- und TFT-Bildschirmbibliothek, sowie die Bibliothek für die Verwendung des DHT-11-Sensors inkludieren.

#include <Wire.h>                 // I2C communication library.
#include <TFT.h>                  // Library for TFT display.
#include <SPI.h>                  // SPI communication library.
#include <DHT.h>                  // Library for DHT11 module.

Nachdem wir die Bibliotheken hinzugefügt haben, müssen wir die verschiedenen Module konfigurieren. Wir beginnen mit dem TFT-Bildschirm. Wir müssen die Ports des Mikrocontrollers angeben, an die wir den Chip Select (cs), Datenleitung (dc) und das Reset-Signal (rst) senden werden.

// Connection from screen pins to microcontroller pins.

// Connection from screen pins to microcontroller pins.
#define cs   10                         // Chip Select.
#define dc   9                          // Data line.
#define rst  8                          // Reset.
TFT TFT_greenhouse = TFT(cs, dc, rst);  // Object implementation for the screen.

Das nächste Modul, das wir konfigurieren werden, ist der DHT-11-Sensor. In diesem Fall müssen wir die Art des Moduls und den Verbindungsport im Mikrocontroller angeben.

#define DHTTYPE DHT11
#define DHTPIN 2 
DHT dht(DHTPIN, DHTTYPE);

Zur Speicherung von Luftfeuchtigkeits- und Temperaturdaten definieren wir zwei Variablen.

float humi; 
float temp;

In diesem Projekt werden wir den TFT-Bildschirm auf die einfachste Art und Weise verwenden, denn wir werden nur Zeichen darauf anzeigen, so dass wir keine weitere Bibliothek hinzufügen müssen. Es ist notwendig, zwei Arrays vom Typ "char" mit einer Länge von 5 Zeichen zu definieren, um die Umwandlung von numerischen Daten in Zeichen der beiden vorhergehenden Variablen zu speichern und sie auf dem TFT-Bildschirm anzeigen zu können.

char humidity[5];
char temperature[5];

Wir müssen die Methoden zum Lesen und Schreiben der Register des Bodenfeuchtesensors implementieren. Wie aus der Dokumentation hervorgeht, belegen die von den Sensoren gelesenen Feuchtigkeitsdaten zwei Bytes, während wir für den Reset keine benötigen. Um den Sensor zu initialisieren, müssen wir also die Methode writeI2CRegister8bit ohne Rückgabewert (void) verwenden. Dazu müssen wir zunächst die Kommunikation mit dem Gerät über seine I2C-Adresse (addr) herstellen, das Register (value) angeben, auf das wir zugreifen und die Kommunikation mit dem Gerät beenden.

void writeI2CRegister8bit(int addr, int value) {
        Wire.beginTransmission(addr);
        Wire.write(value);
        Wire.endTransmission();
}

Um die Feuchtigkeit zu lesen, müssen wir die dazugehörige Methode implementieren. Ihr werden die I2C-Adresse des Moduls (addr), auf das wir zugreifen wollen und die Registernummer (reg), in der die erhaltenen Informationen gespeichert sind, übergeben. Diese Methode stellt zunächst die Kommunikation mit dem Sensor über dessen I2C-Adresse her (Wire.beginTransmission(addr)), greift auf die Registernummer zu (Wire.write(reg)), um die Feuchtigkeitsdaten zu übernehmen und die Kommunikation zu schließen. Dann hält das Programm 20 Mikrosekunden lang an und bittet das Gerät anschließend mit der Adresse (addr), 2 Byte Daten zu liefern. Um diese 2 Bytes zu lesen, erstellt es eine Variable t ohne Vorzeichen, liest die ersten 8 Bits (1 Byte) und verschiebt sie um 8 Stellen nach links (unsigned int t = Wire.read() << 8). Es werden dann die nächsten 8 Bits gelesen und die logische ODER-Verknüpfung mit den beiden 8-Bit-Daten durchgeführt (t = t | Wire.read()). Damit wird die 2-Byte-Zahl erhalten, die mit dem Bodenfeuchtigkeitswert zurückgegeben wird (return t).

unsigned int readI2CRegister16bit(int addr, int reg) {
        Wire.beginTransmission(addr);
        Wire.write(reg);
        Wire.endTransmission();
        delay(20);
        Wire.requestFrom(addr, 2);
        unsigned int t = Wire.read() << 8;
        t = t | Wire.read();
        return t;
}

Um das PCA9548A-Multiplexermodul zu verwenden, müssen wir eine Methode zur Auswahl der Kanäle implementieren, an die wir die Messfühler anschließen. Der erste Teil der Methode besteht darin, die Kommunikation mit dem Modul zu initialisieren, ihm die verwendete Kanalnummer zu senden und schließlich die Kommunikation mit dem Multiplexer zu abzuschließen.

void TCA9548A(uint8_t bus) {
          Wire.beginTransmission(0x70);
          Wire.write(1 << bus);
          Wire.endTransmission();
}

Nachdem wir die Bibliotheken eingebunden und die Objekte erstellt haben, um die erforderlichen Module, Variablen und Methoden verwenden zu können, müssen wir den Anfangszustand der gesamten Baugruppe konfigurieren, wenn sie zurückgesetzt oder eingeschaltet wird. Lassen Sie uns dazu die Methode setup() anschauen.

In den ersten beiden Zeilen initialisieren wir die I2C-Kommunikation und die Kommunikation mit der seriellen Konsole.

Wire.begin();
Serial.begin(9600);

In den nächsten beiden Zeilen initialisieren wir den TFT-Bildschirm und setzen die Hintergrundfarbe auf Schwarz.

TFT_greenhouse.begin();
TFT_greenhouse.background(0, 0, 0);

Auf dem Bildschirm werden wir einen dynamischen Text mit den Sensormesswerten und einen statischen Text mit den Namen der Daten anzeigen. In die setup()-Methode schreiben wir die statischen Daten. Auf diese Weise wird sich die loop()-Methode nur darauf konzentrieren, die dynamischen Werte der Sensoren zu lesen und sie auf dem Bildschirm anzuzeigen. Wir schreiben die Zeilen, für die Farbe, Größe, Position des Textes und den zu auszugebenden Text. Die Beschreibung dieser Zeilen ist im Sketch ausführlich dargestellt.

TFT_greenhouse.stroke(4, 255, 33);
TFT_greenhouse.setTextSize(2);
TFT_greenhouse.text("GREENHOUSE", 17, 0);
TFT_greenhouse.line(17, 16, 135, 16);

TFT_greenhouse.setTextSize(1);
TFT_greenhouse.stroke(16, 93, 209);
TFT_greenhouse.text("SOIL HUMIDITY", 0, 23);
TFT_greenhouse.stroke(255, 255, 255);
TFT_greenhouse.text("Probe 1: ", 0, 33);
TFT_greenhouse.text("Probe 2: ", 0, 43);
TFT_greenhouse.text("Probe 3: ", 0, 53);

TFT_greenhouse.stroke(255, 255, 0);
TFT_greenhouse.text("GREENHOUSE PARAMETERS", 0, 88);
TFT_greenhouse.stroke(255, 255, 255);
TFT_greenhouse.text("Humidity: ", 0, 98);
TFT_greenhouse.text("%", 102, 98);
TFT_greenhouse.text("Temperature: ", 0, 108);
TFT_greenhouse.text("degrees", 102, 108);

Nachdem wir den Ausgabetext konfiguriert haben, setzen wir die Bodenfeuchtesensoren zurück, um die gespeicherten Messungen zu löschen und neue Messungen vorzunehmen. Zuerst müssen wir den Kanal aufrufen, an dem der Sensor angeschlossen ist und dann den Rücksetzbefehl senden. Es handelt sich, wie in der Registertabelle zu sehen ist, um Register 6. Wir müssen dies mit allen Sensoren tun.

TCA9548A(0);
writeI2CRegister8bit(0x20, 6);

TCA9548A(1);
writeI2CRegister8bit(0x20, 6);

TCA9548A(2);
writeI2CRegister8bit(0x20, 6);

In der nächsten Zeile stellen wir ein, dass von nun an alle Texte, die auf den Bildschirm geschrieben werden (dynamischer Text mit Sensordaten), eine Größe von 1 haben werden. Wir starten außerdem den DHT-11-Sensor.

TFT_greenhouse.setTextSize(1);  // Set the font size.
dht.begin();  // Initialization of the temperature and humidity sensor DHT-11.

Jetzt müssen wir nur noch die Mikrocontroller-Ports als Ausgang konfigurieren, an die wir das Relaismodul anschließen werden. Der Ausgangszustand muss auf HIGH gestellt sein, so dass 5 Vdc. anliegen.

pinMode(3, OUTPUT);        // Pin 3 of the microcontroller connected to relay 1.
digitalWrite(3, HIGH);     // Initial state of relay 1 low level.
pinMode(4, OUTPUT);        // Pin 3 of the microcontroller connected to relay 2.
digitalWrite(4, HIGH);     // Initial state of relay 2 low level.
pinMode(5, OUTPUT);        // Pin 3 of the microcontroller connected to relay 3.
digitalWrite(5, HIGH);     // Initial state of relay 3 low level.
pinMode(6, OUTPUT);        // Pin 3 of the microcontroller connected to relay 4.
digitalWrite(6, HIGH);     // Initial state of relay 4 low level.

Die nächste Methode, ist die Dauerschleife loop(). Wie bereits erwähnt, werden wir bei dieser Methode den Empfang der Daten von den Sensoren programmieren und sie auf dem TFT-Bildschirm anzeigen.

Um die Bodenfeuchtigkeitsdaten des ersten Sensors zu empfangen, muss zunächst der Kanal 0 des Moduls PCA9548A aufgerufen werden, an dem der Sensor angeschlossen ist.

TCA9548A(0);

Mit den folgenden Zeilen zeigen wir über die serielle Konsole die Daten des Kapazitätswertes des Bodensensors an. Um die Kapazitätsdaten zu erhalten, müssen wir die zuvor beschriebene Methode zum Lesen von 2 Bytes aus dem Sensor mit den Parametern der hexadezimalen Adresse dieses Sensors und der Nummer des Registers, auf das wir zugreifen wollen, aufrufen (readI2CRegister16bit(0x20, 0)). Anschließend eine Sekunde lang pausieren.

Serial.print(" TCA9548A(0) ");
Serial.print(readI2CRegister16bit(0x20, 0));
Serial.print(" capacitance, ");
delay(1000);

Bevor der aktuelle Bodenfeuchtigkeitsstatus angezeigt wird, muss der vorherige Status gelöscht werden. Um den vorherigen Status zu löschen, muss die Textfarbe des TFT-Displays auf die Hintergrundfarbe des Bildschirms (schwarz) eingestellt werden.

TFT_greenhouse.stroke(0, 0, 0);

Wir geben die drei möglichen Zustände des Bodens aus. Damit stellen wir sicher, dass alle Zeichen schwarz überschrieben werden und den Eindruck erwecken, gelöscht worden zu sein. Die Parameter sind der anzuzeigende Text und die Position auf der x- und y-Achse des Bildschirms.

TFT_greenhouse.text("Wet", 70, 33);
TFT_greenhouse.text("Optima", 70, 33);
TFT_greenhouse.text("Dry", 70, 33);

Um den Feuchtigkeitszustand des Bodens anzuzeigen, wird der Aufruf der Kapazitätsmessung in einen bedingten if-Block programmiert. Je nach dessen Wert wird der entsprechende Block ausgeführt.

Wenn der Kapazitätswert und damit die Bodenfeuchtigkeit sehr hoch ist, wird der erste Block ausgeführt. Der Boden muss nicht bewässert werden. Dann zeigen wir die Nachricht zunächst über die serielle Konsole und dann auf dem Bildschirm an. Dafür stellen wir die Textfarbe auf Rot und den Text "Wet" in den X- und Y-Koordinaten des Bildschirms ein. Da er nicht bewässert werden muss, ändert sich der Anschluss des Mikrocontrollers an das Relaismodul, das diesem Sensor entspricht, nicht und bleibt im High-Zustand.

if (readI2CRegister16bit(0x20, 0) > 527) {
  Serial.println(" Plant Soil Moisture 0 humid");
  TFT_greenhouse.stroke(0, 0, 255);
  TFT_greenhouse.text("Wet", 70, 33);
  digitalWrite(3, HIGH);
}

Der zweite if-Block wird ausgeführt, wenn der Kapazitätswert zwischen 466 und 527 liegt, was bedeutet, dass die Bodenfeuchtigkeit korrekt ist und auch nicht bewässert werden muss. Wie im vorherigen Block wird die Meldung auf der seriellen Konsole und auf dem TFT-Bildschirm angezeigt, wobei die Textfarbe Grün ist. Der Status des mit dem Relaismodul verbundenen Mikrocontroller-Ports ändert sich ebenfalls nicht.

if (readI2CRegister16bit(0x20, 0) > 465 && readI2CRegister16bit(0x20, 0) < 528) {
  Serial.println(" Plant Soil Moisture 1 correct");
  TFT_greenhouse.stroke(0, 255, 0);
  TFT_greenhouse.text("Optima", 70, 33);
  digitalWrite(3, HIGH);
} 

Der dritte if-Block wird ausgeführt, wenn der Kapazitätswert kleiner als 466 ist. Das bedeutet, dass der Boden trocken ist und bewässert werden muss. Wie in den vorangegangenen Fällen wird zunächst die Meldung auf der seriellen Konsole und dann die Meldung "Dry" in gelber Farbe auf dem TFT-Bildschirm angezeigt. In diesem Fall muss die Pflanze bewässert werden. Der Anschluss, an dem das Relaismodul angeschlossen ist, wechselt von einem HIGH in einen LOW Zustand. Das führt dazu, dass das Relais, das in unserem Schaltkreis das Ventil der Wasserleitung steuert, aktiviert wird. Dieses würde sich öffnen und das Wasser würde die Pflanze bewässern, bis der Feuchtigkeitssensor einen Wert von mehr als 466 anzeigt und einer der vorherigen Blöcke ausgeführt wird.

if (readI2CRegister16bit(0x20, 0) < 466) {
  Serial.println(" Plant Soil Moisture 1 dry");
  TFT_greenhouse.stroke(0, 255, 255);
  TFT_greenhouse.text("Dry", 70, 33);
  digitalWrite(3, LOW);
} 

Für jeden der drei Sensoren werden diese drei Blöcke nacheinander ausgeführt.

Nach der Messung der Bodenfeuchtigkeit mit den drei Sensoren müssen wir die Daten der relativen Luftfeuchtigkeit und der Temperatur mit dem DHT-11-Sensor ablesen und sie auf dem TFT-Bildschirm anzeigen.

Zuerst geben wir die Luftfeuchtigkeit aus. Wir löschen die Daten der vorherigen Messung, lesen die neuen Daten aus und zeigen sie auf dem Bildschirm an. Der Löschvorgang entspricht dem aus dem vorherigen Abschnitt zur Ausgabe der Bodensensorwerte. Als Erstes muss die Farbe des Textes mit der des Hintergrunds (schwarz) übereinstimmen und die Reihe der Zeichen, die den Feuchtigkeitswert darstellt, muss erneut geschrieben werden. Anschließend wird der neue Text farblich dargestellt.

TFT_greenhouse.stroke(0, 0, 0);
TFT_greenhouse.text(humidity, 75, 98);

Als Nächstes müssen die vom DHT-11-Sensor gemessenen Feuchtigkeitsdaten in der Variablen humi gespeichert werden. Diese Variable enthält float-Daten. Wir zuerst den numerischen Wert in eine Zeichenkette umwandeln und dann die Zeichenkette in ein Array von 5 Feuchtigkeitszeichen (zwei alphanumerische Zeichen, ein Punkt und zwei weitere alphanumerische Zeichen) schreiben. Danach können wir die Zeichen in Weiß an den X- und Y-Koordinaten auf dem TFT-Bildschirm darstellen.

humi = dht.readHumidity();
String convert_humi = String(humi);
convert_humi.toCharArray(humidity, 5);
TFT_greenhouse.stroke(255, 255, 255);
TFT_greenhouse.text(humidity, 75, 98);

Der letzte Wert, den wir darstellen müssen, ist die Umgebungstemperatur. Der Ablauf ist der gleiche, wie für die Luftfeuchtigkeit. "Löschen" der vorherigen Temperaturdaten, aktuellen Wert auslesen und anzeigen auf dem TFT-Bildschirm. Der Lüfter wird abhängig von den Werten aktiviert, um dem Gewächshaus Frischluft zuzuführen.

Mit dem gleichen Ablauf wie vorher „löschen“ wir den Text für die Temperatur auf dem Display. Wir speichern den aktuellen Wert der Temperatur in der Variable temp, die als float konfiguriert ist.

Um den Lüfter zu aktivieren, müssen wir den Zustand des entsprechenden Mikrocontroller-Pins ändern, an den das Relais angeschlossen ist. Dafür implementieren wir einen if-else-Block. Wenn der Wert der Variablen temp über 32.5 Grad steigt, wird der if-Zweig ausgeführt und der Zustand des Pins ändert sich von HIGH nach LOW. Damit aktiviert das Relaismodul das entsprechende Relais, wodurch am Lüfter Spannung anliegt. Wenn der Wert der gleichen Variablen nicht über 25.5 Grad steigt, wird der else-block ausgeführt, in dem der Zustand des Pins auf HIGH gesetzt und der Lüfter über das Relais ausgeschaltet wird (oder bleibt).

if (temp > 25.5) {                                        
  digitalWrite(6, LOW);
} else { digitalWrite(6, HIGH);
       }

Wie bei der Luftfeuchtigkeit müssen wir zunächst die Variable temp vom Typ float in die Variable convert_temp vom Typ String umwandeln und dann die Zeichenkette in das 5-Zeichen-Array temperature schreiben. Wir setzen die Farbe des Textes auf weiß und zeichnen ihn auf dem TFT-Bildschirm an den X- und Y-Koordinaten des Bildschirms.

String convert_temp = String(temp);
convert_temp.toCharArray(temperature, 5);
TFT_greenhouse.stroke(255, 255, 255);
TFT_greenhouse.text(temperature, 75, 108);

Der letzte Block ist eine bedingte if-Abfrage, die prüft, ob der DHT-11-Sensor funktionsfähig ist. Wenn er keine Temperatur- oder Feuchtigkeitsdaten zurückgibt, werden auf dem Bildschirm einige Striche an den X- und Y-Koordinaten an.

if (isnan(humi) || isnan(temp)) {
  TFT_greenhouse.stroke(255, 255, 255);             
  TFT_greenhouse.text("----", 75, 78);              
  TFT_greenhouse.text("----", 75, 88);              
  return;
}

Sketch Download

Dieser Blogbeitrag ist ein Beispiel dafür, wie eine Bewässerung und Lüftung in einem kleinen Gewächshaus mit Pflanzen und Blumen für den Innenbereich umgesetzt werden kann. Ich hoffe, dass es Ihnen gefallen hat und dass Sie uns Ihre Kommentare und Erfahrungen mit dem Bau des Systems mitteilen werden.