1.1.1 pH-Wert-Messung

Der pH-Wert ist ein logarithmisches Maß für die Konzentration von Wasserstoffionen und beeinflusst die Verfügbarkeit von Nährstoffen für Pflanzen sowie das Wohlbefinden der Fische (Aquaponik). Ein idealer Bereich liegt typischerweise zwischen pH 5.5 und 6.5 für Hydroponik und pH 6.0 und 7.0 für Aquaponik.

Sensor-Typen und Preisgestaltung:

• Hobby-Grade-Elektroden (ca. 20–100 €): Oft mit Kunststoffgehäuse, Glasmembran, und einem KCI-Gel-Elektrolyten. Diese Elektroden sind für den intermittierenden Einsatz und Systeme mit geringen Anforderungen an die Langzeitstabilität konzipiert. Ihre Lebensdauer ist begrenzt (typischerweise 6–12 Monate Dauerbetrieb), und sie erfordern häufigere Kalibrierungen. Die Genauigkeit kann im Bereich von ±0.1 bis ±0.2 pH-Einheiten liegen.
• Industrie- / Labor-Grade-Elektroden (ca. 150–1000+ €): Verfügen über robustere Glasmembranen, flüssige Referenzsysteme (KCI-Lösung, die nachgefüllt werden muss) für höhere Stabilität und Genauigkeit (bis ±0.01 pH), sowie widerstandsfähigere Gehäuse (z.B. aus PPS oder Edelstahl) für industrielle Anwendungen oder kontinuierlichen Einsatz über mehrere Jahre. Diese bieten zudem oft integrierte Temperatursensoren und spezielle Bauformen für unterschiedliche Installationsumgebungen.

1.1.2 Elektrische Leitfähigkeit (EC-Wert)

Die elektrische Leitfähigkeit misst die Konzentration gelöster Ionen im Wasser und dient als Indikator für die Nährstoffkonzentration in der Lösung. Sie wird üblicherweise in Mikrosiemens pro Zentimeter (µS/cm) oder Millisiemens pro Zentimeter (mS/cm) angegeben.

Sensor-Typen und Preisgestaltung:

• 2-Polige Kohlenstoff- oder Edelstahlsensoren (ca. 30–150 €): Diese einfachen Sonden messen den Widerstand zwischen zwei Elektroden. Sie sind kostengünstig, können aber durch Anlagerungen (Biofilm, Kalk) an den Elektroden anfällig für Drift sein und müssen regelmäßig gereinigt werden.
• 4-Polige Induktive Sensoren (ca. 300–1500+ €): Diese Sensoren messen die Leitfähigkeit kontaktlos über eine Induktionsschleife. Sie sind unempfindlicher gegenüber Verschmutzung und Oberflächenablagerungen, bieten eine höhere Langzeitstabilität und Genauigkeit, sind aber deutlich teurer. Häufig in industriellen und professionellen Aquaponik-Anlagen eingesetzt.

1.1.3 Temperaturmessung

Die Wassertemperatur beeinflusst die Löslichkeit von Sauerstoff und Nährstoffen, die Stoffwechselrate von Pflanzen und Fischen sowie die Aktivität von Mikroorganismen. Zudem ist sie ein kritischer Parameter für die Kompensation von pH- und EC-Messungen.

Sensor-Typen:

• DS18B20 (ca. 5–15 €): Ein digitaler Temperatursensor von Maxim Integrated, der über den OneWire-Bus kommuniziert. Er ist oft in wasserdichten Edelstahlhülsen erhältlich, preiswert und präzise (±0.5°C). Ideal für Wasser- und Bodentemperaturmessungen.
• NTC-Thermistor (ca. 1–5 €): Analoge Widerstandssensoren, deren Widerstand sich mit der Temperatur ändert. Günstig, erfordern aber eine Kalibrierung und eine komplexere Auswertung.

Temperaturabhängigkeit von pH und EC:

Sowohl pH- als auch EC-Werte sind stark temperaturabhängig. Die Ionenaktivität (pH) und die Ionenbeweglichkeit (EC) ändern sich mit der Temperatur. Professionelle Messgeräte und Sensoren verfügen über eine automatische Temperaturkompensation (ATC). Ohne ATC können die Messwerte signifikant abweichen. Typischerweise wird eine Bezugstemperatur von 25°C angenommen. Bei einer Abweichung von 1°C vom Referenzwert kann der pH-Wert um bis zu 0.01-0.03 pH-Einheiten variieren, der EC-Wert sogar um 1-3% pro Grad Celsius. Daher ist die Integration eines Temperatursensors in pH- und EC-Messkreise unerlässlich. (Referenz: ISO 10523:2008 für Wasserqualitätsmessung, Herstellerdatenblätter von pH/EC-Elektroden).

1.1.4 Wasserstandsmessung

Die Überwachung des Wasserstands ist essenziell, um den sicheren Betrieb von Pumpen zu gewährleisten, ein Trockenlaufen zu verhindern und die korrekte Funktion von Flut-und-Ebbe-Systemen oder die kontinuierliche Versorgung von NFT-Rinnen sicherzustellen.

Sensor-Typen:

• Schwimmerschalter (nicht-invasiv, ca. 5–20 €): Mechanische Sensoren, die durch den Wasserstand ausgelöst werden. Sie sind robust, zuverlässig und kostengünstig. Allerdings sind sie invasiv, d.h., sie befinden sich im Wasser, was langfristig zu Biofouling oder Korrosion führen kann. Ideal für einfache Ein-/Aus-Schaltungen bei kritischen Füllständen.
• Kapazitive Wasserstandssensoren (nicht-invasiv, ca. 10–30 €): Diese Sensoren messen eine Änderung der Kapazität, die durch das Vorhandensein von Wasser auf der gegenüberliegenden Seite einer nicht-leitenden Wand (z.B. Kunststofftank) verursacht wird. Sie sind nicht-invasiv, berührungslos und somit unempfindlich gegenüber Korrosion und Biofilm. Sie eignen sich gut für die Messung von Füllständen durch Behälterwände hindurch.
• Ultraschall- oder Infrarot-Sensoren (nicht-invasiv, ca. 15–50 €): Diese Sensoren messen die Entfernung zur Wasseroberfläche mittels Schallwellen (Ultraschall) oder Licht (Infrarot). Sie sind nicht-invasiv und ermöglichen eine kontinuierliche Füllstandsmessung. Allerdings können sie durch Feuchtigkeit, Nebel oder Kondensation beeinträchtigt werden und erfordern eine freie Sicht auf die Wasseroberfläche.

1.1.5 Lichtintensität / Photosynthetisch Aktive Strahlung (PAR)

Das Lichtspektrum und die Intensität der photosynthetisch aktiven Strahlung (PAR) sind für das Pflanzenwachstum entscheidend. Die Messung hilft, die Effizienz der künstlichen Beleuchtung zu optimieren.

Sensor-Typen:

• Fotowiderstände (LDR) (ca. 1–5 €): Sehr kostengünstig, messen die allgemeine Helligkeit basierend auf ihrem Widerstand. Nicht spektralselektiv oder auf PAR optimiert, aber ausreichend für einfache Hell/Dunkel-Erkennung oder grobe Intensitätsmessung.
• Digitale Umgebungslichtsensoren (z.B. BH1750, VEML6070, ca. 5–20 €): Bieten eine digitale Ausgabe in Lux und sind oft spektral an das menschliche Auge angepasst. Besser als LDRs für genauere Helligkeitswerte.
• PAR-Sensoren (ca. 100–500+ €): Spezialisierte Sensoren, die die Photosynthetisch Aktive Strahlung (400-700 nm) in µmol/m²/s messen. Essentiell für präzise Steuerung und Optimierung professioneller Wachstumsbeleuchtung. Sehr präzise, aber deutlich teurer.

1.3.1 pH-Sensorkalibrierung

Frequenz und Kosten:

Hobby-Grade-Elektroden: Je nach Beanspruchung und Genauigkeitsanforderung alle 1-4 Wochen. Industrie- / Labor-Grade-Elektroden: Alle 1-3 Monate, bei stabiler Nutzung seltener.

Kosten für Pufferlösungen: Kalibrierlösungen (pH 4.0, pH 7.0, pH 10.0) kosten ca. 10-25 € pro Liter. Zusätzlich ist eine spezielle KCL-Aufbewahrungslösung (3M Kaliumchlorid) für die Elektrode erforderlich (ca. 10-15 € pro 100ml).

Konkrete Durchführung (Zwei- oder Drei-Punkt-Kalibrierung):

1. Reinigung: Spülen Sie die Elektrode vor und nach jeder Kalibrierung gründlich mit destilliertem oder demineralisiertem Wasser ab. Verwenden Sie ein weiches Tuch oder Papiertuch zum vorsichtigen Abtupfen, nicht Reiben.
2. Puffer pH 7.0 (Neutralpunkt): Tauchen Sie die Elektrode in die Pufferlösung pH 7.0 (Referenzpunkt). Warten Sie, bis der Messwert am Anzeigegerät oder im seriellen Monitor des Mikrocontrollers stabil ist (üblicherweise 30-60 Sekunden). Notieren Sie den analogen Rohwert, den der Mikrocontroller ausgibt.
3. Zweiter Pufferpunkt (Steigung): Spülen Sie die Elektrode erneut. Tauchen Sie sie in eine zweite Pufferlösung (z.B. pH 4.0 oder pH 10.0), die nahe am erwarteten Arbeitsbereich Ihres Systems liegt. Warten Sie auf Stabilität und notieren Sie den Rohwert.
4. Dritter Pufferpunkt (Optional): Für höchste Präzision kann eine dritte Pufferlösung (z.B. pH 4.0 und pH 10.0, wenn pH 7.0 der erste Punkt war) verwendet werden.
5. Lineare Regression im Code: Im Mikrocontroller-Code wird eine lineare Gleichung (pH = m * raw_value + b) zur Umrechnung verwendet. Die Kalibrierpunkte werden genutzt, um die Steigung (m) und den Achsenabschnitt (b) dieser Geraden zu berechnen. Viele Bibliotheken für pH-Sensormodule übernehmen diese Berechnung intern.
   Beispiel (vereinfacht für 2 Punkte): Sei (R1, pH1) = (Rohwert bei pH 7.0, 7.0) und (R2, pH2) = (Rohwert bei pH 4.0, 4.0). Dann ist m = (pH2 - pH1) / (R2 - R1) und b = pH1 - m * R1.
6. Temperaturkompensation: Integrieren Sie die vom Temperatursensor gemessene Wassertemperatur in die pH-Berechnung, um die temperaturabhängigen Abweichungen zu korrigieren. Moderne pH-Sensormodule haben oft einen separaten Temperatureingang dafür.
7. Aufbewahrung: Lagern Sie die pH-Elektrode immer in der speziellen KCL-Aufbewahrungslösung oder notfalls in pH 4.0 Pufferlösung, niemals in destilliertem Wasser, da dies die empfindliche Glasmembran austrocknet und die Elektrode irreparabel schädigt.

1.3.2 EC-Sensorkalibrierung

Frequenz und Kosten:

EC-Sensoren sollten ebenfalls alle 2-4 Wochen kalibriert werden. Kalibrierlösungen sind in verschiedenen Konzentrationen (z.B. 1.413 µS/cm für typische Pflanzenlösungen, 2.778 µS/cm für höhere Konzentrationen) erhältlich und kosten ca. 15-30 € pro Liter.

Konkrete Durchführung:

1. Reinigung: Reinigen Sie die Sonde gründlich von Biofilm oder Ablagerungen mit destilliertem Wasser und einem weichen Tuch.
2. Kalibrierlösung: Tauchen Sie die Sonde in eine Kalibrierlösung bekannter Leitfähigkeit (z.B. 1.413 µS/cm bei 25°C). Warten Sie auf Temperaturstabilisierung und einen stabilen Messwert.
3. Zellenkonstante & Temperaturkompensation: Jeder EC-Sensor hat eine "Zellenkonstante" (k-Wert, oft k=1.0 oder k=0.1), die seine Geometrie beschreibt. Die Kalibrierung besteht darin, diesen Wert oder den Kompensationsfaktor im Mikrocontroller-Code (oder im Modul) so anzupassen, dass der gemessene Rohwert der bekannten Leitfähigkeit der Kalibrierlösung bei der Referenztemperatur (25°C) entspricht. Die Temperaturkompensation ist hier besonders wichtig, da die Leitfähigkeit stark mit der Temperatur variiert (ca. 2% pro °C).
   Formel (vereinfacht): EC_kompensiert = EC_gemessen / (1 + α * (T_gemessen - T_referenz)), wobei α der Temperaturkoeffizient ist (typ. 0.02).
4. Überprüfung: Nach der Kalibrierung können Sie die Sonde in eine zweite Kalibrierlösung mit anderer Leitfähigkeit tauchen, um die Genauigkeit über den Messbereich zu überprüfen.

2.1.1 Automatisches Nachfüllsystem

Ein konstantes Wasserniveau ist in beiden Systemen, besonders aber in der Hydroponik, entscheidend. Verdunstung und Pflanzenaufnahme führen zu einem kontinuierlichen Wasserverlust. Ein automatisches Nachfüllsystem kompensiert diesen Verlust effizient.

Technische Umsetzung:

1. Wasserstandssensor: Ein digitaler Schwimmerschalter oder ein kapazitiver Sensor (wie in Artikel 1 besprochen) wird an einem bestimmten Mindestwasserstand im Reservoir platziert.
2. Mikrocontroller: Der ESP32 oder Arduino überwacht den Status des Sensors.
3. Aktor – Magnetventil oder Pumpe: Ein elektrisches Magnetventil (für Leitungswasseranschluss) oder eine kleine Tauchpumpe (für externen Wassertank) wird über ein Relaismodul an den Mikrocontroller angeschlossen. Relais sind notwendig, um die höhere Spannung und den Strom der Aktoren sicher mit dem Mikrocontroller zu steuern.
4. Regelungslogik: Wenn der Wasserstand den Minimalwert unterschreitet, aktiviert der Mikrocontroller das Magnetventil/die Pumpe für eine definierte Zeit oder bis ein vordefinierter Maximalwasserstand erreicht ist (dies erfordert einen zweiten Wasserstandssensor oder eine präzise Zeitschaltung).

// Vereinfachtes Arduino/ESP32 Code-Beispiel für Wasserstandsregler
const int waterLevelPin = 2; // Digitaler Eingang für Schwimmerschalter
const int pumpRelayPin = 4;  // Digitaler Ausgang für Relais
unsigned long pumpStartTime = 0;
const long maxPumpRunTime = 60000; // 60 Sekunden max. Laufzeit (ms)

void setup() {
  pinMode(waterLevelPin, INPUT_PULLUP); // Schwimmerschalter mit Pullup
  pinMode(pumpRelayPin, OUTPUT);
  digitalWrite(pumpRelayPin, HIGH); // Pumpe AUS (Relais oft inverted)
  Serial.begin(115200);
}

void loop() {
  if (digitalRead(waterLevelPin) == LOW) { // Wasserstand zu niedrig (Schalter geschlossen)
    if (digitalRead(pumpRelayPin) == HIGH) { // Pumpe ist noch AUS
      Serial.println("Wasserstand niedrig, Pumpe AN.");
      digitalWrite(pumpRelayPin, LOW); // Pumpe AN
      pumpStartTime = millis();
    }
  } else { // Wasserstand ausreichend
    if (digitalRead(pumpRelayPin) == LOW) { // Pumpe ist noch AN
      Serial.println("Wasserstand OK, Pumpe AUS.");
      digitalWrite(pumpRelayPin, HIGH); // Pumpe AUS
    }
  }

  // Max. Laufzeit Überwachung für Sicherheit
  if (digitalRead(pumpRelayPin) == LOW && (millis() - pumpStartTime > maxPumpRunTime)) {
    Serial.println("WARNUNG: Pumpe läuft zu lange! Automatisch ausgeschaltet.");
    digitalWrite(pumpRelayPin, HIGH); // Pumpe AUS
  }
}

2.1.2 Timer-gesteuerte Aquaponik-Flut-und-Ebbe-Systeme (Ebb-and-Flow)

In Aquaponik-Systemen mit Flut-und-Ebbe-Technik (Ebb-and-Flow oder Flood-and-Drain) ist eine präzise Zeitsteuerung der Bewässerungszyklen entscheidend für die Sauerstoffversorgung der Wurzeln und die Nährstoffzufuhr.

Technische Umsetzung:

1. Tauchpumpe: Eine leistungsstarke Tauchpumpe, die das Wasser aus dem Fischtank in die Pflanzenbetten befördert.
2. Siphon oder Überlauf: Ein Bell-Siphon oder ein fester Überlauf im Pflanzenbett, der das Wasser bei Erreichen einer bestimmten Höhe abführt und so den "Ebbe"-Zyklus einleitet.
3. Mikrocontroller & Relais: Der Mikrocontroller steuert die Tauchpumpe über ein Relaismodul basierend auf einem vordefinierten Zeitplan.

// Vereinfachtes Arduino/ESP32 Code-Beispiel für Ebb-and-Flow Pumpe
const int pumpRelayPin = 4;
const long floodDuration = 10 * 60 * 1000; // 10 Minuten Fluten (ms)
const long ebbDuration = 50 * 60 * 1000;   // 50 Minuten Ebbe (ms)
long lastPumpToggleTime = 0;
bool isFlooding = false;

void setup() {
  pinMode(pumpRelayPin, OUTPUT);
  digitalWrite(pumpRelayPin, HIGH); // Pumpe AUS starten
  Serial.begin(115200);
  Serial.println("Starte Ebb-and-Flow Zyklus.");
}

void loop() {
  if (!isFlooding && (millis() - lastPumpToggleTime >= ebbDuration)) {
    // Ebbe-Phase beendet, starte Fluten
    Serial.println("Starte Flut-Phase.");
    digitalWrite(pumpRelayPin, LOW); // Pumpe AN
    lastPumpToggleTime = millis();
    isFlooding = true;
  } else if (isFlooding && (millis() - lastPumpToggleTime >= floodDuration)) {
    // Flut-Phase beendet, starte Ebbe
    Serial.println("Starte Ebbe-Phase.");
    digitalWrite(pumpRelayPin, HIGH); // Pumpe AUS
    lastPumpToggleTime = millis();
    isFlooding = false;
  }
}

3.2.1 Tageslichtsimulation mit dimmbaren LEDs

Die Nachbildung des natürlichen Tagesverlaufs kann Pflanzen Stress reduzieren und das Wachstum optimieren.

Technische Umsetzung:

1. Multispektrale LED-Leisten/Module: Verwenden Sie LED-Leisten, die verschiedene Lichtfarben (z.B. Warmweiß, Kaltweiß, Rot, Blau, Far-Red) separat ansteuerbar machen. Hierfür eignen sich spezialisierte Pflanzen-LEDs oder flexible RGBW/RGBWW-Streifen.
2. PWM-LED-Treiber: Die Intensität jeder LED-Farbe wird über Pulsweitenmodulation (PWM) gesteuert. Mikrocontroller wie der ESP32 verfügen über mehrere PWM-Ausgänge. Für leistungsstarke LEDs sind dedizierte LED-Treiber (z.B. Meanwell LDD-H Serie für Konstantstrom oder MOSFET-Treiber für Konstantspannung) erforderlich, die wiederum über PWM-Signale des Mikrocontrollers angesteuert werden.
3. Mikrocontroller: Der ESP32 oder Arduino generiert die PWM-Signale basierend auf einem vordefinierten Tageslicht-Profil.

// Vereinfachtes Arduino/ESP32 Code-Beispiel für Sonnenaufgang/Sonnenuntergang
const int warmWhitePin = 13; // PWM-Pin für Warmweiß-LED
const int redLedPin = 12;    // PWM-Pin für Rot-LED
const int blueLedPin = 14;   // PWM-Pin für Blau-LED

const int sunriseDuration = 30 * 60 * 1000; // 30 Minuten (ms)
const int sunsetDuration = 30 * 60 * 1000;  // 30 Minuten (ms)
const int dayDuration = 12 * 60 * 60 * 1000; // 12 Stunden Taglicht (ms)

unsigned long currentTime;
unsigned long dayStartTime = 0; // Speichert den Start des aktuellen Tageszyklus

void setup() {
  // Für ESP32 müssen PWM-Frequenz und Auflösung konfiguriert werden
  ledcSetup(0, 5000, 8); // Kanal 0, Frequenz 5kHz, 8 Bit Auflösung (0-255)
  ledcAttachPin(warmWhitePin, 0);
  ledcSetup(1, 5000, 8); // Kanal 1
  ledcAttachPin(redLedPin, 1);
  ledcSetup(2, 5000, 8); // Kanal 2
  ledcAttachPin(blueLedPin, 2);

  Serial.begin(115200);
  Serial.println("Starte Lichtzyklus.");
}

void loop() {
  currentTime = millis();

  // Reset des Tageszyklus alle 24 Stunden (oder basierend auf Echtzeituhr)
  if (currentTime - dayStartTime >= (24 * 60 * 60 * 1000)) { // 24 Stunden
     dayStartTime = currentTime;
     Serial.println("Neuer Tageszyklus beginnt.");
  }

  long timeInDay = (currentTime - dayStartTime) % (24 * 60 * 60 * 1000); // Zeit seit Tagesstart

  int warmWhiteIntensity = 0;
  int redIntensity = 0;
  int blueIntensity = 0;

  // Sonnenaufgangs-Phase
  if (timeInDay < sunriseDuration) {
    float progress = (float)timeInDay / sunriseDuration;
    warmWhiteIntensity = (int)(progress * 255); // Max 255
    redIntensity = (int)(progress * 200);      // Etwas weniger Rot
  }
  // Taglicht-Phase (inkl. Blaulicht)
  else if (timeInDay >= sunriseDuration && timeInDay < (sunriseDuration + dayDuration)) {
    warmWhiteIntensity = 255;
    redIntensity = 200;
    blueIntensity = 150; // Blau hinzu
  }
  // Sonnenuntergangs-Phase
  else if (timeInDay >= (sunriseDuration + dayDuration) && timeInDay < (sunriseDuration + dayDuration + sunsetDuration)) {
    float progress = (float)(timeInDay - (sunriseDuration + dayDuration)) / sunsetDuration;
    warmWhiteIntensity = (int)((1.0 - progress) * 255);
    redIntensity = (int)((1.0 - progress) * 200);
    blueIntensity = 0; // Blau zuerst weg
  }
  // Nacht-Phase
  else {
    warmWhiteIntensity = 0;
    redIntensity = 0;
    blueIntensity = 0;
  }

  ledcWrite(0, warmWhiteIntensity);
  ledcWrite(1, redIntensity);
  ledcWrite(2, blueIntensity);

  delay(1000); // Aktualisierungsrate
}

3.2.2 Photoperioden-Steuerung

Die exakte Einhaltung von Hell-Dunkel-Zyklen ist entscheidend, insbesondere für Kurztag- und Langtagpflanzen, um Blüte und Fruchtbildung zu induzieren oder zu verhindern.

Technische Umsetzung:

1. Echtzeituhr (RTC): Ein RTC-Modul (z.B. DS3231 oder DS1307) am I²C-Bus des Mikrocontrollers liefert präzise Zeitdaten, unabhängig von der Stromversorgung des Mikrocontrollers. Dies ist zuverlässiger als interne Timer, die bei Stromausfall zurückgesetzt werden.
2. Mikrocontroller & Relais: Steuert die Hauptbeleuchtung über ein Relaismodul basierend auf den RTC-Daten.

Praktische Idee: Präziser Licht-Timer mit RTC

Verwenden Sie eine RTC, um die aktuelle Uhrzeit zu erfassen. Definieren Sie im Code Start- und Endzeiten für die Beleuchtung. Zuverlässiger und präziser als reine Timer, da die RTC die tatsächliche Uhrzeit kennt und nicht nur die verstrichene Zeit seit dem letzten Reset. Dies ist besonders wichtig, wenn Sie die Photoperiode für die Blüteninduktion exakt einhalten müssen.

3.3.1 Bedarfsgesteuerte Zusatzbeleuchtung

Dieses System nutzt einen Umgebungslichtsensor, um die künstliche Beleuchtung nur bei Bedarf zu aktivieren oder deren Intensität anzupassen.

Technische Umsetzung:

1. Lichtsensor (PAR oder Lux): Ein digitaler Lichtsensor (z.B. BH1750 für Lux, oder ein dedizierter PAR-Sensor für professionelle Anwendungen) wird an einer repräsentativen Stelle im Gewächshaus installiert.
2. Mikrocontroller: Liest die Daten des Lichtsensors und vergleicht sie mit einem vordefinierten Schwellenwert für die gewünschte minimale Lichtintensität.
3. Aktoren – LED-Beleuchtung & Relais: Die künstliche Beleuchtung wird über Relais (für An/Aus) oder PWM-Treiber (für Dimmung) angesteuert.

// Vereinfachtes Arduino/ESP32 Code-Beispiel für Zusatzbeleuchtung
#include <wire.h>
#include <bh1750.h> // Bibliothek für BH1750 Sensor

BH1750 lightMeter;
const int auxLightRelayPin = 5; // Pin für Zusatzbeleuchtung
const int minLuxThreshold = 5000; // Minimaler Lux-Wert, unter dem Zusatzlicht anspringt

void setup() {
  Serial.begin(115200);
  Wire.begin();
  lightMeter.begin(); // Initialisiere BH1750

  pinMode(auxLightRelayPin, OUTPUT);
  digitalWrite(auxLightRelayPin, HIGH); // Zusatzlicht AUS starten (Relais oft inverted)
  Serial.println("Starte Lichtsensor-basierte Steuerung.");
}

void loop() {
  float lux = lightMeter.readLightLevel(); // Lux-Wert lesen

  // Hier sollte zusätzlich eine RTC-Abfrage erfolgen, ob es überhaupt "Tag" ist.
  // if (isDaytime() && lux < minLuxThreshold) { ... }
  
  if (lux < minLuxThreshold) {
    if (digitalRead(auxLightRelayPin) == HIGH) {
      Serial.print("Lux zu niedrig ("); Serial.print(lux); Serial.println("), Zusatzlicht AN.");
      digitalWrite(auxLightRelayPin, LOW); // Zusatzlicht AN
    }
  } else {
    if (digitalRead(auxLightRelayPin) == LOW) {
      Serial.print("Lux ausreichend ("); Serial.print(lux); Serial.println("), Zusatzlicht AUS.");
      digitalWrite(auxLightRelayPin, HIGH); // Zusatzlicht AUS
    }
  }
  delay(5000); // Alle 5 Sekunden messen
}

4.2.1 Temperatur- und Luftfeuchtigkeitssensoren

Kombinierte Sensoren sind kostengünstig und platzsparend.

Sensor-Typen:

• DHT11/DHT22 (ca. 5–15 €): Weit verbreitet für Hobbyprojekte. DHT11 ist günstiger, aber weniger präzise (±2°C, ±5% RH) und langsamer. DHT22 (oder AM2302) ist genauer (±0.5°C, ±2% RH) und für die meisten Anwendungen ausreichend. Beide nutzen ein proprietäres digitales Protokoll und benötigen eine spezielle Bibliothek.
• BME280/BMP280 (ca. 10–25 €): Digitale Sensoren von Bosch, die über I²C oder SPI kommunizieren. Der BME280 misst Temperatur, Luftfeuchtigkeit und Luftdruck. Der BMP280 nur Temperatur und Druck. Sie sind präziser (±0.5°C, ±3% RH für Feuchtigkeit) und schneller als DHT-Sensoren. Ideal für professionellere Anwendungen.

4.2.2 CO2-Sensoren

Die Messung von CO2 erfolgt typischerweise mit NDIR-Sensoren (Non-Dispersive Infrared).

Sensor-Typen:

• MH-Z19B / MH-Z19C (ca. 30–60 €): Kostengünstige NDIR-CO2-Sensoren, die über UART oder PWM kommunizieren. Sie bieten eine Genauigkeit von ±50 ppm + 5% des Messwerts und sind für geschlossene Gewächshäuser gut geeignet. Verfügen oft über eine Auto-Kalibrierungsfunktion (ABC-Logik), die regelmäßige Frischluftzyklen voraussetzt.
• SCD30 (ca. 60–90 €): Ein präziserer und oft kompakterer CO2-, Temperatur- und Feuchtigkeitssensor von Sensirion, der über I²C kommuniziert. Bietet eine höhere Genauigkeit (±30 ppm + 3% des Messwerts) und ist ebenfalls für den Einsatz in Innenräumen optimiert.

4.3.1 Automatische Belüftung und Heizung/Kühlung

Eine stabile Lufttemperatur und Luftfeuchtigkeit sind entscheidend, um Pflanzenstress zu minimieren und Krankheiten vorzubeugen.

Technische Umsetzung:

1. Sensoren: BME280 oder DHT22 liefern Temperatur- und Feuchtigkeitsdaten.
2. Mikrocontroller: Verarbeitet die Sensordaten und implementiert Regelalgorithmen (z.B. Hysterese-Regelung).
3. Aktoren:
   • Abluftventilator: Gesteuert über ein Relaismodul, um überschüssige Wärme abzuführen oder feuchte Luft auszutauschen.
   • Zuluftklappe/Lüfter: Kann ebenfalls über ein Relais gesteuert werden, um Frischluft zuzuführen.
   • Heizmatte/Heizlüfter: Ebenfalls über Relais geschaltet, um die Temperatur bei Bedarf zu erhöhen.
   • Aktivkohlefilter: Optional in der Abluft, um Gerüche zu neutralisieren.

Praktische Idee: Temperatur- und Feuchtigkeitsregler

Der ESP32 liest kontinuierlich die Daten des BME280. Wenn die Temperatur über einen Schwellenwert (z.B. 28°C) steigt, wird der Abluftventilator aktiviert. Fällt sie unter einen unteren Schwellenwert (z.B. 20°C), kann eine Heizmatte zugeschaltet werden. Ähnlich kann die Luftfeuchtigkeit reguliert werden: Bei zu hoher Feuchtigkeit (z.B. >70% RH) wird der Ventilator aktiviert, um feuchte Luft abzuführen. Eine Hysterese (z.B. Einschalten bei 28°C, Ausschalten bei 26°C) ist wichtig, um ständiges Ein- und Ausschalten zu vermeiden.

// Vereinfachtes Arduino/ESP32 Code-Beispiel für Temperatur/Feuchtigkeitsregler mit BME280
#include <wire.h>
#include <adafruit_sensor.h>
#include <adafruit_bme280.h> // Bibliothek für BME280 Sensor

#define SEALEVELPRESSURE_HPA (1013.25) // Standard Atmosphärendruck

Adafruit_BME280 bme; // I2C

const int exhaustFanRelayPin = 18; // Abluftventilator
const int heaterRelayPin = 19;     // Heizmatte

const float tempHighThreshold = 28.0; // °C, Ventilator AN
const float tempLowThreshold = 26.0;  // °C, Ventilator AUS
const float tempMinThreshold = 20.0;  // °C, Heizmatte AN
const float tempMaxThreshold = 22.0;  // °C, Heizmatte AUS

const float humidityHighThreshold = 75.0; // %RH, Ventilator AN
const float humidityLowThreshold = 70.0;  // %RH, Ventilator AUS

void setup() {
  Serial.begin(115200);
  Serial.println("Starte Umgebungskontrolle.");

  if (!bme.begin(0x76)) { // I2C-Adresse des BME280
    Serial.println("Konnte BME280 nicht finden, überprüfe Verkabelung oder Adresse!");
    while (1);
  }

  pinMode(exhaustFanRelayPin, OUTPUT);
  pinMode(heaterRelayPin, OUTPUT);
  digitalWrite(exhaustFanRelayPin, HIGH); // Ventilator AUS (Relais oft inverted)
  digitalWrite(heaterRelayPin, HIGH);     // Heizung AUS

  delay(100);
}

void loop() {
  float temperature = bme.readTemperature();
  float humidity = bme.readHumidity();

  Serial.printf("Temp: %.2f °C, Hum: %.2f %%\n", temperature, humidity);

  // Temperaturregelung
  if (temperature > tempHighThreshold) {
    if (digitalRead(exhaustFanRelayPin) == HIGH) {
      Serial.println("Temp zu hoch, Ventilator AN.");
      digitalWrite(exhaustFanRelayPin, LOW); // Ventilator AN
    }
    if (digitalRead(heaterRelayPin) == LOW) { // Heizung AUS, wenn Ventilator an ist
      Serial.println("Temp zu hoch, Heizung AUS.");
      digitalWrite(heaterRelayPin, HIGH); // Heizung AUS
    }
  } else if (temperature < tempLowThreshold && temperature > tempMinThreshold) {
    if (digitalRead(exhaustFanRelayPin) == LOW) {
      Serial.println("Temp OK, Ventilator AUS.");
      digitalWrite(exhaustFanRelayPin, HIGH); // Ventilator AUS
    }
  }
  
  if (temperature < tempMinThreshold) {
    if (digitalRead(heaterRelayPin) == HIGH) {
      Serial.println("Temp zu niedrig, Heizung AN.");
      digitalWrite(heaterRelayPin, LOW); // Heizung AN
    }
    if (digitalRead(exhaustFanRelayPin) == LOW) { // Ventilator AUS, wenn Heizung an ist
      Serial.println("Temp zu niedrig, Ventilator AUS.");
      digitalWrite(exhaustFanRelayPin, HIGH); // Ventilator AUS
    }
  } else if (temperature > tempMaxThreshold && temperature < tempHighThreshold) {
    if (digitalRead(heaterRelayPin) == LOW) {
      Serial.println("Temp OK, Heizung AUS.");
      digitalWrite(heaterRelayPin, HIGH); // Heizung AUS
    }
  }

  // Luftfeuchtigkeitsregelung (kann mit Temperaturregelung interagieren, hier vereinfacht)
  if (humidity > humidityHighThreshold) {
    if (digitalRead(exhaustFanRelayPin) == HIGH) {
      Serial.println("Feuchte zu hoch, Ventilator AN.");
      digitalWrite(exhaustFanRelayPin, LOW); // Ventilator AN
    }
  } else if (humidity < humidityLowThreshold) {
    // Hier könnte ein Luftbefeuchter gesteuert werden, wenn nötig.
    // Oder sicherstellen, dass der Ventilator AUS ist, wenn Feuchte OK.
    if (digitalRead(exhaustFanRelayPin) == LOW && temperature < tempHighThreshold) { // Nur ausschalten, wenn Temp es erlaubt
      Serial.println("Feuchte OK, Ventilator AUS (falls nicht wegen Temp an).");
      digitalWrite(exhaustFanRelayPin, HIGH);
    }
  }

  delay(5000); // Alle 5 Sekunden messen
}

4.3.2 CO2-Anreicherung

In geschlossenen Anbausystemen kann die CO2-Konzentration schnell unter das atmosphärische Niveau sinken (ca. 400 ppm), was die Photosyntheseleistung begrenzt. Eine kontrollierte CO2-Anreicherung auf 800-1500 ppm kann den Ertrag deutlich steigern.

Wir empfehlen ! dringend ! nicht CO2 der Gewächshaus-Umluft zu zu fügen sondern das Fenster, wenn möglich, einfach zu öffnen. Da es aber auch im Hobby-Bereich echte Profis gibt, haben wir diesen Artikel auf mehrfaches Nachfragen trotzdem auch für Hobby-isten hier eingestellt. Bedenken Sie aber: das ist noch gefährlicher als eine Gas-Installation. CO2 explodoiert natürlich nicht (Schutzgas-Eigenschaften) aber es ist heimtückisch da Sie es im Gegensatz zu Gas nicht riechen können und einfach ersticken - nicht am CO2 sondern mangels Sauerstoff !

Technische Umsetzung:

1. CO2-Sensor: Ein MH-Z19B oder SCD30 liefert die aktuellen CO2-Werte.
2. Mikrocontroller: Vergleicht den gemessenen CO2-Wert mit dem Zielwert.
3. Aktor – Magnetventil für CO2-Flasche: Ein spezielles Magnetventil für CO2-Druckflaschen (oft 12V oder 24V) wird über ein Relaismodul gesteuert. Alternativ kann ein CO2-Generator (z.B. mit Trockeneis oder enzymatischen Prozessen) verwendet werden.

Praktische Idee: Einfache CO2-Regelung

Der ESP32 liest den CO2-Wert vom Sensor. Wenn der Wert unter einen definierten Schwellenwert (z.B. 800 ppm) fällt, öffnet der Mikrocontroller das Magnetventil der CO2-Flasche für eine kurze, definierte Zeit (z.B. 10-30 Sekunden). Danach wird eine Wartezeit (z.B. 5-10 Minuten) eingelegt, damit sich das CO2 verteilen kann und der Sensor den neuen Wert erfasst, bevor erneut dosiert wird. Wichtig: Eine CO2-Anreicherung sollte nur während der Beleuchtungsphase erfolgen, da Pflanzen im Dunkeln kein CO2 verbrauchen.

Sicherheitshinweis: CO2 in hohen Konzentrationen ist für den Menschen gefährlich. Eine ausreichende Belüftung des Raumes bei Anwesenheit von Personen ist unerlässlich. Das System sollte niemals CO2 freisetzen, wenn sich Personen im Raum aufhalten.

// Vereinfachtes Arduino/ESP32 Code-Beispiel für CO2-Regelung mit MH-Z19B (UART)
// Benötigt SoftwareSerial für Arduino oder die Hardware-UART des ESP32

// Beispiel für ESP32 HardwareSerial:
#define MHZ19B_RX_PIN 16 // GPIO, der an TX des MH-Z19B geht
#define MHZ19B_TX_PIN 17 // GPIO, der an RX des MH-Z19B geht
HardwareSerial SerialMHZ(1); // Verwende Serial1 auf ESP32

const int co2ValveRelayPin = 21; // Relais für CO2-Magnetventil

const int targetCO2 = 1000;      // Ziel-CO2 in ppm
const int co2DoseThreshold = 100; // ppm unter Ziel, bevor dosiert wird
const int doseDuration = 10000;   // 10 Sekunden CO2 dosieren (ms)
const long dosePause = 5 * 60 * 1000; // 5 Minuten Pause nach Dosierung (ms)

unsigned long lastDoseTime = 0;
bool isDaytime = true; // Annahme: Hier RTC oder Lichtsensor einbinden!

void setup() {
  Serial.begin(115200);
  SerialMHZ.begin(9600, SERIAL_8N1, MHZ19B_RX_PIN, MHZ19B_TX_PIN); // MH-Z19B Baudrate 9600

  pinMode(co2ValveRelayPin, OUTPUT);
  digitalWrite(co2ValveRelayPin, HIGH); // CO2-Ventil AUS starten

  Serial.println("Starte CO2-Kontrolle.");
  delay(100);
}

void loop() {
  // Lese CO2-Wert (MH-Z19B benötigt spezielle Anfrage)
  int co2ppm = readMHZ19B(); // Funktion zum Lesen des CO2-Werts implementieren

  Serial.printf("CO2: %d ppm\n", co2ppm);

  // CO2-Regelung nur bei Tag und wenn ausreichend Zeit seit letzter Dosierung
  if (isDaytime && (millis() - lastDoseTime > dosePause)) {
    if (co2ppm < (targetCO2 - co2DoseThreshold)) {
      Serial.println("CO2 zu niedrig, Ventil AN.");
      digitalWrite(co2ValveRelayPin, LOW); // Ventil AN
      lastDoseTime = millis();
      delay(doseDuration); // Dosierdauer
      digitalWrite(co2ValveRelayPin, HIGH); // Ventil AUS
      Serial.println("CO2 Dosierung beendet.");
      delay(2000); // Kurze Pause für Sensor
    }
  } else if (!isDaytime) {
    // Sicherstellen, dass Ventil bei Nacht AUS ist
    if (digitalRead(co2ValveRelayPin) == LOW) {
      digitalWrite(co2ValveRelayPin, HIGH);
      Serial.println("Nacht, CO2-Ventil AUS.");
    }
  }

  delay(5000); // Wartezeit zwischen Messungen

  // --- MH-Z19B Lese-Funktion (vereinfacht, benötigt Fehlerbehandlung) ---
  // https://github.com/WifWaf/MH-Z19/blob/master/MHZ19.h
  // Dies ist ein Platzhalter, eine vollständige Implementierung ist komplexer.
  int readMHZ19B() {
    byte cmd[9] = {0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79}; // Request CO2
    SerialMHZ.write(cmd, 9);
    delay(100); // Warte auf Antwort
    if (SerialMHZ.available() >= 9) {
      byte response[9];
      SerialMHZ.readBytes(response, 9);
      if (response[0] == 0xFF && response[1] == 0x86) {
        return (response[2] << 8) | response[3];
      }
    }
    return -1; // Fehler
  }
}