OpenFarmingAI: Automatisiertes Microgreens Anbau System Mit Ebbe-Flut System Mit Pythagoreischem Abfluss Für Die Einbindung in Home Assistant

Dies ist ein "How-to" für den Bau eines open source Systems für den automatisierten Anbau von Microgreens. Dieses modulare System nutzt als Syphon das Funktionsprinzip des pythagoreischen Bechers aus. Dabei wird mit Hilfe einer USB-Aquarium Pumpe Wasser aus einem unteren Behälter nach oben in den Microgreens-Anbauraum gepumpt, bis der Überlauf des Siphons überschritten wird. Anschließend entleert sich der gesamte Behälter vollständig selbst, ohne dass ein weiteres Ventil oder eine weitere Pumper benötigt wird. Der Vorteil des Systems liegt darin, dass keine Wasserführenden Bauteile außerhalb des Systems verbaut sind (Pumpen, Schläuche, Kupplungen) und nur eine Pumpe benötigt wird. Durch einen weiteren Not-Überlauf wird sichergestellt, dass der obere Behälter nicht überlaufen kann. Weiterhin sind alle Löcher und Schlauchverbindungen auch bei Undichtigkeit unkritisch, da das Wasser nur in den Tank zurücklaufen kann.

Das System teilt sich in einzelne Einheiten von 40 cm x 60 cm x 17 cm auf. Sie bestehen jeweils aus zwei Euroboxen, wobei die untere als Wassertank dient und die Microgreens in der oberen Eurobox angebaut werden. Bis zu drei dieser Boxen können gleichzeitig von einem Microcontroller gesteuert werden. Die Box kann aber auch als eigenständiges Anbausystem verwendet werden. Wir haben in unserem Projekt 12 dieser Boxen in vier Reihen in einem Schwerlastregal aufgebaut und jedes Regalfach mit LEDs ausgestattet. LEDs bieten sich in einem Regalsystem an, sind aber nicht notwendig, wenn genug Sonnenlicht auf das System fällt.

Dieses Instructible stellt alle notwendigen STL-Dateien für den 3D-Druck bereit, sowie eine Teileliste für weitere benötigte Komponenten. Weiterhin wird ein Platinen-Design (PCB) bereitgestellt, welches für die Steuerung der 9V USB Pumpen und das Auslesen von Sensoren (Wasserstand, Temperatur, Feuchtigekeit, Luftdruck) verwendet werden kann.

Weiterhin wird Programm-Code für den Microcontroller bereitgestellt, der auf ESPHome basiert (Code Generator für Microcontroller) und damit problemlos in Home Assistant (Open Source Heimautomatisierung) eingebunden werden kann.

Vorkenntnisse / Zielgruppe:

• handwerkliches Geschick
• Kenntnisse in der Anwendung von 3D-Druckern
• Kenntnisse von Schaltkreisen / Elektrotechnik Grundkenntnisse
• Lötkenntnisse
• Grundkenntnisse im Umgang mit Mikrocontrollern
• Grundkenntnisse in der Programmierung
• ESPHome Grundkenntnisse (Link)
• Home Assistant Grundkenntnisse (Link)

Werkzeug:

• 3D-Drucker
• Akkuschrauber
• Stufenbohrer bis 32 mm
• 3D-Drucker. Alternativ einen Zugang zu einem Makerspace oder online bestellen
• Lötkolben
• Lötzinn
• Heißluftfön (nicht zwingend nötig, kann aber hilfreich sein)
• Schrumpfschlauch
• Schere oder Cuttermesser
• Feinsäge für Holz/Kusnstoff

Verbrauchsmaterial:

• Hanf- oder Kokosmatten Meterware auf 37 x 57 cm x 1cm zuschneiden

oder fertig konfektionierte Pads

• Hanfmatten Pads perforiert 113 mm x 75 mm x 10 mm) (Link)
• Umkartons (Link)

Zusätzliches Material pro Microgreens Box:

• 1x Schlauch trinkwassergeeignet mit Außendurchmesser 12 mm und Innendurchmesser 8 mm (Link)
• 1x O-Ring 18 mm x 2 mm
• 1x O-Ring 12,5 mm x 2 mm
• 1x O-Ring 37 mm x 3 mm
• 1x Eurobox 60 cm x 40 cm x 7,5 cm
• 1x Eurobox 60 cm x 40 cm x 12,0 cm

Material für Regal:

• Schwerlastregal (Link)
• Teichfolie
• Wasserleckagesensor
• Alustreifen für LED Streifen 1m x 15 mm x 2 mm

Hardware:

• Computer / Notebook
• 
  

Elektronik für Pumpensteuerung:

• 1x USB Aquarium Pumpe (Link)
• 1x ESP32 Devboard (Link)
• 3x USB Breakout Board (Link)
• 3x LAN Breakout Board
• 3x Relais (Link)
• 1x MicroUSB Power Supply Board (Link)
• 1x PCB oder alternativ Lochraster Platine
• 3x Feuchtesensor (als Füllstandssensor genutzt) (Link)
• 1x Shelly Flood (Link)
• 1x USB Mehrfachnetzteil f. Microcontroller (Link)
• 3x Ethernet Breakout Board (Link)
• 6x Krimpstecker f. Ethernetkabel (Link)
• Ethertnet Kabel nach Bedarf (Link)
• Krimpzange (Link)

Elektronik für Licht:

• 1x LED Strips (Link)
• 1x LED-Netzteil (Link)
• 1x Shelly Plug (Link)

Raspberry Pi:

• Raspberry Pi 4 B (Optional)
• 1x Netzteil Raspberry Pi (Link)
• 1x Ethernetkabel f. Raspberry Pi (Link)
• 1x SSD f. Raspberry Pi (Link)
• 1x SSD Adapter f. Raspberry Pi (Link)
• 1x Gehäuse f. Raspberry Pi (Link)

Software:

• ESPHome (Link)
• Autodesk Fusion 360 (falls Änderungen an den CAD-Dateien vorgenommen werden müssen: Link)
• Home Assistant Installation auf Raspberry Pi (Link) (Optional)
• Git (Link)
• Git Repository für die Software (Link)

Als erstes werden die benötigten Teile für den Pythagoreischen Abfluss (Funktionsprinzip: Pythagoreischer Becher) sowie den Überlauf, die Halterung für den Schlauch und die Gitter für die Hanfmatten gedruckt. Wir haben dafür den Prusa MK3S+ 3D-Drucker mit weißem PETG als Filament verwendet, ihr könnt natürlich jeden beliebigen anderen Drucker mit genügend Bauraum verwenden (die Gitter sind hierbei mit 180 mm x 180 mm maßgebend). Die STL- und 3MF-Dateien findet ihr anbei. Wenn ihr plant, eine andere Behältergröße zu verwenden, als die von uns verwendete Eurobox, müsst ihr gegebenenfalls die Gitter selber neu konstruieren, damit diese für eure Box passen. Dafür findet ihr auch die originalen CAD-Dateien, die wir mit Fusion360 erstellt haben.

Benötigt werden pro Box-System:

• 1x Überlauf
• 1x Klemmring für Überlauf
• 1x Syphon innen
• 1x Syphon außen
• 1x Syphon Klemmring
• 1x Schlauchhalterung
• 1x Klemmring für Schlauchhalterung
• 6x Gitter
• 1x Halterung für Wasserstandssensor
• 1x Gehäuse Oberseite für Wasserstandssensor
• 1x Gehäuse Unterseite für Wasserstandssensor

Wir benötigen die gedruckten Bauteile aus dem vorherigen Arbeitsschritt sowie folgendes Zubehör:

• 1x Eurobox 60 cm x 40 cm x 7,5 cm
• 1x Eurobox 60 cm x 40 cm x 12 cm
• 1x O-Ring 18 mm x 2 mm
• 1x O-Ring 12,5 mm x 2 mm
• 1x O-Ring 37 mm x 3 mm
• Akkuschrauber
• Stufenbohrer
• Schlauch
• USB-Pumpe

Vorbereitung der kleinen Box (60 cm x 40 cm x 7,5 cm)

Mit Hilfe des Stufenbohrers bohrt ihr in einer der Ecken passende Löcher für den Überlauf, den pythagoreischen Abfluss sowie die Schlauchhalterung. Macht die Löcher immer gerade so groß genug, dass die Bauteile sich gerade so mit etwas druck durch stecken lassen. Ordnet die Löcher so an, dass die Klemmringe auf der Unterseite nicht stören, wenn ihr die Eurobox auf die untere Eurobox stellen wollt und achtet darauf, dass die Bauteile jeweils in einem Freiraum des Gitters positioniert sind (Bilder anbei).

Montage der Bauteile

Steckt die Bauteile (Schlauchhalterung, pythagoreischert Abfluss, Überlauf) jeweils von innen durch die Löcher und platziert dabei den passenden O-Ring zwischen dem Boden der Box und dem Bauteil. Steckt nun von der Unterseite der Box den passenden Klemmring auf das Bauteil und verdreht diesen, um den O-Ring zu verpressen und das Bauteil zu verklemmen. Den pythagoreischen Abfluss montiert ihr wie zuvor beschrieben und steckt anschließend das äußere Teil über den Überlauf und verdreht es, um es zu verklemmen (Bilder anbei).

Montage der Pumpe

Schneidet ca. 40 cm vom Schlauch ab und steck diesen durch den Überlauf und anschließend in die Schlauchhalterung. Auf der Unterseite der Box steckt ihr den Schlauch auf die USB Pumpe und befestigt diese in der Unteren Box. Sägt noch einen Ausschnitt in die Untere Box, um das Kabel aus der Box heraus zu führen.

Montage des Wasserstandssensors

Steckt die Sensorhalterung auf den Rand der Box und schiebt anschließend den das Sensorgehäuse in die Halterung. Die Montage des Sensors im Sensorgehäuse inkl. Löten und Verkabelung wird in einem späteren Schritt erklärt.

Montage der Gitter und der Hanfmatten

legt nun 6 Gitter in die obere Box und verteilt die Hanfpads oder eure am Stück zugeschnittene Hanfmatte auf der Gittersatruktur. Die Matten sollten etwas über den Überlauf raden, sodass diese nicht komplegtt mit Wasser überspült werden. Dafür eignen sich Hanfmatten mit ca. 10 mm Dicke.

Wir haben mit verschiedenen Hanf und Kokosmatten experimentiert und sind letztendlich bei 1cm dicken Hanfmatten verblieben, da diese die Feuchtigkeit gut halten und nicht zu schnell trocken fallen. Es kommt aber auch immer etwas auf das verwendete Saatgut an. Wird euer Saatgut zu sehr weggespült, eignet sich vielleicht eher eine Kokosmatte, da diese eine gröbere Struktur hat und damit das Saatgut besser an Ort und Stelle hältt. Experimentiert selber etwas, was am besten für euch funktioniert.

Wenn ihr das System im größerem Maßstab betreiben wollt, eignet sich ein Schwerlastregal, wie dieses hier (Link). Hier apssen genau drei der verwendeten Euroboxsysteme nebeneinander. Ihr könnt vier solcher Systeme übereinander anordnen und habt noch genug Platz über den Systemen, in dem die Microgreens wachsen können und ihr LED Streifen montieren könnt. Wenn euch das Licht stört, könnt ihr das Regal auch zusätzlich mit Teichfolie abdecken und zur Sicherheit gegen Leckage noch Teichfolie unter das Regal legen sowie einen Wasser Leckage Sensor auf dem Boden unter dem Regal platzieren.Hierzu eignet sich beispielsweise der Shelly Flood Sensor, welcher sich in Home Assistant einbinden lässt (Link).

Für die Beleuchtung könnt ihr handelsübliche LED Streifen für den Indoor-Pflanzenanbau verwenden. Microgreens benötigen nicht viel Licht, deshalb reichen auch geringe Leistungen. Wir verwenden in unserem System pro Regalreihe zwei LED Streifen (Link), die wir auf Aluminiumprofilen verklebt haben. Die LEDs werden mit 12V betrieben (Link) und mit einer mechanisch einstellbaren Zeitschaltuhr oder alternativ mit einer smarten Steckdose geschaltet. Für diese gibt es viele verschiedene Hersteller, wir verwenden hier den Shelly Plug S (Link) und haben diesen in Home Assistant eingebunden und steuern ihn über eine Automatisierung (hierzu später mehr).

Um die LED Strips am Regal zu befestigen, könnt ihr entweder einfach Kabelbinder verwenden oder alternativ 3D-gedruckte Halterungen, die wir euch hier ebenfalls zur Verfügung stellen.

Im folgenden Schritt wird die Elektronik für die Pumpensteuerung sowie die Auswertung der Sensoren betrachtet. Es wird ein ESP32 Devboard verwendet, dabei handelt es sich um einen Microcontroller des Typs ESP32, der ähnlich zu einem Arduino programmiert werden kann, um vielfältige Aufgaben zu übernehmen. Wir wollen in diesem Projekt den Microcontroller 3 Pumpen Ein- und Ausschalten lassen sowie einen BMP280 Sensor (Druck, Luftfeuchtigkeit, Temperatur) und einen Bodenfeuchtesensor (zweckentfremdet als Wasser Füllstandssensor) auslesen, um darüber unser System zu steuern. Weiterhin sind drei Relais an den ESP32 angeschlossen, die jeweils die Verbindung zu USB Buchsen schalten. An den USB Buchsen werden dann die USB Pumpen angeschlossen. Die Versorgung des ESP32 und der Pumpen geschieht über ein 9V Netzteil. dieses versorgt direkt die Pumpen (über das Relais und die USB Buchsen) und wird zusätzlich über einen DCDC Wandler auf 5V herunter geregelt, um damit den ESP32 zu versorgen. Dabei wird nicht der VIN Pin des ESP32 verwendet, sondern der MicroUSB Anschluss. Dazu wird eine weitere USB Buchse verwendet, um die 5V auf ein MicroUSB-Kabel zu legen, welches dann an den ESP32 angeschlossen wird. Die Pumpen würden auch mit 5V laufen, liefern aber bei 9V mehr Leistung, was für dieses Projekt nicht unbedingt notwendig ist, die Anwendung aber angenehmer macht.

Nun da wir die Elektronik haben, benötigen wir noch Programmcode, um die Relais auch ansteuern zu können. Hierzu kann beispielsweise die Arduino IDE oder Visual Studio Code (mit dem PlatformIO Plugin) verwendet werden. Dabei ist aber noch viel händische Propgrammierarbeit notwendig (in der Programmiersprache C++). Um dies zu vereinfachen, haben wir uns für die Plattform ESPHome entschieden. Dabei handelt es sich um ein Plugin für Home Assistant (was aber auch als Standalone lauffähig ist), womit sich mit Hilfe einfacher Skript-Basierter Dateien Programmcode erstellen lässt. Es handelt sichd abei um sogenannten YAML-Code, der mit wenig bis keinen Programmierkenntnissen nachvollziehbar ist. Wir stellen euch hier einmal die YAML-Datei zur Verfügung, mit der wir unseren Controller ansteuern. Die YAML-Datei könnt ihr einfach in eurer Home Assistant Installation in dem esphome Hautpverzeichnis ablegen und solltet anschließend in der Lage sein, den Programmcode aus dem Addon heraus zu compilieren. Dabei erzeugt ein Code-Generator automatisiert aus der YAML.Datei den C++ Code (inkl. aller Abhängigkeiten in Form von Bibliotheken - ihr müsst euch um nichts weiter kümmern) und kompiliert diesen anschließend. Ihr erhaltet als Ergebnis ein Binary zum Herunterladen und könnt dieses mit dem ESPhome flasher über euren PC auf den Microcontroller flashen.

Git Repository für die Software (Link)

YAML-Code (Speichert den folgenden Code mit der Deteiendung ".yaml"). Um mehrere Controller anzulegen, speichert pro COntroller eine neue Datei und ändert dabei die ersten drei EInstellungen unter dem Punkt "Substitutions" (host_name, device_name, device_name_upper:

 host_name: hydroponics-controller-0101
 device_name: hydroponics_controller_0101
 device_name_upper: hydroponics.controller.0101

Inhalt der Datei "hydroponics_controller_0101.yaml"

substitutions:
 #general settings
 host_name: hydroponics-controller-0101
 device_name: hydroponics_controller_0101
 device_name_upper: hydroponics.controller.0101 
 status_led_interval_ok: 10s
 status_led_interval_booting: 3s
 settings_log_level: DEBUG
 activate_fast_connect: "true"
 api_reboot_timeout: "2min"

 #i2c settings
 i2c_bus_a_name: bus_a
 i2c_bus_a_sda: "22"
 i2c_bus_a_scl: "21"

 # pump settings
 pump_1_name: pump_1
 pump_1_pin: "16"
 pump_2_name: pump_2
 pump_2_pin: "17"
 pump_3_name: pump_3
 pump_3_pin: "18"

 #bme280_1 settings
 bme280_1_name: bme280_1
 bme280_1_i2c_bus: ${i2c_bus_a_name}
 bme280_1_oversampling: "16x"
 bme280_1_adress: "0x76"
 bme280_1_update_interval: "10s"

 #Soil moisture Sensor settings
 capacitive_moisture_1_name: water_level_1
 capacitive_moisture_1_pin: "33"
 capacitive_moisture_1_update_interval: "1s"
 capacitive_moisture_1_calibrate_linear_1: "1.057 -> 0.00"
 capacitive_moisture_1_calibrate_linear_2: "0.72 -> 100.00"


 #Soil moisture Sensor settings
 capacitive_moisture_2_name: water_level_2
 capacitive_moisture_2_pin: "35"
 capacitive_moisture_2_update_interval: "1s"
 capacitive_moisture_2_calibrate_linear_1: "1.057 -> 0.00"
 capacitive_moisture_2_calibrate_linear_2: "0.72 -> 100.00"

 #Soil moisture Sensor settings
 capacitive_moisture_3_name: water_level_3
 capacitive_moisture_3_pin: "34"
 capacitive_moisture_3_update_interval: "1s"
 capacitive_moisture_3_calibrate_linear_1: "1.057 -> 0.00"
 capacitive_moisture_3_calibrate_linear_2: "0.72 -> 100.00"

esphome:
 name: ${host_name}
 platform: ESP32
 board: esp32dev


# Preferences
preferences:
 flash_write_interval: 1min

# Pump switches to control the relais
switch:
 - platform: gpio
   pin: ${pump_1_pin}
   name: "${device_name_upper}.${pump_1_name}"
   id: ${device_name}_${pump_1_name}
   restore_mode: ALWAYS_OFF
 - platform: gpio
   pin: ${pump_2_pin}
   name: "${device_name_upper}.${pump_2_name}"
   id: ${device_name}_${pump_2_name}
   restore_mode: ALWAYS_OFF
 - platform: gpio
   pin: ${pump_3_pin}
   name: "${device_name_upper}.${pump_3_name}"
   id: ${device_name}_${pump_3_name}
   restore_mode: ALWAYS_OFF


# Enable Home Assistant API
api:
 reboot_timeout: ${api_reboot_timeout}
 password: !secret esphome_api_pw

# enable ota updates
ota:
 password: !secret esphome_ota_pw

# Enable logging
logger:
 level: ${settings_log_level}

# Wifi settings
wifi:
 networks:
 - ssid: !secret wifi_ap_ssid
   password: !secret wifi_ap_pw

 # Enable fallback hotspot (captive portal) in case wifi connection fails
 ap:
   ssid: "$device_name_upper AP"
   password: !secret esphome_fallback_ap_pw

 fast_connect: ${activate_fast_connect}


sensor:
 - platform: wifi_signal
   name: "${device_name_upper}.wifi_signal"
   id: ${device_name}_wifi_signal
   update_interval: 60s

 # BME Sensor
 - platform: bme280
   i2c_id: ${bme280_1_i2c_bus}
   temperature:
     name: "${device_name_upper}.${bme280_1_name}.temperature"
     id: ${device_name}_${bme280_1_name}_temperature
     oversampling: ${bme280_1_oversampling}
   pressure:
     name: "${device_name_upper}.${bme280_1_name}.pressure"
     id: ${device_name}_${bme280_1_name}_pressure
   humidity:
     name: "${device_name_upper}.${bme280_1_name}.humidity"
     id: ${device_name}_${bme280_1_name}_humidity
   address: ${bme280_1_adress}
   update_interval: ${bme280_1_update_interval}

 # Waterlevel Sensor 1
 - platform: adc
   pin: ${capacitive_moisture_2_pin}
   name: "${device_name_upper}.${capacitive_moisture_2_name}"
   id: ${device_name}_${capacitive_moisture_2_name}
   update_interval: ${capacitive_moisture_2_update_interval}
   unit_of_measurement: "%"
   filters:
   - median:
       window_size: 7
       send_every: 4
       send_first_at: 1
   - calibrate_linear:
       - ${capacitive_moisture_2_calibrate_linear_1}
       - ${capacitive_moisture_2_calibrate_linear_2}
   - lambda: |-
      if (x < 0.5){
           return 0;
       }else if (x >=0.5 && x <99.5){
           return (x);
       }else if (x >=99.5 && x<120.0){
           return 100.0;
       }else{
           return -100.0;
       }
   accuracy_decimals: 2

 # Waterlevel Sensor 2 
 - platform: adc
   pin: ${capacitive_moisture_3_pin}
   name: "${device_name_upper}.${capacitive_moisture_3_name}"
   id: ${device_name}_${capacitive_moisture_3_name}
   update_interval: ${capacitive_moisture_3_update_interval}
   unit_of_measurement: "%"
   filters:
   - median:
       window_size: 7
       send_every: 4
       send_first_at: 1
   - calibrate_linear:
       - ${capacitive_moisture_3_calibrate_linear_1}
       - ${capacitive_moisture_3_calibrate_linear_2}
   - lambda: |-
      if (x < 0.5){
           return 0;
       }else if (x >=0.5 && x <99.5){
           return (x);
       }else if (x >=99.5 && x<120.0){
           return 100.0;
       }else{
           return -100.0;
       }
   accuracy_decimals: 2

 # Waterlevel Sensor 3 
 - platform: adc
   pin: ${capacitive_moisture_1_pin}
   name: "${device_name_upper}.${capacitive_moisture_1_name}"
   id: ${device_name}_${capacitive_moisture_1_name}
   update_interval: ${capacitive_moisture_1_update_interval}
   unit_of_measurement: "%"
   filters:
   - median:
       window_size: 7
       send_every: 4
       send_first_at: 1
   - calibrate_linear:
       - ${capacitive_moisture_1_calibrate_linear_1}
       - ${capacitive_moisture_1_calibrate_linear_2}
   - lambda: |-
      if (x < 0.5){
           return 0;
       }else if (x >=0.5 && x <99.5){
           return (x);
       }else if (x >=99.5 && x<120.0){
           return 100.0;
       }else{
           return -100.0;
       }
   accuracy_decimals: 2


# Example configuration entry
binary_sensor:
 - platform: status
   name: ${device_name_upper}.status
   id: ${device_name}_status

button:
 - platform: restart
   name: ${device_name_upper}.restart
   id: ${device_name}_restart

i2c:
 - id: ${i2c_bus_a_name}
   sda: ${i2c_bus_a_sda}
   scl: ${i2c_bus_a_scl}
   scan: true

captive_portal:

Nun könnt ihr den Controller in Home Assistant einbinden und anschließend in einer Home Assistant Automatisierung ansteuern. Ihr könnt alternativ auch innerhalb der ESPHome YAML Datei eine Automatisierung anlegen, um den Controller unebhängig von Home Assistant zu betreiben. Seht euch hierzu Beispiele von ESPHome an.

Die Home Assistant Automatisierung kann beispielsweise wiefolgt aussehen:

- id: '1682515305642'
  alias: hydroponics_0101_pump_automation
  description: ''
  trigger:
  - platform: time_pattern
    minutes: /15
    id: minutes
  - platform: time_pattern
    seconds: /1
    id: trigger_second
  condition: []
  action:
  - if:
    - condition: trigger
      id: trigger_second
    - condition: state
      entity_id: timer.hydroponics_0101_pumptimer
      state: active
    - condition: state
      entity_id: input_boolean.hydroponics_0101_pumpautomation_active
      state: 'on'
    - condition: state
      entity_id: schedule.hydroponics_0101_pumpschedule
      state: 'on'
    then:
    - service: switch.turn_on
      data: {}
      target:
        entity_id:
        - switch.hydroponics_controller_0101_pump_1
        - switch.hydroponics_controller_0101_pump_2
        - switch.hydroponics_controller_0101_pump_3
    else:
    - if:
      - condition: state
        entity_id: input_boolean.hydroponics_0101_pumpautomation_active
        state: 'on'
      then:
      - service: switch.turn_off
        data: {}
        target:
          entity_id:
          - switch.hydroponics_controller_0101_pump_1
          - switch.hydroponics_controller_0101_pump_2
          - switch.hydroponics_controller_0101_pump_3
  - if:
    - condition: trigger
      id: minutes
    then:
    - service: timer.start
      data:
        duration: 00:06:00
      target:
        entity_id: timer.hydroponics_0101_pumptimer
  mode: restart

Die LEDs könnt ihr beispielsweise über einen ShellyPlug steuern und in einer Automatisierunng verwenden:

- id: '1676991140328'
  alias: hydroponics_0101_light_automation
  description: ''
  trigger:
  - platform: time_pattern
    seconds: /1
  - platform: state
    entity_id:
    - input_boolean.hydroponics_0101_lightautomation_active
  - platform: state
    entity_id:
    - schedule.hydroponics_0101_lightschedule
  condition: []
  action:
  - if:
    - condition: state
      entity_id: input_boolean.hydroponics_0101_lightautomation_active
      state: 'on'
    - condition: state
      entity_id: schedule.hydroponics_0101_lightschedule
      state: 'on'
    then:
    - service: switch.turn_on
      data: {}
      target:
        entity_id: switch.hydroponics_shellyplug_0101
    else:
    - service: switch.turn_off
      data: {}
      target:
        entity_id: switch.hydroponics_shellyplug_0101
  mode: single