Bewässerungssytem für Balkonpflanzen

Aus HSHL Mechatronik
Version vom 18. Januar 2024, 11:54 Uhr von Dieter-Jürgen Heimann (Diskussion | Beiträge) (→‎Lessons Learned)
(Unterschied) ← Nächstältere Version | Aktuelle Version (Unterschied) | Nächstjüngere Version → (Unterschied)
Zur Navigation springen Zur Suche springen

Autoren: Oliver Aust, Jürgen Heimann
Betreuer: Prof. Schneider


→ zurück zur Übersicht: WS 20/21: Angewandte Elektrotechnik (BSE)

→ zurück zur Übersicht: WS 21/22: Angewandte Elektrotechnik (BSE)

→ zurück zur Übersicht: WS 22/23: Angewandte Elektrotechnik (BSE)

→ zurück zur Übersicht: WS 23/24: Angewandte Elektrotechnik (BSE)


Einleitung

Das Projekt "Bewässerungssystem für Balkonplanzen" entsteht im Rahmen des Praktikums "Fachpraktikum Elektrotechnik" im Studiengang Mechatronik (MTR).


Ziel des Projektes ist die Entwicklung eines automatischen Bewässerungssystems, welches sowohl den Füllstand des Wasserbehälters als auch die Bodenfeuchtigkeit und den individuellen Wasserbedarf diverser Balkonplanzen berücksichtigt.

Das Projekt wurde mit Hilfe des V-Modells (siehe Abb.1) in verschiedene Etappen eingeteilt. Anhand dessen wurde ein Projektverlaufsplan mit den zu erreichenenden Meilensteinen erstellt erstellt.

Abb.1 V-Modell automatisches Bewässerungssystem

Anforderungen

Um dieses Projekt zu realisieren müssen folgende Anforderungen erfüllt werden

Nr. Beschreibung Bereich Datum Status


1 Das Gehäuse (Arduino, Display, Kabelführung) muss wetterfest (IP65) sein Mechanik/Hardware 25.10.2023 i.O.
2 Das Gehäuse muss Platz für ein Kabelführungssystem,den Arduino Uno R3 und dem Display aufweisen Hardware 27.10.2023 i.O.
3 Das Gehäuse muss mit einem 9V Akku betrieben werden können Hardware 31.10.2023 i.O.
4 Der Füllstandssensor soll den Wasserfüllstand des Wasserbehälters in Echtzeit messen Hardware 31.10.2023 i.O.
5 Die Halterung für den Ultraschallsensor (HC-SR04) muss Spritzwasserfest (IP44) sein Hardware 04.11.2023 i.O.
6 Die Pumpe muss Wasser vom Kanister in den Blumentopf befördern Hardware 04.11.2023 i.O.
7 Der HC-SR04 muss den Wasserstand des Kanisters vor und während des Gießvorganges in Echtzeit messen Sensorik 04.11.2023 i.O.
8 Der Bodenfeuchtesensor soll den Feuchtigkeitsgrad der Erde im Blumentopf alle 5min messen Sensorik 07.11.2023 i.O.
9 Die Pumpe soll in Abhängigkeit der Bodenfeuchte und der Bewässerungsmenge, dem individuellen Bedarf der Planze, Wasser aus dem Behälter pumpen. Hardware 07.11.2023 i.O.
10 Die Programmierung des Regelkreises muss mit Matlab/Simulink erfolgen Software 14.11.2023 teilweise i.O.
11 Das Programm muss flexibel auf die indivduellen Bedrüfnisse der jeweiligen Pflanze einstellbar sein Software 04.12.2023 i.O.
12 Die Messdaten müssen auf dem Display angezeigt werden Software/Hardware 04.12.2023 i.O.
13 Es muss eine Excell Tabelle mit dem Wasserbedarf verschiedener Pflanzen erstellt werden Software/Dokumentation 04.12.2023 i.O.
14 Die Excelltabelle muss als Stellgröße in Matlab/Simulink fungieren Software 04.12.2023 Offen
15 Das Display muss Bewässerungsstand und bei zu geringem Füllstand "Wassertank auffüllen" anzeigen. Software/Hardware 04.12.2023 i.O.
16 Die Pumpe muss in Abhängikeit des Regelkreises aus Bodenfeuchte & Wasserstand geschaltet werden Software/Hardware 16.12.2023 i.O.
17 Es muss eine Dokumentation anhand des V-Modells in SVN erstellt werden Dokumentation 16.12.2023 i.O.
18 Es muss ein Plakate für die Messe erstellt werden Dokumentation 16.12.2023 i.O.
19 Es muss ein Video als Ergebnispräsentation erstellt werden Dokumentation 16.12.2023 i.O.

Tabelle 1: Auflistung der Anforderungen

Funktionaler Systementwurf/Technischer Systementwurf

Zur näheren Erläuterung wird der Systementwurf in Komponenten unterteilt:


  • Blumentopf und Pflanze: Der Bereich in dem der Bodenfeuchtesensor verbaut wird.
  • Gehäuse: Das Gehäuse dient als Halterung für den Arduino und zur Halterung des LCD-Displays, ebenfalls wird das Kabelführungssystem dorthin verlaufen.
  • Wasserführungssystem: Konstruktion für Schlauch und Pumpe mit Wasserführungssystem vom Behälter zum Blumentopf.
  • Bodenfeuchtesensor: Misst den Feuchtigkeitsbedarf der Pflanze.
  • Wasserstandssensor: Misst den Wasserstand in Echtzeit.
  • LCD-Display: Auf dem Display werden Messdaten und letzter Zeitpunkt der Bewässerung angezeigt.
  • Arduino: An den Arduino Mikrocontroller sind die genannten elektrischen Komponenten angebunden. Der Mikrocontroller führt den Algorithmus aus, er verarbeitet Messdaten und regelt entsprechend.
  • Spannungsquelle: Als Spannungsquelle für den Arduino mit Platine wird eine 9V-Block-Batterie eingesetzt.


Abbildung 2 ist das vereinfachte Blockschaltbild zusehen. In Abbildung 3 ist der Funktionale Systemaufbau zu sehen. Bei welchem die Komponenten und der schematische Datenfluss aufgezeigt ist. In Abb. 4 ist der technische Systementwurf mit sämtlichen Signalflüssen und dem Weg des Wassers zu sehen.

Abb.2 Blockschaltbild Systemaufbau
Abb.3 Funktionaler Systemaufbau
Abb.4 Technischer Systementwurf

Der Programmablaufplan (PAP) stellt die logische Basis des Programmierens dar.. Die Orangenen Klammern werden beim programmieren meist in for bzw. while schleifen realisiert. Die Abzweigungen werden meist als if Funktionen bzw. als switch case realisiert.

Abb.5 PAP Bewässerungssystem

Komponentenspezifikation

Tabelle 2: Komponentenliste
ID Komponente Beschreibung Bild
1 Arduino UNO
  • ATMega328 Prozessor
  • Versorgungsspannung: 7V-12V
  • Betriebsspannung: 5V
  • Pin-Belegung: 14 digitale Ein-/Ausgänge und 6 analoge Eingänge
mini
mini
2 1602-LCD Display
  • Betriebsspannung: 5V
mini
mini
3 Bodenfeuchtigkeitssensor
  • Sensor Kapazitiv
  • Ausgangsspannung: Analog
  • Versorgungsspannung: 5V
  • Maße: 22 x 97 x 9 mm
  • Leitungslänge: 190mm
mini
mini
4 HC-SR04
  • Sensor: Ultraschall
  • Stromaufnahme: 15mA
  • Versorgungsspannung: 5V
  • Maße: 45 x 20 x 15 mm
  • Messbereich: 2cm bis 400cm
  • Genauigkeit: +/-3mm
  • Arbeitsfrequenz: 40kHz
mini
mini
5 JZK DC 12V Wasserpumpe
  • Versorgunsspannung: 12V
  • Durchflussrate: 600-800l/h
mini
mini

Umsetzung (HW/SW)

3. Architektur


1.Verdrahtungspläne

In Abb. 6. finden sie den mit der Komponentenübersicht. In Abb. 7. den Schaltplan. Beide Abbildungen wurden mit Fritzek erstellt. Die 5 VDC Anschlüsse und GND wurden über ein Breadboard geschaltet. Die Signalleitungen, sehen sind im folgenden noch mal aufgelistet:

  • Ultraschallsensor HC-SR04: Echo --> 6 / Trig --> 7
  • Bodenfeuchtesensor Capacitive Soil Moisture Sensor v1.2: Aout --> A0
  • Relaise SRD-05VDC-SL-C: IN --> 8
  • Display 1602A mit LCM1602iic: SDA --> A5 / SCL --> A4


Abb.6 Verdrahtungsplan mit Komponentenübersicht
Abb.7 Verdrahtungsplan Schaltplan

2. Solidworks konstruktionen für die additive Fertigung.

In Abbildung 8 ist das Gehäuse für den Arduino mit Verschraubungsvorrichtung. In Abbildung 9 ist der Deckel des Gehäuses zusehen, mit der Verschraubungsvorrichtung für das Display.

Abb.8 Gehäusekonstruktion: Arduino Box
Abb.9 Gehäusekonstruktion: Deckel mit Aussparung für den Display

In Abbildung 10 ist die Ultraschallsensorhalterung, welche an den Wassertank befestigt wird.

Abb.10 US Sensorhalterung Deckel / Halter / Komplett

Komponententest

  • Bodenfeuchtesensor misst Feuchtigkeitswert des Bodens in Prozent in Echtzeit. (siehe Abb.12)
  • Ultraschallsensor misst die Entfernung in cm. in Echtzeit.(siehe Abb.13)
  • Die Wasserpumpe funktioniert.
  • Das Relaise schaltet.
  • Der Arduino und die Pumpe laufen mit jewils einen 9V Akku.
  • Das Display zeigt die Messwerte der Sensoren in Echtzeit an, den Status des Bewässerungsvorganges in M(essen),W(arten) oder B(ewässern) und falls der Füllstand des Wassertankes zu gering ist kommt die Aufforderung "Wassertank befüllen" (siehe Abb.14)
Abb. 12 Komponententest Bodenfeuchtesensor
Abb.13 Komponententest Ultraschallsensoor
Abb. 14 Display Kompnententest


Umsetzung Software

Die Komponententest konnten mit Matlab/Simulink erstellt werden. Ebenfalls konnte die grobe Funktionalität der Bewässerung, also das Zusammenspiel zwischen Ultraschallsensor, Bodenfeuchtesensor und der Pumpe, realisiert werden. Allerdings konnte die Einbindung des Displays über die I2C Schnittstelle nicht realisiert werden. Weshalb ich das System mit der Arduino IDE finalisiert habe. Im folgenden wird der Programm Code, Bewaesserung.ino, wassertank.h und pflanzentopf.h aufgezeigt. Bitte beachten, das vor jedem inlcude und define ein "#" anstatt die Zahl gehört. 

// Bewaesserung.ino
#include "pflanzentopf.h"
#include "wassertank.h"

#include <LiquidCrystal.h>

// Zustände
#define STATE_WARTEN 1
#define STATE_BODENFEUCHTE_MESSEN 2
#define STATE_PFLANZE_BEWAESSERN 3
#define STATE_WASSERTANK_LEER 4
byte state = STATE_WARTEN;



// Variablen Wartezeit
int LETZTE_ZEITMESSUNG = 0;
const int WARTEZEIT_ZEITMESSUNG = 2000; // in ms


// LCD Display
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void zeigeMesswerte(String status) {
  double bodenfeuchte = messeBodenfeuchte();
  double fuellstandTank = messeFuellstandTank();
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(String(bodenfeuchte, 2) + " %" + " " + status);
  lcd.setCursor(0, 1);
  lcd.print(String(fuellstandTank, 2) + " cm" + " " + status);
}

void zeigeWassertankLeer() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Wassertank");
  lcd.setCursor(0, 1);
  lcd.print("leer");
}



void setup() {
  Serial.begin(9600);
  Serial.print("Starte Bewässerungssystem");

  initBodenfeuchteSensor();
  initUltraschallSensor();
  initPumpe();
  
  lcd.begin(16, 2);
  lcd.clear();
  
  lcd.setCursor(0, 0);
  lcd.print("Starte");
  lcd.setCursor(0, 1);
  lcd.print("Bewaesserung");
  

  delay(2000);

  lcd.clear();

}

void loop() {

  switch(state) {
    case STATE_WARTEN: {
      // WENN ZEIT ABGELAUFEN IST -> BODENFEUCHTE MESSEN
      if (millis() - LETZTE_ZEITMESSUNG > WARTEZEIT_ZEITMESSUNG) {
        LETZTE_ZEITMESSUNG = millis();
        state = STATE_BODENFEUCHTE_MESSEN;
        Serial.println("STATE <STATE_BODENFEUCHTE_MESSEN>");
      }
    } break;
    case STATE_BODENFEUCHTE_MESSEN: {

      // WENN BODENFEUCHTE ZU GERING -> PFLANZE BEWÄSSERN
      // WENN BODENFEUCHTE AUSREICHEND -> ERNEUT WARTEN
      if (istBodenfeucheZuGering() == true){
        state = STATE_PFLANZE_BEWAESSERN;
        starteBewaesserung();
        Serial.println("STATE <STATE_PFLANZE_BEWAESSERN>");
      } else {
        LETZTE_ZEITMESSUNG = millis();
        state = STATE_WARTEN;
        Serial.println("STATE <STATE_WARTEN>");
      }
    } break;
    case STATE_PFLANZE_BEWAESSERN: {

      // WENN FÜLLSTAND DES WASSERTANK ZU GERING -> WARTEN AUF AUFFÜLLEN
      if (istFuellstandTankZuGering() == true) {
        stoppeBewaesserung();
        state = STATE_WASSERTANK_LEER;
        Serial.println("STATE <STATE_WASSERTANK_LEER>");
      }

      // WENN PFLANZE AUSREICHEND GEGOSSEN -> ERNEUT WARTEN
      if (istPflanzeAusreichendGegossen() == true) {
        stoppeBewaesserung();
        LETZTE_ZEITMESSUNG = millis();
        state = STATE_WARTEN;
        Serial.println("STATE <STATE_WARTEN>");
      }
    } break;
    case STATE_WASSERTANK_LEER: {
      // WENN FÜLLSTAND DES WASSERTANK NICHT MEHR ZU GERING -> ERNEUT WARTEN
      if (istFuellstandTankZuGering() == false) {
        LETZTE_ZEITMESSUNG = millis();
        state = STATE_WARTEN;
        Serial.println("STATE <STATE_WARTEN>");
      }
    } break;
  }

switch(state) {
    case STATE_WARTEN: {
      zeigeMesswerte("W");
    } break;
    case STATE_BODENFEUCHTE_MESSEN: {
      zeigeMesswerte("M");
    } break;
    case STATE_PFLANZE_BEWAESSERN: {
      zeigeMesswerte("B");
    } break;
    case STATE_WASSERTANK_LEER: {
      zeigeWassertankLeer();
    } break;
  }


}

Programmcode Bewaesserung.ino 

// pflanzentopf.h

// Parameter
#define MINIMALE_BODENFEUCHTE 60 // in %

#define BODENFEUCHTE_PIN A0






void initBodenfeuchteSensor() {
  pinMode(BODENFEUCHTE_PIN, INPUT);
}


double messeBodenfeuchte() {
  
  // MESSE 10 WERTE UND BERECHeNE DURCHSCHNITT
  double bodenfeuchte = 0.0;
  for (int i = 0; i < 10; i++) {
    bodenfeuchte = bodenfeuchte + analogRead(BODENFEUCHTE_PIN);
    delay(10);
  }
  bodenfeuchte = bodenfeuchte / 10.0;

  // WANDLE IN PROZENT (1024 = 10Bit Analog Auflösung)
  double prozent = (bodenfeuchte / 1024.0)*100.0;
  Serial.print("Bodenfeuchte = ");
  Serial.println(prozent);
  return prozent; // in %
}


bool istBodenfeucheZuGering() {
  double bodenfeuchte = messeBodenfeuchte();
  
  if (bodenfeuchte < MINIMALE_BODENFEUCHTE){
    return true;
  } else {
    return false;
  }
}

Unterprogramm pflanze.h 

// Parameter
#define WASSERTANK_Breite 14 // in cm
#define WASSERTANK_HOEHE 17 // in cm

#define MINIMALE_WASSER_HOEHE 2 // in cm
#define MAXIMALES_BEWAESSERUNGS_VOLUMEN 0.05 // in Liter

#define ULTRASCHALL_TRIGGER_PIN 7
#define ULTRASCHALL_ECHO_PIN 6

#define MOTOR_PIN 8

// Variablen
double fuellstandBewaesserungStart = 0.0;






void initUltraschallSensor() {
  pinMode(ULTRASCHALL_TRIGGER_PIN, OUTPUT);
  pinMode(ULTRASCHALL_ECHO_PIN, INPUT);
}


void initPumpe() {
  pinMode(MOTOR_PIN, OUTPUT);
}


double messeFuellstandTank() {
  digitalWrite(ULTRASCHALL_TRIGGER_PIN, LOW);
  delay(5);
  digitalWrite(ULTRASCHALL_TRIGGER_PIN, HIGH);
  delay(10);
  digitalWrite(ULTRASCHALL_TRIGGER_PIN, LOW);
  long zeitDifferenz = pulseIn(ULTRASCHALL_ECHO_PIN, HIGH); // Zeitdifferenz in us
  
  double distanz = WASSERTANK_HOEHE - (double(zeitDifferenz) / 2.0) * 0.03432; // in cm
  Serial.print("Fuellstand = ");
  Serial.println(distanz);
  return distanz; // in cm
}


bool istFuellstandTankZuGering() {
  double fuellstandTank = messeFuellstandTank();
  
  if (fuellstandTank < MINIMALE_WASSER_HOEHE){
    return true;
  } else {
    return false;
  }
}


void startePumpe() {
  digitalWrite(MOTOR_PIN, HIGH);
  Serial.println("StartePumpe");
}


void stoppePumpe() {
  digitalWrite(MOTOR_PIN, LOW);
}


void starteBewaesserung() {
  double fuellstandTank = messeFuellstandTank();
  fuellstandBewaesserungStart = fuellstandTank;

  startePumpe();
}


void stoppeBewaesserung() {
  fuellstandBewaesserungStart = 0.0;

  stoppePumpe();
}


double berechneGegosseneLiter() {
  double fuellstandTank = messeFuellstandTank();
  double hoehe = fuellstandBewaesserungStart - fuellstandTank;
    Serial.print(" fuellstandBewaesserungStart");
 Serial.println( fuellstandBewaesserungStart);
  Serial.print("Fuellstand");
 Serial.println(fuellstandTank);
   Serial.print("hoehe: ");
 Serial.println(hoehe);
  double volumen =  WASSERTANK_Breite * WASSERTANK_Breite * hoehe;
  double liter = volumen * 0.001;
    Serial.print("Liter: ");
 Serial.println(liter);
     Serial.print("Volumen: ");
 Serial.println(volumen);
  return liter;
  
}


bool istPflanzeAusreichendGegossen() {
  double liter = berechneGegosseneLiter();
  Serial.print("Liter: ");
  Serial.println(liter);
  if (liter > MAXIMALES_BEWAESSERUNGS_VOLUMEN){
    return true;
  } else {
    return false;
  }
}

Unterprogramm wassertank.h

In der Abb. 15 ist die Excell Datei mit dem individellen Wasserbedarf nach Größe dargestellt. Wichtig ist zu erwähnen, dass diese Werte je nach Größe der Pflanze bzw. des Beetes abweichen können.

Abb.15 Wasserbedarf der Pflanzen nach Größe und individuellen Bedarf

Datei:Excell Pflanzenbewässerung.xlsx

Ergebnis

Das automatische Bewässerungssystem ist voll funktionsfähig und hat die meisten der Anforderungen erfüllt. Die komplette Implementierung ist aus Zeit Gründen nicht in Simulink programmiert. Die Probleme mit dem Display wurden dann in der Arduino IDE vollständig gelöst. Die Einbindung von der Excelltabelle (siehe Abb. 15) mittels Matlab wurde ebenfalls nicht mehr realisiert. Ansonsten ist das Programm Vollfunktionsfähig. Die Breadbords wurden vorerst als Platinen Ersatz verwendet, da das System noch auf sämtliche Pflanzen in meinem Haushalt erweitert wird (siehe Ausblick).


Ausblick

Es gibt 3 Möglichkeiten dieses System zu erweitern:

  1. zahlreichen Pumpen und Leitungen
  2. eine Leitung und eine Pumpe für alle Pflanzen, welche dann die verschiedenen Leitungsenden verschließt
  3. Eine Wasserverteilstation durch einen Servomotor und additive Fertigung realisiert


Das System wird mit einer Wasserverteilstation arbeiten.

Zusammenfassung

Lessons Learned

  • Projektplanung
  • Zeitmanagement
  • Agiles Projektmanagement
  • Problemlösungskompetenz
  • Anforderungen formulieren
  • Komponenten Auswahl
  • Umgang mit Mikrocontrollern, Sensoren, Motoren/Pumpen und Relaise
  • Verdrahtungspläne zeichnen
  • Solidworks CAD Zeichnungen
  • Löten, Crimpen, Abisolieren und Verkabeln
  • Anwendung von Simulink und Arduino IDE
  • Dokumentation Wiki und SVN
  • Plakatdesign mit Canva
  • Videopräsentation
  • Messestand gestalten

Projektunterlagen

Projektplan

Zunächst wurde ein Projektplan via Gantt entworfen. Dieser zeigt auf welche Ressource (Person), die jeweilige Aufgabe im bestimmten Zeitrahmen erledigen soll. Ebenfalls werden diverse Meilensteine und der Projektstand regelmässig aktualisiert.

Legende:

Grün: Jürgen Heimann

Pink: Oliver Aust

Grau: Heimann/Aust

Rot: Projektphase


Abb.11 Projektplan

Projektdurchführung

  1. Erstellung des Projektplans
  2. Beschaffung der Komponenten, Sensoren und Aktoren
  3. Konstruktion der 3D Druckobjekte
  4. Additive Fertigung
  5. Erstellung der Anschlusspläne
  6. Aufbau des Systems
  7. Komponententest und Programmierung mittels Matlab/Simulink
  8. Weitere Umsetzung mittels Arduino IDE
  9. Dokumentation
  10. Ergebnispräsentation mittels Video und Messe

Projektunterlagen

Im folgenden können Sie sich sämtliche relevanten Dateien und Unterlagen des Bewässerungssystems runterladen.

Datei:Automatisches Bewässerungssystem.zip

YouTube Video

Video Ergebnispräsentation

https://youtu.be/pWbTuslWwPA

Weblinks

Literatur

→ zurück zur Übersicht: WS 21/22: Angewandte Elektrotechnik (BSE)

Abgerufen von „https://wiki.hshl.de/wiki/index.php?title=Bewässerungssytem_für_Balkonpflanzen&oldid=117867“