Saugroboter smart(er) machen

In diesem Artikel widme ich mich einem Haushaltsgerät, welches an sich schon ziemlich smart ist, dem Saugroboter. Wenn man einen solchen allerdings mit Homeassistant verbindet, lässt sich noch einiges mehr herausholen, wie ich euch zeigen werde.

Ich habe persönlich einen Deame D9 im Einsatz, auf welchen ich Valetudo installiert habe. Die Konzepte, die ich hier vorstellen werde, lassen sich aber mit Sicherheit auch auf andere Robos mit anderer Software, in der einen oder anderen Form, anwenden.
Speziell bei Valetudo kommt jedoch hinzu, dass Homeassistant hier gewisse Funktionen ersetzen kann, welche ihr durch die Installation von Valetudo im Vergleich zur Standard-Firmware eines Saugroboters evtl. verliert. (Weil Valetudo nicht mit einer Cloud verbunden ist)

Alle Punkte, die ich euch hier aufzähle, werden von mir persönlich genau so genutzt und ich kann euch sagen, man merkt den Robo fast nicht mehr. Der Boden ist quasi wie von Zauberhand immer sauber :-). Nur alle paar Tage (wenn man darauf hingewiesen wird) muss man den Staubbehälter ausleeren und das war es.

Voraussetzungen

Euer Robo muss natürlich in Homeassistant eingebunden werden, damit ihr diesen starten und auch zurück zur Basisstation schicken könnt. Abhängig von eurem Model gibt es verschiedene Integrationen für Homeassistant.
Ein Valetudo Robo kann über MQTT verbunden werden.

Weiter unten beschreibe ich eine Automatisierung, welche den Robo dann fahren lässt, wenn ihr tatsächlich nicht zu Hause seid. Dafür muss es in Homeassistant eine Möglichkeit geben festzustellen, ob ihr eben abwesend seid oder nicht.
Dafür gibt es mehrere Möglichkeiten. Ich benutze dafür den Ping Sensor.

Mitzählen der Reinigungsvorgänge

Eine sehr einfache Funktion ist das Mitzählen der durchgeführten Reinigungen. Mein Roboter bietet keine Möglichkeit, auszulesen, wie voll sein Staubbehälter ist. Ich habe auch noch nie ausprobiert, was passiert, wenn man den Behälter einfach nicht ausleert, es ist aber einleuchtend, dass die Reinigungsleistung wohl desto mehr nachlassen würde je voller der Behälter ist.

Nach einigen Versuchen habe ich für mich definiert, dass mein Robo 3 Reinigungsvorgänge durchführen soll, bevor er sich selbst als "voll" betrachtet. Diese Zahl ist natürlich stark davon abhängig, wie regelmäßig ihr reinigt, dazu unten mehr.
Wir erstellen dafür also eine einfache input_number, welche die Durchgänge mitzählen soll:

input_number:
  robo_cleanups_done:
  name: Robo Cleanups Done
  icon: mdi:robot
  min: 0
  max: 3
  step: 1

Anschließend erstellen wir folgende Automatisierung:

alias: Robo Cleanup Done, Dustbin Control
description: ""
trigger:
  - platform: state
    entity_id:
      - vacuum.valetudo_dreamed9
    from: cleaning
    to: null
condition: []
action:
  - if:
      - condition: numeric_state
        entity_id: input_number.robo_cleanups_done
        below: 2
    then:
      - service: notify.mobile_app_person_1
        data:
          message: Cleanup Fertig, Staubbehälter hat noch Platz
          title: Saugrobo
    else:
      - service: notify.mobile_app_person_1
        data:
          message: Cleanup Fertig, Staubbehälter ausleeren!
          title: Saugrobo
  - service: input_number.increment
    target:
      entity_id: input_number.robo_cleanups_done
    data: {}
mode: single

Die Automatisierung wird ausgelöst, wenn der Robo vom Zustand cleaning in einen beliebigen anderen Zustand wechselt. Die Reinigung gilt also auch dann als abgeschlossen, wenn er in einen Error-Zustand geht. Anschließend wird der Wert von input_number.robo_cleanups_done betrachtet. Liegt dieser unter 2, also bei 0 oder bei 1, wird mittels notify die Nachricht Cleanup Fertig, Staubbehälter hat noch Platz an das Mobilgerät von person_1 gesendet. Beim dritten Reinigungsvorgang wird stattdessen die Nachricht Cleanup Fertig, Staubbehälter ausleeren! gesendet.

Reinigung bei Abwesenheit bzw. Sperren der Reinigung

Alle Saugroboter Apps, die ich bisher gesehen habe, bieten die Möglichkeit, festgelegte Reinigungsintervalle festzulegen, also bestimmte Uhrzeiten und/oder bestimmte Tage in der Woche. Auch bei Valetudo ist das nicht anders.
Mein persönlicher Alltag ist jedoch bei weitem zu unregelmäßig, als ,dass ich damit ein Programm festlegen könnte, bei dem der Robo wirklich immer nur dann reinigt, wenn ich nicht zu Hause bin.
Ich habe also eine Automatisierung entwickelt, welche den Robo nur dann reinigen lässt, wenn alle Personen im Haus tatsächlich abwesend sind.

Wir beginnen damit, folgenden Sensor in der configuration.yaml zu definieren:

sensor:
  - platform: history_stats
    name: Dreame D9 Last Clean (30h Calc Range)
    entity_id: vacuum.valetudo_dreamed9
    state: "cleaning"
    type: time
    start: "{{ now() - timedelta(hours=30) }}"
    end: "{{ now() }}"

Wir messen damit, wie viel Zeit der Robo in den letzten 30 Stunden im Zustand cleaning verbracht hat.
Wird dieser Wert 0, dann bedeutet das, dass die letzte Reinigung 30 Stunden her ist. Dieser Wert hat sich für mich im Praxistest als vernünftig erwiesen (in Kombination mit dem Ausleeren des Staubbehälters nach 3 Durchgängen, siehe oben).
Wenn dieser Zustand erreicht ist, wird der Robo bei der nächsten Gelegenheit, die er hat, eine Reinigung durchführen. Wie das funktioniert, dazu komme ich gleich.

Als Nächstes erzeugen wir zwei input_boolean:

input_boolean:
  robo_clean_at_next_leave:
    initial: false

  robo_perma_off:
    initial: false

Mit robo_clean_at_next_leave werden wir in weiterer Folge Homeassistant und somit unserem Saugrobo mitteilen können, dass für unser Befinden die Wohnung derzeit zu schmutzig ist und er bitte bei der nächsten Gelegenheit, wenn wir das Haus verlassen reinigen soll, unabhängig davon wie lange die letzte Reinigung schon zurückliegt.

robo_perma_off wird uns dazu dienen, den Robo temporär komplett für die Reinigung zu sperren.

Nun erstellen wir die Automatisierung, welche den Robo zur Reinigung losschicken wird. Diese ist etwas länger, aber keine Sorge, ich werde jeden Schritt erklären:

alias: Robo On
description: ""
trigger:
  - platform: state
    entity_id:
      - device_tracker.person_1_ping
    from: home
    to: not_home
  - platform: state
    entity_id:
      - device_tracker.person_2_ping
    from: home
    to: not_home
condition:
  - condition: and
    conditions:
      - condition: state
        entity_id: device_tracker.person_1_ping
        state: not_home
      - condition: state
        entity_id: device_tracker.person_2_ping
        state: not_home
      - condition: or
        conditions:
          - condition: state
            entity_id: sensor.dreame_d9_last_clean_30h_calc_range
            state: "0.0"
          - condition: state
            entity_id: input_boolean.robo_clean_at_next_leave
            state: "on"
      - condition: state
        entity_id: input_boolean.robo_perma_off
        state: "off"
action:
  - delay:
      hours: 0
      minutes: 30
      seconds: 0
      milliseconds: 0
  - condition: and
    conditions:
      - condition: state
        entity_id: device_tracker.person_1_ping
        state: not_home
      - condition: state
        entity_id: device_tracker.person_2_ping
        state: not_home
      - condition: time
        after: "10:00:00"
        before: "20:00:00"
  - choose:
      - conditions:
          - condition: numeric_state
            entity_id: input_number.robo_cleanups_done
            above: 2
        sequence:
          - service: notify.mobile_app_person_1
            data:
              title: Saugrobo
              message: Würde reinigen, aber Staubbehälter ist voll
      - conditions:
          - condition: numeric_state
            entity_id: input_number.robo_cleanups_done
            below: 3
        sequence:
          - service: notify.mobile_app_person_1
            data:
              title: Saugrobo
              message: Automatic Cleanup Start
          - service: input_boolean.turn_off
            target:
              entity_id: input_boolean.robo_clean_at_next_leave
            data: {}
          - device_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
            domain: vacuum
            entity_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
            type: clean
mode: single

Die Automatisierung funktioniert für einen 2-Personen-Haushalt, lässt sich aber natürlich auch erweitern.
Getriggert wird, wenn eine der beiden Personen durch den Ping Sensor von home auf not_home wechselt. Mit anderen Worten, das Smartphone dieser Person nicht mehr im WLAN verbunden ist.

Anschließend erfolgen mehrere condition Abfragen, welche alle erfüllt werden müssen, sonst wird an dieser Stelle abgebrochen.
Die ersten beiden Abfragen nutzen wieder den Ping Sensor um zu prüfen, ob jetzt alle Personen not_home sind, also die Person, die gerade die Wohnung verlassen hat, die letzte war und somit niemand mehr zu Hause ist.

Für die nächste condition wird geprüft, ob entweder sensor.dreame_d9_last_clean_30h_calc_range auf 0 ist, also die letzte Reinigung mehr als 30 Stunden zurückliegt, ODER input_boolean.robo_clean_at_next_leave auf on ist, also der Wunsch vorliegt, beim nächsten Verlassen zu reinigen.

Schließlich wird noch geprüft, ob input_boolean.robo_perma_off auf off ist, also der Robo nicht grundsätzlich für die Reinigung gesperrt wurde.

Sind alle diese Bedingungen erfüllt, beginnt die action der Automatisierung. Diese hat zu Beginn eine 30 Minuten Wartezeit (delay) und anschließend wieder mehrere condition Abfragen. Bei den ersten beiden wird wieder geprüft, ob alle Personen not_home sind. Der Grund dafür ist, dass ich nicht möchte, dass der Saugrobo loslegt, wenn ich nur sehr kurz aus der Tür gehe, z.B. um den Müll runter zu bringen.

Anschließend wird noch geprüft, ob die Uhrzeit zwischen 10:00 und 20:00 liegt. Davor und danach möchte ich nämlich grundsätzlich keine Reinigung haben. (Das verhindert auch, dass der Robo losfährt, wenn ihr in der Nacht das WLAN eures Smartphones abschaltet)

Anschließend wird mit choose einer von zwei Pfaden eingeschlagen.
Falls input_number.robo_cleanups_done über 2 liegt, wird davon ausgegangen, dass der Staubbehälter zu voll ist. In diesem Fall wird keine Reinigung durchgeführt, sondern stattdessen mittels notify die Nachricht Würde reinigen, aber Staubbehälter ist voll abgesendet. Das ist quasi wie ein Erinnerungsservice für mich, sollte ich mal vergessen haben, den Behälter zu entleeren.

Sollte input_number.robo_cleanups_done stattdessen unter 3 liegen, wird mit der Automatisierung fortgefahren.
Zuerst werde ich mittels notify mit der Nachricht Automatic Cleanup Start darüber informiert, dass der Robo jetzt loslegt. (Muss man natürlich nicht wissen, ich will es aber).

Danach wird mittels input_boolean.turn_off unser input_boolean.robo_clean_at_next_leave auf off gestellt.
Weil der Robo jetzt gleich losfahren wird, ist der Wunsch nach Reinigung jetzt ja erfüllt.

Zu guter Letzt wird noch die Entität des Saugroboters angesprochen, um die Reinigung zu beginnen.

Darstellung in Homeassistant

Die sensors, input_boolean und input_number die wir bisher definiert haben, lassen sich im Homeassistant Dashboard schön darstellen. Hier meine Version:

Der YAML Code dazu:

type: horizontal-stack
cards:
  - show_name: true
    show_icon: true
    type: button
    tap_action:
      action: call-service
      service: input_number.set_value
      target:
        entity_id: input_number.robo_cleanups_done
      data:
        value: 0
    name: Staubbehälter Reset
    icon: mdi:arrow-u-left-bottom
    icon_height: 40px
  - type: gauge
    entity: input_number.robo_cleanups_done
    name: Staubbehälter Durchgänge (Max 3)
    min: 0
    max: 3
    severity:
      green: 0
      yellow: 3
      red: 3
  - show_name: true
    show_icon: true
    type: button
    tap_action:
      action: toggle
    name: Reinigung bei nächstem Verlassen
    icon: mdi:vacuum
    entity: input_boolean.robo_clean_at_next_leave
    icon_height: 40px
  - show_name: true
    show_icon: true
    type: button
    tap_action:
      action: toggle
    entity: input_boolean.robo_perma_off
    icon: mdi:close-octagon
    name: Perma Off
    icon_height: 40px

Der erste Button Staubbehälter Reset setzt input_number.robo_cleanups_done auf 0. Diesen kann man drücken, wenn man den Staubbehälter entleert hat.

Das zweite Element ist eine Gauge-Card, welche den Wert von input_number.robo_cleanups_done anzeigt. Passend zu dem, was wir oben definiert haben, ist der Maximalwert 3. Wird dieser erreicht, wechselt die Farbe auf Rot, ein Zeichen dafür, dass der Staubbehälter als voll angesehen wird.

Das dritte Element ist der Button Reinigung bei nächstem Verlassen, dieser toggelt den Wert von input_boolean.robo_clean_at_next_leave, wodurch man den Wunsch der Reinigung beim nächsten Verlassen angeben kann.

In derselben Funktionsweise toggelt der letzte Button Perma Off den Wert input_boolean.robo_perma_off um die Reinigung zu sperren.

Abbruch der Reinigung bei Rückkehr

Wenn ich zufällig genau dann nach Hause zurückkehre, wenn der Robo gerade am Reinigen ist, möchte ich, dass dieser sofort damit aufhört und mich nicht belästigt.
Dafür habe ich folgende Automatisierung definiert:

alias: Robo Person Home, End Cleaning
description: ""
trigger:
  - platform: state
    entity_id:
      - device_tracker.person_1_ping
    from: not_home
    to: home
  - platform: state
    entity_id:
      - device_tracker.person_2_ping
    from: not_home
    to: home
condition:
  - condition: device
    device_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    domain: vacuum
    entity_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    type: is_cleaning
action:
  - device_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    domain: vacuum
    entity_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    type: dock
mode: single

Was hier passiert, ist denke ich sehr simpel. Wenn eine der beiden Personen von not_home zu home wechselt und der Robo gerade im Zustand is_cleaning ist, wird dieser umgehend auf dock geschickt.
Er fährt also in seine Basisstation zurück.

In der Praxis dauert es ein wenig, bis sich euer Smartphone mit dem WLAN verbunden hat und der Ping Sensor eure Präsenz erfolgreich erkennt. Aber normalerweise ist der Robo auf dem Rückweg, wenn ich meine Schuhe und Jacke fertig ausgezogen habe. ;-)

Notifications

Wie bereits zu Beginn erwähnt, hat Valetudo keine Verbindung zu einer Cloud (das ist sogar der Sinn der Sache). Das bedeutet aber auch, dass ihr keine direkten Benachrichtigungen über den Zustand eures Robos auf euer Smartphone bekommt.
Mit ein paar sehr einfachen Automatisierungen lässt sich das jedoch in Homeassistant nachbauen.

Mit dieser Automatisierung erhalte ich eine Benachrichtigung, wenn der Robo in einen Error-Zustand geht:

alias: Robo Error Notification
description: ""
trigger:
  - platform: state
    entity_id:
      - vacuum.valetudo_dreamed9
    from: null
    to: error
condition: []
action:
  - service: notify.notify
    data:
      message: Robo hat Error :-(
      title: Saugrobo
mode: single

Der Aufbau ist wahrscheinlich selbsterklärend, wechselt der state der Entität des Robos von einem beliebigen Zustand auf error, wird mit notify eine Benachrichtigung ausgesendet.

Auf dieselbe Weise lassen sich Automatisierungen erstellen für Benachrichtigungen, wann die Verbrauchsgegenstände des Robos ersetzt werden müssen.

Für die Sensor-Reinigung:

alias: Robo Cleaning Sensors
description: ""
trigger:
  - platform: numeric_state
    entity_id:
      - sensor.valetudo_dreamed9_sensor_cleaning
    below: 1
condition: []
action:
  - service: notify.notify
    data:
      message: Cleaning Sensors abgelaufen
      title: Saugrobo
mode: single

Für die Hauptbürste:

alias: Robo Main Brush EOL
description: ""
trigger:
  - platform: numeric_state
    entity_id:
      - sensor.valetudo_dreamed9_main_brush
    below: 1
condition: []
action:
  - service: notify.notify
    data:
      message: Main Brush abgelaufen
      title: Saugrobo
mode: single

Für die Nebenbürste:

alias: Robo Right Brush EOL
description: ""
trigger:
  - platform: numeric_state
    entity_id:
      - sensor.valetudo_dreamed9_right_brush
    below: 1
condition: []
action:
  - service: notify.notify
    data:
      message: Right Brush abgelaufen
      title: Saugrobo
mode: single

Und für den Filter:

alias: Robo Main Filter EOL
description: ""
trigger:
  - platform: numeric_state
    entity_id:
      - sensor.valetudo_dreamed9_main_filter
    below: 1
condition: []
action:
  - service: notify.notify
    data:
      message: Main Filter abgelaufen
      title: Saugrobo
mode: single

Schlussworte

Zum Schluss wie immer: Falls ihr Fragen oder Verbesserungsvorschläge habt, kontaktiert mich gerne.
Ich persönlich finde, Staubsaugroboter sind eine der besten Erfindungen im Bereich Smart Home. Nicht nur spart man sich das mühsame Staubsaugen mit der Hand, der Robo macht das auch garantiert öfter und regelmäßiger als die meisten Menschen, wodurch die Wohnung hygienischer wird.
Solltet ihr mehr als ein Stockwerk haben, würde ich euch empfehlen, einen zweiten Robo zu kaufen und die Automatisierung für diesen auf die genau gleiche Weise einzurichten.