Automatische Pflanzenbewässerung: Schaltungsdesign, Code & Projektreport

Automatische Pflanzenbewässerung – Voller Quellcode, Schaltung & Projektreport – PDF-Download

Einführung

Tägliche Bewässerungsarbeiten sind die wichtigste kulturtechnische Praxis und die arbeitsintensivste Aufgabe. Egal ob zu heiß, kalt, trocken oder nass – die Wassermenge, die die Pflanzen erreicht, muss kontrolliert werden. Ein automatisches Pflanzenbewässerungssystem, das Pflanzen bedarfsgerecht wässert, ist daher effektiv. Ein zentraler Aspekt: „Wann und wie viel wässern“. Um manuelle Arbeit zu reduzieren, wird ein solches System eingesetzt. Es überwacht kontinuierlich die Bodenfeuchte, entscheidet, ob und wie viel Wasser benötigt wird. Das Projekt gliedert sich in Teilsysteme: Stromversorgung, Relais, Magnetventil, Arduino GSM-Shield, Bodenfeuchtesensor, LCD.

Das System ist so konzipiert und programmiert, dass der Bodenfeuchtesensor zu einem bestimmten Zeitpunkt die Feuchte misst. Ist der Wert unter einem vordefinierten Schwellenwert (je nach Pflanzenbedarf), wird Wasser zugeführt, bis der Schwellenwert erreicht ist.

Das System meldet seinen Status und sendet Erinnerungen per SMS (Bewässerung, Wassertank nachfüllen) über das Arduino GSM-Shield.

• Verwandtes Projekt: Regenalarm-Schaltung – Schnee, Wasser & Regendetektor

Projektziel

Im Zeitalter fortschrittlicher Technologie sollte der Lebensstil smart, einfach und bequem sein. Automatisierte Systeme reduzieren tägliche Aufgaben. Die automatische Pflanzenbewässerung hilft Millionen Menschen, besonders bei Abwesenheit. Das System misst Bodenfeuchte, vergleicht mit Schwellenwert, steuert Magnetventil über Arduino. Zusätzlich überwachen Temperatur- und Feuchtesensoren die Umgebungsbedingungen. Das GSM-Shield sendet Statusmeldungen und empfängt SMS.

• Verwandtes Projekt: Wasserstandsanzeige – Zwei einfache Projekte

Systemhintergrund

Pflanzen sind für die Menschheit essenziell (Sauerstoffproduktion). Automatische Bewässerungssysteme verbreiten sich durch IoT und vernetzte Objekte rasant – im privaten wie industriellen Bereich. Hauptvorteile: Effizienz und einfache Bedienung.

Pflanzenliebhaber können ihre Pflanzen auch bei Abwesenheit betreuen – durch zuverlässige Sensortechnik.

Es gibt verschiedene Arten von Zimmerpflanzen-Bewässerungssystemen, je nach Automatisierungsgrad.

• Verwandtes Projekt: Smart Irrigation System – Schaltplan & Code

Im finalen PDF-Report (kostenloser Download am Ende) werden folgende Abschnitte detailliert beschrieben:

• Pflanzenbewässerungs-Kugeln & Spikes
• Innenraum-Tropfbewässerung
• Sensortechnik
• Temperatur- & Feuchtesensoren
• Temperatursensoren
• Feuchtesensoren
• Bodenfeuchtesensoren
• Bimetall-Thermostat
• Thermistor
• Widerstandstemperaturdetektoren (RTD)
• Thermoelemente
• Sensor-ICs, LM35
• Digitaler Temperatursensor (ADT7301)
• DHT11 und DHT22
• GSM-Modul
• GSM-Architektur
• Relais
• Transistor
• Hitachi 16×2 LCD

Verwandtes Projekt: Was sind ATMega-Mikrocontroller & wie macht man ein LED-Projekt damit?

Produkt- & Komponentenspezifikationen

Anforderungs-ID	SRS-GSM-001
Titel	GSM-Modul
Beschreibung	System beinhaltet GSM-Modul, sendet Alarm-SMS an Empfänger, empfängt SMS vom Benutzer.
Version	1.0

Anforderungs-ID	SRS-Mikrocontroller-001
Titel	ATmega328p
Beschreibung	System beinhaltet Mikrocontroller (Arduino Uno). Liest Sensorwerte, steuert Gesamtsystem.
Version	1.0

Anforderungs-ID	SRS-TempFeuchte-001
Titel	DHT11
Beschreibung	System beinhaltet Temperatur- & Feuchtesensor, misst Umgebungswerte, sendet an Mikrocontroller.
Version	1.0

Anforderungs-ID	SRS-Feuchte-001
Titel	Grove Bodenfeuchtesensor
Beschreibung	System beinhaltet Bodenfeuchtesensor, misst Bodenfeuchte, sendet an Mikrocontroller.
Version	1.0

Anforderungs-ID	SRS-LCD-001
Titel	Hitachi 16×2 LCD
Beschreibung	System beinhaltet LCD-Schnittstelle für Benutzer, zeigt Sensorwerte an.
Version	1.0

Verwandter Beitrag: Arduino-Programmierung: Was ist Arduino und wie programmiert man es?

Arduino-basiertes automatisiertes Pflanzenbewässerungssystem

Blockdiagramm der automatischen Pflanzenbewässerung

Schaltplan der automatischen Pflanzenbewässerung & Bewässerungssystem

Zwei funktionale Komponenten: Feuchtesensor und Motor/Wasserpumpe. Feuchtesensor misst Bodenfeuchte, Motor/Pumpe versorgt Pflanzen.

Bild anklicken zum Vergrößern

Der Schaltplan beschreibt das Systemverhalten. Arduino Uno steuert Motor über H-Brücke (Drehrichtung). Feuchtesensor misst Bodenfeuchte, sendet Signal an Arduino, dieser öffnet Servomotor bei Bedarf. Motor/Pumpe versorgt Pflanzen bis gewünschter Feuchtewert erreicht.

Im Prototyp misst Feuchtesensor Feuchte, sendet Signal an Arduino, dieser öffnet Wasserpumpe über H-Brücke und bewässert die Pflanze. Realisiert mit Arduino IDE.

Verwandtes Projekt: Ampelsteuerung mit IC 4017 & 555 Timer

Projektdesign

Dieser Abschnitt behandelt Software- und Hardwaredesign, Systemkomponenten und Begründung der Auswahl. Das Blockdiagramm zeigt das konzeptionelle Modell.

Funktionalität des Blockdiagramms:

• GSM-Modul sendet/empfängt SMS.
• Bodenfeuchte-, Temperatur- & Feuchtesensoren.
• Magnetventile mit Steuerschaltung für Wasserdurchfluss.
• Feuchtesensor bestimmt Pflanzenfeuchte. Mikrocontroller prüft in Schleife, ob Wert über Schwellenwert liegt. Wenn ja, sendet GSM SMS.
• Temperatur- & Feuchtesensor prüft, ob zu heiß/feucht. ATmega328p (Arduino Uno) liest Werte, entscheidet über Magnetventil-Steuerung.

Weitere Komponentendetails im PDF (unten).

Verwandtes Projekt: Was ist Raspberry Pi? Projekte mit Raspberry Pi

Hardwaredesign

Sensorschaltung

Schema der Sensorschaltung. Alle Sensoren an Arduino Analogpins A0–A3. Pin A0 für Temperatur/Feuchte, A1–A3 für Feuchtesensoren. Gemeinsame 5V-Versorgung und Masse.

LCD-Schaltung

Schema des LCD. Digitalpins 8–13 für LCD. Pin 1 & 3: Versorgung & Masse, Pin 2: Kontrast (Potentiometer). Wichtig: Arduino-Digitalpins und LCD-Datenpins in korrekter Reihenfolge verbinden, sonst Müllanzeige.

Magnetventil-Schaltung

Schaltplan der Magnetventil-Schaltung. Digitalpins 4–7 für Magnetventile. Relais, Transistoren, Widerstände, LEDs statt Magnetventile (CadStar hat kein Magnetventil-Symbol). Relais nutzen 5V, 5V auch an NO-Kanal der Relais (LEDs arbeiten mit 5V + 220Ω Vorwiderstand).

• Verwandtes Projekt: Spracherkennungs-basierte Hausautomation

Bei Spannung an Transistorbasis: Transistor schaltet durch → Relaisspule magnetisiert → Relais schaltet auf NC-Kanal → LED an. Spannung fällt ab → Transistor sperrt → Relaisspule entmagnetisiert → Relais schaltet zurück auf NO → LED aus.

Nach Fertigstellung aller Schematics: Aufbau auf Streifenrasterplatine (Veroboard). Wichtig: Layout vorher auf Planungsbogen entwerfen (Prinzipien: Vcc/GND-Leitungen oben rechts markieren, IC-Pin-Trennungen kennzeichnen, Bauteile flach verlegen, IC-Pins nummerieren, Kupferbahnen horizontal).

Verwandtes Projekt: Vollautomatische Wasserstandssteuerung mit SRF04

Softwaredesign

Nach Hardwarefertigstellung: Test mit Software. Implementierung detailliert für jede Automatisierungstechnologie. Enthält Arduino-Code (Upload auf Arduino).

Zuerst: Magnetventil-Schaltung testen (Flussdiagramm im Software-Flow-Abschnitt). Einfaches Programm: LED blinkt jede Sekunde. Digitalpins 4–7 definiert, Initialisierung in void setup(), Blinken in void loop().

Dann: Sensorwerte auslesen & auf LCD anzeigen (Flussdiagramm im Software-Flow). In void loop() Sensoren auslesen, Berechnungen, LCD-Ausgabe.

Verwandtes Basisprojekt: Automatische Straßenlaternensteuerung mit LDR & BC547

Dann: GSM-Modul-Software hochladen. Modem-Test (Initialisierung, Bibliotheken, IMEI, Funktionstest). Netzwerkverbindungstest (GSM-Initialisierung, unterstützte Netze).

Nach GSM-Test: Kommunikation mit Empfänger (SMS senden/empfangen). Zwei Arduino-Programme: SMS senden & SMS empfangen.

Schließlich: Alle Softwaremodule zusammenführen → finales funktionierendes System. Verschiedene Algorithmen (siehe Software-Flow). Abbildung zeigt finale Software: Messung, SMS senden/empfangen, Wiederholung.

Hinweis: Alle Softwarecodes im Anhang (unten).

HINWEIS: Modem-Test- & Netzwerktest-Ausgaben nicht im Report enthalten (Report nach Hardwareabgabe erstellt).

Verwandtes Projekt: Elektrische & Elektronik-Basics in LabVIEW

Projektbau & Softwaretest

Nach erfolgreichem Hard- & Softwaredesign: Bau & Test. Details zu Implementierung, Test, Fehlerbehebung im vollständigen PDF-Report (Schritt-für-Schritt).

Softwaretest

Softwaretestphase ist wichtig. Ziel: Softwarefehler finden, Validierung & Verifikation gegen technische Anforderungen. Verschiedene Ansätze: Software Requirements Specification (SRS) dokumentiert erwartetes Systemverhalten.

Verwandtes Projekt: Klatschschalter mit 555 Timer

Anforderungs-ID	SRS-Sensor-010
Titel	Sensor
Beschreibung	Sensoren nehmen Messwerte auf, senden an Mikrocontroller.
Version	V 1.0

Anforderungs-ID	SRS-Daten-020
Titel	Datenanzeige
Beschreibung	Benutzer fordert Messwerte an → Anzeige zeigt Temperatur, Feuchte, Feuchtemesswerte.
Version	V1.0

Anforderungs-ID	SRS-Mikrocontroller-030
Titel	Mikrocontroller
Beschreibung	Mikrocontroller als „Gehirn“ verwaltet alles im System.
Version	V1.0

Anforderungs-ID	SRS-Latch-040
Titel	Latch
Beschreibung	Latch erweitert Digitalpins des Mikrocontrollers.
Version	V1.0

Anforderungs-ID	SRS-GSM-050
Titel	GSM
Beschreibung	System sendet SMS-Alert an Empfänger auf Mikrocontroller-Befehl.
Version	V1.0

Nach SRS-Erstellung: Statische Testphase (Dokumentenreview). Verifikation der Anforderungen. Vier Verifikationsmethoden:

1. Inspektion (I): Sichtprüfung
2. Analyse (A): Analytische Nachweise
3. Demonstration (D): Betriebseigenschaften ohne quantitative Messung
4. Test (T): Quantitative Messung

Für jede SRS-Anforderung wird Verifikationsmethode (I, A, D, T) definiert.

Verifikation:

Anforderungs-ID	Anforderungstitel	Methode
REQ-010	Prüfen, ob Sensoren Messwerte liefern	I
REQ-020	Prüfen, ob Daten auf Bildschirm angezeigt werden	D
REQ-030	Prüfen, ob Mikrocontroller ordnungsgemäß arbeitet (100% Ergebnis)	D
REQ-040	Prüfen, ob Latch-Schaltung 3 Eingänge nimmt, 8 Ausgänge liefert	A
REQ-050	Prüfen, ob SMS per GSM gesendet & empfangen wird	D

Ergebnisse

Alle Tests mit zufriedenstellendem Ergebnis. Keine besonderen Dokumentationsergebnisse. System arbeitet mit Feuchte- & DHT11-Sensor (Temperatur/Feuchte), Messwerte hängen von aktueller Raumtemperatur/Feuchte und Pflanzenfeuchte ab. Gesamtfunktionalität gut.

Verwandter Beitrag: Arduino PWM-Programmierung & Funktionen

Finaler & vollständiger Softwarecode für automatische Pflanzenbewässerung & Bewässerungssysteme

Hinweis: Weitere Codes im PDF (Testcode Magnetventil, Sensortest, GSM-Modem-Test, GSM-Netzwerktest, GSM-SMS-senden, GSM-SMS-empfangen).

Finaler Auto-Bewässerung Pflanzen Projektcode

#include <dht.h>
#define dht_dpin A0
dht DHT;
//———————–
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 10, 11, 12, 13);
//———————————-
int plantPotMoisture[3] = {A1, A2, A3};
//———————
#include <GSM.h>
#define PINNUMBER ""
GSM gsmAccess;
GSM_SMS sms;
char remoteNumber[] = "0899506304";
String moistureMessage = "Moisture is Low on sensor: ";
String SMS_Alert = "Sending SMS!";
String humidityMsg = "Humidity is High. Open All Solenoids";
String tempMsg = "Temperature is too HIGH!..Open ALl Solenoids ";
String messageBuffer = "";
char senderNumber[20];
String stringOne = "Opens1";
String stringTwo = "Opens2";
String stringThree = "Opens3";
String stringFour = "OpenAll";
//—————
#define solenoidData 5
#define solenoidClockster 4
#define solenoidLatch 6
//—————
const int master = 0;
const int slave1 = 1;
const int slave2 = 2;
const int slave3 = 3;
boolean takeReadings = true;
int serialSolenoidOutput = 0;

void setup() {
  pinMode(solenoidData, OUTPUT);
  pinMode(solenoidClockster, OUTPUT);
  pinMode(solenoidLatch, OUTPUT);
  digitalWrite(solenoidLatch, HIGH);
  digitalWrite(solenoidLatch, LOW);
  shiftOut(solenoidData, solenoidClockster, MSBFIRST, 0);
  digitalWrite(solenoidLatch, HIGH);
  //————————-
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Wait Until");
  lcd.setCursor(0, 1);
  lcd.print("GSM Initialized!");
  boolean notConnected = true;
  while (notConnected) {
    if (gsmAccess.begin(PINNUMBER) == GSM_READY) notConnected = false;
    else {
      Serial.println("Not connected");
      delay(1000);
    }
  }
}

void loop() {
  if (takeReadings) {
    moistureSensor();
    TempAndHumidity();
    if (DHT.humidity > 50 || DHT.temperature > 25 && takeReadings) {
      takeReadings = false;
      if (DHT.humidity > 50) {
        sendSMS(humidityMsg);
      } else if (DHT.temperature > 25) {
        sendSMS(tempMsg);
      }
      while (!takeReadings) recieveSMS();
    }
    if (plantPotMoisture[0] > 30 || plantPotMoisture[1] > 30 || plantPotMoisture[2] > 30 && takeReadings) {
      takeReadings = false;
      if (plantPotMoisture[0] > 30) {
        sendSMS(moistureMessage + "1");
      } else if (plantPotMoisture[1] > 30) {
        sendSMS(moistureMessage + "2");
      } else {
        sendSMS(moistureMessage + "3");
      }
      while (!takeReadings) recieveSMS();
    }
  }
}

void moistureSensor() {
  for (int i = 0; i < 3; i++) {
    lcd.clear();
    plantPotMoisture[i] = analogRead(i);
    plantPotMoisture[i] = map(plantPotMoisture[i], 550, 0, 0, 100);
    Serial.print("Moisture" + i);
    lcd.print("Moisture" + i);
    Serial.print(plantPotMoisture[i]);
    lcd.print(plantPotMoisture[i]);
    Serial.println("%");
    lcd.print("%");
    delay(1000);
  }
}

void TempAndHumidity() {
  DHT.read11(dht_dpin);
  lcd.setCursor(0, 0);
  lcd.print("Humidity=");
  Serial.print("Current humidity = ");
  Serial.print(DHT.humidity);
  lcd.print(DHT.humidity);
  lcd.print("%");
  Serial.print("%");
  Serial.print("temperature = ");
  Serial.print(DHT.temperature);
  Serial.println("C");
  lcd.setCursor(0, 1);
  lcd.print("temp=");
  lcd.print(DHT.temperature);
  lcd.print("C ");
  delay(1000);
  lcd.clear();
}

void sendSMS(String messageToSend) {
  Serial.print("Sending a message to mobile number: ");
  Serial.println(remoteNumber);
  Serial.println("SENDING");
  lcd.print(SMS_Alert);
  Serial.println();
  Serial.println("Message:");
  Serial.println(messageToSend);
  sms.beginSMS(remoteNumber);
  sms.print(messageToSend);
  sms.endSMS();
  Serial.println("\nCOMPLETE!\n");
  lcd.clear();
  lcd.print("Completed!!!");
}

void recieveSMS() {
  char c;
  if (sms.available()) {
    lcd.clear();
    lcd.print("Message received from:");
    delay(800);
    lcd.clear();
    sms.remoteNumber(senderNumber, 20);
    lcd.print(senderNumber);
    while (c = sms.read()) {
      Serial.println(c);
      messageBuffer += c;
    }
    Serial.println(messageBuffer);
    if (messageBuffer == stringOne) {
      toggleSolenoid1();
      takeReadings = true;
    } else if (messageBuffer == stringTwo) {
      toggleSolenoid2();
      takeReadings = true;
    } else if (messageBuffer == stringThree) {
      toggleSolenoid3();
      takeReadings = true;
    } else if (messageBuffer == stringFour) {
      toggleAll();
      takeReadings = true;
    } else {
      takeReadings = true;
    }
    messageBuffer = "";
    Serial.println("\nEND OF MESSAGE");
    sms.flush();
    Serial.println("MESSAGE DELETED");
  }
  delay(1000);
}

void toggleSolenoid1() {
  solenoidWrite(master, HIGH);
  delay(1000);
  solenoidWrite(slave1, HIGH);
  delay(1000);
  solenoidWrite(slave1, LOW);
  delay(1000);
  solenoidWrite(master, LOW);
  delay(1000);
}

void toggleSolenoid2() {
  solenoidWrite(master, HIGH);
  delay(1000);
  solenoidWrite(slave2, HIGH);
  delay(1000);
  solenoidWrite(slave2, LOW);
  delay(1000);
  solenoidWrite(master, LOW);
  delay(1000);
}

void toggleSolenoid3() {
  solenoidWrite(master, HIGH);
  delay(1000);
  solenoidWrite(slave3, HIGH);
  delay(1000);
  solenoidWrite(slave3, LOW);
  delay(1000);
  solenoidWrite(master, LOW);
  delay(1000);
}

void toggleAll() {
  solenoidWrite(master, HIGH);
  delay(1000);
  solenoidWrite(slave1, HIGH);
  delay(1000);
  solenoidWrite(slave2, HIGH);
  delay(1000);
  solenoidWrite(slave3, HIGH);
  delay(1000);
  solenoidWrite(slave1, LOW);
  delay(1000);
  solenoidWrite(slave2, LOW);
  delay(1000);
  solenoidWrite(slave3, LOW);
  delay(1000);
  solenoidWrite(master, LOW);
  delay(1000);
}

void solenoidWrite(int pin, bool state) {
  if (pin >= 0 && pin < 8) {
    if (state) serialSolenoidOutput |= (1 << pin);
    else serialSolenoidOutput &= ~(1 << pin);
  }
  digitalWrite(solenoidLatch, LOW);
  shiftOut(solenoidData, solenoidClockster, MSBFIRST, serialSolenoidOutput);
  digitalWrite(solenoidLatch, HIGH);
}

Vollständiger Projektreport Automatische Pflanzenbewässerung (PDF) Kostenloser Download

• Titel: Automatisierte Pflanzenbewässerung System PDF
• Format: PDF
• Größe: 4,18 MB
• Seiten: 77
• Download: Hier

Verwandter Beitrag: PCB-Design Schritt für Schritt & bildlich

Über den Autor

-Department of Engineering, School of Informatics & Engineering, Institute of Technology, Blanchardstown, Dublin 15