Xenia DBL : Schnittstellen / APIs für Home-Automation und Apps

Hier ein neuer, separater Thread für die Themen:

• Schnittstellen
• APIs
• Homeautomation Einbindung (z.B. ioBroker und Home Assistant)
• App-Zugriffe und Steuerung der Xenia

 

Home Assistant - Sensoren der Xenia auslesen und nutzen:

Einträge in der configuration.yaml beide unter "sensor:"

Auslesen der Dater via Rest - URL und evtl. Interval anpassen:

Code:

  - platform: rest
    name: "Xenia_JSON_Data"
    resource: "http://xenia.localnet/overview"
    scan_interval: 5
    value_template: '1'
    json_attributes:
      - "MA_EXTRACTIONS"
      - "MA_OPERATING_HOURS"
      - "MA_STATUS"
      - "MA_CLOCK"
      - "BG_SENS_TEMP_A"
      - "BG_LEVEL_PW_CONTROL"
      - "PU_SENS_PRESS"
      - "PU_LEVEL_PW_CONTROL"
      - "PU_SET_LEVEL_PW_CONTROL"
      - "SB_SENS_PRESS"
      - "BB_SENS_TEMP_A"
      - "BB_LEVEL_PW_CONTROL"
      - "SB_STATUS"

Die ausgelesenen Daten als Sensoren bereitstellen:

Code:

  - platform: template
    sensors:
      xenia_status:
        value_template: >-
          {% if state_attr('sensor.xenia_json_data', 'MA_STATUS') == 0 %}
            Off
          {% elif state_attr('sensor.xenia_json_data', 'MA_STATUS') == 1 %}
            On
          {% elif state_attr('sensor.xenia_json_data', 'MA_STATUS') == 2 %}
            Eco
          {% else %}
            Unknown
          {% endif %}
      xenia_extractions:
        value_template: "{{ state_attr('sensor.xenia_json_data', 'MA_EXTRACTIONS') }}"
      xenia_operating_hours:
        value_template: "{{ state_attr('sensor.xenia_json_data', 'MA_OPERATING_HOURS') }}"
      xenia_clock:
       value_template: "{% set in = state_attr('sensor.xenia_json_data', 'MA_CLOCK') %}{{ (in / 65536 )| round(0) }}:{{'%02i'%( ((in % 65536) / 256) | round(0))}}:{{'%02i'%(in % 256| round(0))}}"
      xenia_bg_sens_temp_a:
        unit_of_measurement: 'ºC'
        value_template: "{{ state_attr('sensor.xenia_json_data', 'BG_SENS_TEMP_A') | round(1) }}"
      xenia_bg_level_pw_control:
       unit_of_measurement: '%'
       value_template: "{{ state_attr('sensor.xenia_json_data', 'BG_LEVEL_PW_CONTROL') }}"
      xenia_pu_sens_press:
        unit_of_measurement: 'bar'
        value_template: "{{ state_attr('sensor.xenia_json_data', 'PU_SENS_PRESS')| round(1) }}"
      xenia_pu_level_pw_control:
        unit_of_measurement: '%'
        value_template: "{{ state_attr('sensor.xenia_json_data', 'PU_LEVEL_PW_CONTROL') }}"
      xenia_pu_set_level_pw_control:
        unit_of_measurement: '%'
        value_template: "{{ state_attr('sensor.xenia_json_data', 'PU_SET_LEVEL_PW_CONTROL') }}"
      xenia_sb_sens_press:
        unit_of_measurement: 'bar'
        value_template: "{{ state_attr('sensor.xenia_json_data', 'SB_SENS_PRESS') | round(1)}}"
      xenia_bb_sens_temp_a:
        unit_of_measurement: 'ºC'
        value_template: "{{ state_attr('sensor.xenia_json_data', 'BB_SENS_TEMP_A') | round(1)}}"
      xenia_bb_level_pw_control:
        unit_of_measurement: '%'
        value_template: "{{ state_attr('sensor.xenia_json_data', 'BB_LEVEL_PW_CONTROL') }}"
      xenia_sb_status:
        value_template: "{{ state_attr('sensor.xenia_json_data', 'SB_STATUS') }}"

 

Home Assistant - Betriebszustand der Xenia (Ein - Aus - Eco) via Home Assistant steuern und meine Implementierung eines Buttons für das UI:

configuration.yaml

Steuerbefehle senden (URL anpassen)

Code:

rest_command:
  xenia_machine_control:
    url: "http://xenia.local/machine_control"
    method: POST
    payload: "action={{ action }}"
    content_type: "application/x-www-form-urlencoded"

Lovelace Button für Xenia -- der aktuelle Betriebszustand wird aus dem im vorherigen Post erstellten Sensor ausgelesen. Der Betriebszustand wird angezeigt und ein kurzer Druck schaltet um (Ein -> Aus, Aus -> Ein, Eco -> Ein) und ein langer Druck schaltet wie folgt: (Ein, Aus -> Eco, Eco -> Aus). Das ganze ist als Grid Karte gelöst. Die drei sep. Button liegen übereinander, es wird aber nur jeweils der zum Betriebszustand passende Button angezeigt.

Code:

square: false
type: grid
columns: 1
cards:
  - type: conditional
    conditions:
      - entity: sensor.xenia_status
        state: 'On'
    card:
      type: custom:mushroom-template-card
      primary: 'On'
      secondary: ''
      icon: mdi:coffee-maker
      icon_color: green
      layout: vertical
      multiline_secondary: true
      tap_action:
        action: call-service
        service: rest_command.xenia_machine_control
        data:
          action: '0'
      hold_action:
        action: call-service
        service: rest_command.xenia_machine_control
        data:
          action: '2'
  - type: conditional
    conditions:
      - entity: sensor.xenia_status
        state: 'Off'
    card:
      type: custom:mushroom-template-card
      primary: 'Off'
      secondary: ''
      icon: mdi:coffee-maker
      icon_color: red
      layout: vertical
      multiline_secondary: true
      tap_action:
        action: call-service
        service: rest_command.xenia_machine_control
        data:
          action: '1'
      hold_action:
        action: call-service
        service: rest_command.xenia_machine_control
        data:
          action: '2'
  - type: conditional
    conditions:
      - entity: sensor.xenia_status
        state: Eco
    card:
      type: custom:mushroom-template-card
      primary: Eco
      secondary: ''
      icon: mdi:coffee-maker
      icon_color: orange
      layout: vertical
      multiline_secondary: true
      tap_action:
        action: call-service
        service: rest_command.xenia_machine_control
        data:
          action: '1'
      hold_action:
        action: call-service
        service: rest_command.xenia_machine_control
        data:
          action: '0'

 

Einige Schnittstellen haben ich mir bisher aus den Quellen der Web-Schnittstelle herausgezogen.

Hilfreich wäre eine zentrale Ablage (Github ?) um das zu dokumentieren oder Xenia / @Iskanda haben dazu bereits etwas fertig oder andere Vorstellungen.

Bisher habe ich zusammen:

• http://xenia.local/overview --> JSON Sammlung von aktuellen Parameter-Zuständen
• http://xenia.local/machine_control/?action=x mit x=[0|1|2]
  • 0: Off
  • 1: On
  • 2: Eco
• http://xenia.local/scripts_list --> JSON Listen der aktuell installierten (eigenen) Skripten
• http://xenia.local/get_60 --> JSON Dataset zum letzten Bezug mit den Daten für Temperatur für Brühgruppe + Brühboiler und Pumpendruck

Was gibt es noch?

Auch wäre es gut zu wissen, was wir dem ESP32 zumuten können (Menge an Pull-Abfragen pro Zeiteinheit).

 

Uhrzeitinformationen in den Schnittstellen sind 3-Byte-Werte, mit

Byte 0: Sekunden
Byte 1: Minuten
Byte 2: Stunden

 

Polling jede Sekunde ist aber kein Problem? Evtl. auch kombiniert mit dem ein oder offenen Browser, die ja auch regelmäßig pollen?

 

Habe mir interessehalber einmal Daten aus dem Visualizer von einer Decent angesehen, da dort immer pro Messwert ein Zeitstempel mitprotokolliert wird.

Druckdaten sind mit einer Messintervall-Zielgröße von vermutlich 250ms verfügbar.

Genau:

• Avg 249,9
• Min 221,0
• Max 273,0

 

Hier strauchele ich im Moment:

Ich bekomme zwar ein {"status":"success"} bei

curl -X POST -H "Content-Type: application/x-www-form-urlencoded; charset=UTF-8" --data '{"ID": "18"}' "http://xenia.localnet/execute_script"

zurück, aber das Skript wird nicht ausgeführt.

 

Ich sehe hier auch noch 3 + 4 als Werte (bei mir im Zusammenhang mit Scriptausführungen - 3 nach Skriptstart - 4 nach Scriptende (?)).

 

Hier nachfolgend einige Snippsel, um die Xenia Skripte auch in Home Assistant zu nutzen.

Grundlagen:

a) Ausführen eines Skriptes in zwei Varianten mit jeweils unterschiedlichen Parametern (script_id als Zahl und entity_id mit einer Entity [dazu später mehr]

Code:

rest_command:
   execute_xenia_script_id:
   url: "http://192.168.111.32/execute_script?ID={{ script_id }}"

   execute_xenia_script_entity:
   url: "http://192.168.111.32/execute_script?ID={{ state_attr(entity_id, 'index') }}"

Für die manuelle Anlage von Buttons ist mit dem rest_command "execute_xenia_script_id" alles wesentlche vorhanden. Um die gesamte Liste der möglichen Skripte automatisiert anzuzeigen und aufrufen zu können, ist dann ein wenig mehr Aufwand erforderlich.

b) Ein Sensor, der die Skript-Informationen ausliest:

Code:

sensor:
  - platform: rest
    name: "xenia_scripts_list"
    resource: "http://xenia.localnet/scripts_list"
    scan_interval: 600
    json_attributes:
      - "index_list"
      - "title_list"
    value_template: "xenia_scripts_data"

c) Dazu dann ein Python-Skript, das aus "xenia_scripts_list" pro Skript eine input_text Entity erstellt.

Beispiel:


Das Python Skript rufe ich aktuell per Button manuell auf.

Code:

# Get the sensor attributes
xenia_scripts_list = hass.states.get("sensor.xenia_scripts_list")
index_list = xenia_scripts_list.attributes.get("index_list")
title_list = xenia_scripts_list.attributes.get("title_list")

# Get all input_text.xenia_script_ entities
xenia_input_text_entities = [
    entity for entity in hass.states.all() if entity.entity_id.startswith("input_text.xenia_script_")
]

if index_list and title_list:
    # Merge the index_list and title_list into a list of dictionaries
    xenia_scripts = [
        {"index": index, "name": title}
        for index, title in zip(index_list, title_list)
    ]

    # Create or update input_text entities for each script in the xenia_scripts variable
    for script in xenia_scripts:
        entity_id = f"input_text.xenia_script_{script['index']}"

        # Check if the entity already exists
        existing_entity = hass.states.get(entity_id)
        if existing_entity:
            # Update the entity's attributes and value
            hass.states.set(
                entity_id,
                str(script["name"]),
                {"name": script["name"], "index": script["index"]}
            )
        else:
            # Create a new input_text entity and set the value to the index value
            hass.services.call(
                "input_text",
                "set_value",
                {"entity_id": entity_id, "value": str(script['index'])},
            )

            # Set the entity's name and index attributes
            hass.states.set(
                entity_id, str(script["name"]), {"name": script["name"], "index": script["index"]}
            )

    # Remove input_text.xenia_script_ entities that are not in the xenia_scripts list
    current_xenia_script_entities = [f"input_text.xenia_script_{script['index']}" for script in xenia_scripts]
    entities_to_remove = [entity for entity in xenia_input_text_entities if entity.entity_id not in current_xenia_script_entities]

    for entity in entities_to_remove:
        hass.services.call("input_text", "remove", {"entity_id": entity.entity_id})
        logger.info(f"Removed {entity.entity_id}")

else:
    logger.error("Failed to fetch data from sensor.xenia_scripts_list")

d) Auto-Entities Card, um die vorhandenen Skripte anzuzeigen und dann auch per tap_action aufrufen zu können.

Code:

type: custom:auto-entities
card:
  square: false
  columns: 1
  type: grid
show_empty: false
card_param: cards
filter:
  include:
    - entity_id: input_text.xenia_script_*
      options:
        type: custom:mushroom-template-card
        entity: this.entity_id
        primary: |
          {{ state_attr(entity, 'name')}} [{{state_attr(entity, 'index')}}]
        tap_action:
          action: call-service
          service: rest_command.execute_xenia_script_entity
          data:
            entity_id: this.entity_id

 

Finde gerade noch:

http://xenia.local/overview_single liefert die Infos zu:

BG_SET_TEMP
PU_SET_PRESS
PU_SENS_WATER_TANK_LEVEL
SB_SET_PRESS
BB_SET_TEMP

als JSON.

In HomeAssistant sieht das dann wie folgt aus:

Code:

  - platform: rest
    name: "Xenia_JSON_Data_Single"
    resource: "http://xenia.localnet/overview_single"
    scan_interval: 60
    value_template: "1"
    json_attributes:
      - "BG_SET_TEMP"
      - "PU_SET_PRESS"
      - "PU_SENS_WATER_TANK_LEVEL"
      - "SB_SET_PRESS"
      - "BB_SET_TEMP"

und

Code:

  - platform: template
    sensors:
      xenia_bg_set_temp:
        unit_of_measurement: "ºC"
        friendly_name: "Xenia BG Set Temperature"
        value_template: "{{ state_attr('sensor.xenia_json_data_single', 'BG_SET_TEMP') }}"
      xenia_pu_set_press:
        unit_of_measurement: "bar"
        friendly_name: "Xenia PU Set Pressure"
        value_template: "{{ state_attr('sensor.xenia_json_data_single', 'PU_SET_PRESS') }}"
      xenia_pu_sens_water_tank_level:
        friendly_name: "Xenia PU Sens Water Tank Level"
        value_template: "{{ state_attr('sensor.xenia_json_data_single', 'PU_SENS_WATER_TANK_LEVEL') }}"
      xenia_sb_set_press:
        unit_of_measurement: "bar"
        friendly_name: "Xenia SB Set Pressure"
        value_template: "{{ state_attr('sensor.xenia_json_data_single', 'SB_SET_PRESS') }}"
      xenia_bb_set_temp:
        unit_of_measurement: "ºC"
        friendly_name: "Xenia BB Set Temperature"
        value_template: "{{ state_attr('sensor.xenia_json_data_single', 'BB_SET_TEMP') }}"

 

Nachdem der Versuch mit dem Spülen zur Verkürzung der Aufwärmzeit leider aktuell keine für mich ausreichende Beschleunigung erzielt werden konnte, habe ich mir etwas sehr simples in Home Assistant angelegt. Es gibt jetzt eine Benachrichtigung auf mein Mobiltelefon + SmartWatch, wenn meine Xenia nach dem Einschalten aufgeheizt ist, Mich hat es selbst überrascht, wie nützlich das ist. Daher hier die Beschreibung zur Automation:

Ablauf:

- Aktivierung beim Wechsel der Xenia von Off zu On.

- Warten , dass die gemessene Temperatur der Brühgruppe größer ist, als der Zielwert für die BG. (Warten ist begrenzt auf 10 Minuten - falls der Zielzustand nicht erreicht wird, dann Abbruch des Skripts - keine Benachrichtigung)

- Absenden der Nachricht




Und hier die YAML-Automation:

Code:

alias: Xenia Ready Notification
description: ""
trigger:
  - platform: state
    entity_id:
      - sensor.xenia_status
    from: "Off"
    to: "On"
condition: []
action:
  - wait_for_trigger:
      - platform: numeric_state
        entity_id: sensor.xenia_bg_sens_temp_a
        above: sensor.xenia_bg_set_temp
    timeout:
      hours: 0
      minutes: 10
      seconds: 0
      milliseconds: 0
    continue_on_timeout: false
    enabled: true
  - service: notify.mobile_app_<Mobile Device>
    data:
      message: Xenia ready
      data:
        visibility: public
mode: single