Home Assistant – Telegram Push Meldungen

Mit der Home Assistant Telegram Plattfrom lassen sich aus Home Assistant heraus Meldungen an Telegram Chats schicken. Dies kann sehr gut verwendet werden um z.B. als Funktion einer Alarmanlage beim Öffnen einer Tür oder Bewegung in einem Zimmer informiert zu werden.

Telegram einrichten

  1. Telegram Bot erstellen und API Key erhalten: Zunächst must du einen Telegram Bot erstellen. Dazu gibt es den BotFather Bot. Du kannst diesen Bot einfach mit Telegram anchatten und ihm sagen das du einen neuen Bot erstellen möchtest. Dazu schickst du „/newbot“ und folgst den Anweisungen des BotFather. du must dann einen Namen und einen Usernamen der auf „bot“ endet vergeben. BotFather erstellt daraufhin deinen Bot und gibt dir einen HTTP Access Token (z.B. 110201543:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw) den du im weiteren Verlauf benötigst. Den Token must du sicher verwahren.

  2. Bot kontaktieren: Telegram Bots können nicht einfach Nachrichten an Benutzer schicken. Zunächst muss immer eine Nachricht vom Benutzer zum Bot geschickt worden sein. D.h. du must in Telegram eine Nachricht an deinen neuen Bot schicken. Dazu einfach in Telegram nach dem vergebenen Bot Namen suchen und anchatten.

  3. Chat ID ermitteln: Der schnellste Weg die eigene Chat ID zu ermitteln ist es den GetIDs Bot anzuchatten.

  4. Home Assistant Konfiguration anpassen: In der Home Assistant Konfiguration muss nun noch der Telegram Bot eingetragen werden. Dazu benötigst du den oben erstellten API Key deines Bots und deine Chat ID. Nach der Konfigurationsanpssung must du Home Assistant neustarten.
    # --- Telegram Notfification ---------------------------------------------------
    telegram_bot:
      - platform: polling
        api_key: "API KEY"
        allowed_chat_ids:
          - CHAT ID
    
    notify:
      - name: telegram
        platform: telegram
        chat_id: CHAT ID
    

  5. Erste Nachricht versenden: Nach der Einrichtung stehen nun neue telegram Services zur Verfügung. Am einfachsten testest du das Verschicken einer Nachricht über „Entwicklerwerkzeuge“ -> „Dienste“ und dort den Telegram Send Service (telegram_bot.send_message).

Beispiel Verwendung: Haustür Überwachung

Ein nützlicher Anwendungsfall ist z.B. die Tür-Überwachung im Rahmen einer Alarmanlage. Der Telegram Service sorgt in diesem Fall für die Meldung auf das Handy wenn die Tür geöffnet oder geschlossen wird. Unten ist ein Beispiel aufgeführt, welches in die „configuration.yaml“ aufgenommen werden kann. Der Binary Sensor „HOUSE_DOOR_SENSOR“ muss durch eine eigene Sensor Entity ausgetauscht werden.

automation:
  - alias: House door open
    trigger:
      platform: state
      entity_id: binary_sensor.HOUSE_DOOR_SENSOR
      to: 'on'
    action:
      service: telegram_bot.send_message
      data:
        message: "House door open"
  - alias: House door close
    trigger:
      platform: state
      entity_id: binary_sensor.HOUSE_DOOR_SENSOR
      to: 'off'
    action:
      service: telegram_bot.send_message
      data:
        message: "House door close"

Home Assistant – Server Monitoring mit Open Hardware Monitor

Wer zuhause einen Server betreibt hat häufig früher oder später den Wunsch diesen auch zu monitoren. So können Probleme früh erkannt werden und im Fehlerfall eine Benachrichtigung per E-Mail oder Push Nachricht auf das Handy erfolgen. Wird bereits eine Hausautomatisierung mit Home Assistant betrieben hat man bereits alles an der Hand um diesen Task zu erledigen. Aufbereitet kann dies dann wie auf dem Bild rechts aussehen.

Mit einem „Ping“ Sensor kann der Server im regelmäßigen Intervall angepingt werden und seine Up-Time überwacht werden. Außerdem lassen sich mit dem Open Hardware Monitor die Hardware überwachen. Dazu zählt u.a. die Temperatur der CPU, dessen Auslastung, die Umdrehungsgeschwindigkeit der Lüfter oder der Füllstand der Festplatten.





Open Hardware Monitor installieren

Der Open Hardware Monitor ist eine kostenlose Open Source Software zum Monitoren der Hardware. Die Installation beschränkt sich auf das Entpacken des Archives und Ausführen der „OpenHardwareMonitor.exe“ als Administrator. Anschließend sollten noch einige Einstellungen zum AutoStart vorgenommen werden und der Webserver aktiviert werden. Er ermöglicht, das neben der Windows-Oberfläche eine Webseite mit allen Werten vorhanden ist. http://localhost:8085/

Options -> Start minimized
Options -> Minimize to tray
Options -> Minimize on close
Options -> Run on Windows Startup

Options -> Remote Webserver -> Run















Windows Firewall konfigurieren

Damit die Open Hardware Monitor Daten abgerufen werden können muss noch der Port 8085 (TCP) in der Windows Firewall freigegeben werden. Am schnellsten kommst du zur Windows Firewall Management Console über das „Ausführen“ Fenster
Windows Taste + R -> "wf.msc" eintippen -> Ok
Dort dann auf „Eingehende Regeln“ und „Neue Regel…“.

Home Assistant Konfiguration

In Home Assistant ist die Integration schnell erledigt. Es muss lediglich ein neuer Sensor vom Typ „openhardwaremonitor“ in der „/config/configuration.yaml“ hinzugefügt werden. Dies ist z.B. über den Web-Editor möglich.

sensor:
  - platform: openhardwaremonitor
    host: 192.168.1.10

Wer auch den Online Status / UpTime des Servers überwachen möchte pingt diesen zyklisch mit dem BinarySensor „ping“ an:

binary_sensor:
  - platform: ping
    name: 'NAS Status'
    host: 192.168.1.10
    count: 2
    scan_interval: 60

Anschließend muss Home Assistant neu gestartet werden.

Um eine Visualisierung wie bei dem Screenshot am Anfang des Artikels zu bekommen verende ich die Custom Components Vertical Stack In Card und Bar Card. Die Entity Namen variieren je nach Hardware und können unter dem Menüpunkt Entwicklerwerkzeuge -> Zustände nach geschlagen werden.

type: custom:vertical-stack-in-card
cards:
  - type: entity
    entity: binary_sensor.farm_two
  - type: horizontal-stack
    cards:
      - type: gauge
        entity: sensor.farm_two_intel_pentium_silver_j5040_load_cpu_total
        min: 0
        max: 100
        name: CPU Load
      - type: gauge
        entity: sensor.farm_two_intel_pentium_silver_j5040_temperatures_cpu_package
        min: 0
        max: 100
        name: CPU Temp
      - type: gauge
        entity: sensor.farm_two_generic_memory_load_memory
        min: 0
        max: 100
        name: Memory Load
  - type: divider
  - type: custom:bar-card
    entities:
      - entity: sensor.farm_two_intenso_ssd_sata_iii_load_used_space
        animation:
          state: 'on'
        name: 'C: System'
        icon: mdi:harddisk
    columns: '0'
    animation:
      state: 'on'
    direction: right
    height: '100'
  - type: divider
  - type: entities
    entities:
      - icon: mdi:web
        name: Open Hardware Monitor
        type: weblink
        url: http://192.168.1.10:8085/

Möchtest du den Home Assistant Server überwachen so schau dir diesen Artikel an.

Home Assistant – Reolink IP Kamera einbinden

Hardware

Bei der Auswahl einer Reolink Kamera für die Integration in Home Assistant muss etwas darauf aufgepasst werden, dass diese auch mit Home Assistant zusammen arbeitet. Bei dem in diesem Tutorial Plugin werden unten auf der Seite einige Modelle gelistet die nicht funktionieren. z.B. gibt es von der E1 Pro verschiedene Varianten. Die normale geht nicht, die „Zoom“ sollte aber funktionieren. Im wesentlichen liegt dies daran das Reolink bei einigen Kameras auf ein Hauseigenes Protokoll setzt. Es ist daher wichtig eine Kamera zu kaufen die das standardisierte RTSP (Real Time Streaming Protocol) unterstützt.

Kamera in das Netzwerk integrieren

Viele der Kameras können wahlweise über Ethernet Kabel oder WLAN angeschlossen werden.

  • Ethernet: Hier empfiehlt sich der Reolink Client für Windows. Er kann die Kamera im Netzwerk finden und einrichten. Wichtig ist ihr eine feste IP-Adresse zu zuweisen, damit die Kamera immer unter der selben Adresse für Home Assistant erreichbar ist.
  • WLAN: Die WLAN Einrichtung geht am einfachsten über die Handy App. Hierbei wird ein QR Code unter der Kamera gescannt. Anschließend werden die WLAN Zugangsdaten eingetragen und die APP generiert hieraus einen QR Code. Dieser beinhaltet die WLAN Zugangsdaten und wird dann mit der Kamera abgefilmt. Dieses liest die Zugangsdaten aus und wählt sich in das Netzwerk ein. Anschlie0end sollte der Kamera noch eine feste IP gegeben werden. Dies geht z.B. mit der oben beschriebenen Windows Anwendung

Home Assistant Integration

Wir nutzen für die Integration der Kamera die „Home Assistant Reolink custom integration“. Am einfachsten lässt sich diese mittels HACS in Home Assistant installieren. Dazu gehst du wie unten beschrieben vor. Alternativ kannst du die Integration auch manuell installieren. Diese muss letztlich nur in das Verzeichnis „/config/custom_components/reolink_dev“ der Home Assistant Installation kopiert werden. Dazu kannst du z.B. einen Samba Server auf dem Home Assistant einrichten und über Netzwerk zugreifen.

  1. Klicke auf ACS im Home Assistant Menü
  2. Klicke auf Integrationen
  3. Klicke auf die drei Punkte in der oberen rechten Ecke
  4. und wählst „Benutzerdefinierte Repositories“
  5. Kopiere die Repository URL (https://github.com/fwestenberg/reolink_dev) in die DialogBox und
  6. wähle Integration
  7. Klicke Hinzufügen
  8. Klicke unten rechts auf den Button „durchsuchen und herunterladen von Repositories“ und suche nach Reolink
  9. Repostory hinzufügen und Home Assistant anschließend neu starten

Zum Hinzufügen der Kamera gehst du wie folgt vor:
Einstellungen -> Geräte & Dienste -> Integration hinzufügen (rechts unten) -> Reolink IP Camera eingeben und hinzufügen.

Anschließend musst du noch deine IP Adresse der Kamera einfügen und dessen Zugangsdaten. Nun sollte die Kamera als Entität in Home Assistant vorhanden sein.

Home Assistant – 7,5″ E-Paper Display (Waveshare) mit ESPHome ansteuern – Wetterstation

In diesem Tutorial beschreibe ich wie ein Waveshare e-Paper Display über ESPHome mit Home Assistant verbunden wird und als Wetterstation und zum Anzeigen weiterer Sensor Daten verwendet werden kann.

Hardware

  • E-Paper Display: Waveshare 7.5 Inch E-Paper Display HAT Module V2 Kit 800×480 Resolution. Das Display führt einen SPI Anschluss über ein Flachbandkabel heraus und kann ohne Lötarbeiten mit dem unten genannten ESP32 Driver Board verbunden werden.

  • ESP32 Driver Board: Waveshare Universal e-Paper Driver Board mit Wifi und Bluetooth. Das Board erlaubt den direkten Anschluss des Display über SPI. Wichtig ist hier die ESP32 Version zu kaufen. Es gibt auch ein ESP8266 Driver Board das ich zuerst gekauft habe. Dieses hat aber für das 7,5″ E-Paper Display nicht genug Leistung.
  • Gehäuse: Waveshare 7.5inch e-Paper Raw Panel Case. Das Gehäuse ist perfekt auf das Display abgestimmt.

  • Es wird mit Magneten zusammengehalten, so das das Display sehr schnell ein- und ausgebaut werden kann. Ich habe den ESP32 einfach auf der Rückseite montiert und mit Holz und etwas Farbe einen Ständer dran gebaut. Siehe obige Bilder. Sehr Flache Kontroller finden ggf. auch im Gehäuse Platz.

Software Konfiguration

Datenquelle – Home Assistant Weather Integration

Als Datenquelle für die Wetterinformationen nutze ich die Home Assistant Weather Integration. Diese ist in der Regel standardmäßig in Home Assitant integriert. Dabei handelt es sich um folgende Kachel im UI:

Gespeist wird die Kachel über den Sensor „weather.home“ den du in den „Entwicklerwerkzeuge -> Zustände“ finden solltest:

Um die Wetterdaten an das Display zu senden habe ich zwei neue Template Sensoren angelegt die die Werte als CSV (Comma Separated Values) dem Display zu Verfügung stellen. Die Sensoren müssen in der „config/configuration.yaml“ Datei eingetragen werden.

sensor:
 - platform: template
    sensors:
      epaper_weather_actual:
        #weahtericon;temperature;humidity,pressure;wind_speed
        value_template: "{{states('weather.home')}};{{state_attr('weather.home', 'temperature') | replace('.',',') }};{{state_attr('weather.home', 'humidity') | replace('.',',') }};{{state_attr('weather.home', 'pressure') | replace('.',',') }};{{state_attr('weather.home', 'wind_speed') | replace('.',',') }}"
      epaper_weather_forecast:
        value_template: "{{as_timestamp(state_attr('weather.home', 'forecast')[0]['datetime']) | timestamp_custom('%a') }};{{state_attr('weather.home', 'forecast')[0]['condition']}};{{state_attr('weather.home', 'forecast')[0]['temperature']| replace('.',',') }};{{state_attr('weather.home', 'forecast')[0]['templow']| replace('.',',') }};{{as_timestamp(state_attr('weather.home', 'forecast')[1]['datetime']) | timestamp_custom('%a') }};{{state_attr('weather.home', 'forecast')[1]['condition']}};{{state_attr('weather.home', 'forecast')[1]['temperature']| replace('.',',') }};{{state_attr('weather.home', 'forecast')[1]['templow']| replace('.',',') }};{{as_timestamp(state_attr('weather.home', 'forecast')[2]['datetime']) | timestamp_custom('%a') }};{{state_attr('weather.home', 'forecast')[2]['condition']}};{{state_attr('weather.home', 'forecast')[2]['temperature']| replace('.',',') }};{{state_attr('weather.home', 'forecast')[2]['templow']| replace('.',',') }};{{as_timestamp(state_attr('weather.home', 'forecast')[3]['datetime']) | timestamp_custom('%a') }};{{state_attr('weather.home', 'forecast')[3]['condition']}};{{state_attr('weather.home', 'forecast')[3]['temperature']| replace('.',',') }};{{state_attr('weather.home', 'forecast')[3]['templow']| replace('.',',') }};{{as_timestamp(state_attr('weather.home', 'forecast')[4]['datetime']) | timestamp_custom('%a') }};{{state_attr('weather.home', 'forecast')[4]['condition']}};{{state_attr('weather.home', 'forecast')[4]['temperature']| replace('.',',') }};{{state_attr('weather.home', 'forecast')[4]['templow']| replace('.',',') }}"
      epaper_sunrise:
        value_template: "{{ as_timestamp(state_attr('sun.sun', 'next_dawn')) | timestamp_custom('%H:%M') }}"
      epaper_sunset:
        value_template: "{{ as_timestamp(state_attr('sun.sun', 'next_dusk')) | timestamp_custom('%H:%M') }}"

ESP32 mit ESPHome einrichten

Das Display habe ich mit ESPHome eingerichtet. D.h. du must die ESPHome Integration in Home Assistant installieren und den ESP32 Mikrokontroller hinzufügen. Dazu verbindest du diesen mittels USB mit Home Assistant und gehst in die ESPHome Oberfläche:

Einstellungen -> Add-ons, Backups & Supervisor -> ESPHome -> Benutzeroberfläche öffnen

Hier kannst du dann mit mit „New Device“ den Mikrokontroller als ESP32 hinzufügen und diesem einen Namen geben. Siehe nachfolgende Screenshots:



Sobald der ESP32 in ESPHome integriert ist, sollte Home Assistant diesen als neue Integration finden. „Einstellungen -> Geräte & Dienste -> Integrationen“. Hier muss die Integration hinzugefügt werden, damit das Display auf die Wetterdaten von Home Assistant zugreifen kann.

ESPHome Display Konfiguration

Das Display nutzt Google Open Sans Font für die Schriften und Material Design Icon Font um z.B. die Wetter Bilder zu zeigen. Diese müsst ihr herunterladen und in den Order „config\esphome\fonts“ legen. Am einfachsten geht dies wenn ihr Samba auf dem Home Assistant einrichtet und dann über das Netzwerk auf die Verzeichnisse zugreift.
\\HOMEASSISTANT_IP\config\esphome\fonts

In der Konfiguration nutze ich die UniCodes der Bilder. Dies ist etwas robuster ein falsch eingestelltes Encoding der Konfigurationsdatei so keine Probleme bereitet. Die Unicodes der Material Design Icons kannst du hier finden.
Nachfolgend findest du meine ESPHome Konfiguration die eine Uhrzeit, Sonnen Auf- und Untergangzeiten, UpTime, WLAN Signalstärke und natürlich die Wetterdaten anzeigt:

esphome:
  name: epaper75

esp32:
  board: esp32dev
  framework:
    type: arduino

# Enable logging
logger:

# Enable Home Assistant API
api:

ota:
  password: "OTAPW"

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Epaper75 Fallback Hotspot"
    password: "FALLBACKPW"

captive_portal:


# Example configuration entry
spi:
  clk_pin: 13
  mosi_pin: 14

# --- Fonts --------------------------------------------------------------------  
font:
  - file: 'fonts/OpenSans-Bold.ttf'
    id: openSansBold_font
    size: 20
    glyphs:
      ['&', '@', '!', '?', ',', '.', '"', '%', '(', ')', '+', '-', '_', ':', '°', '0',
       '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E',
       'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
       'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ' ', 'a', 'b', 'c', 'd', 'e', 'f',
       'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
       'u', 'v', 'w', 'x', 'y', 'z', 'å', 'ä', 'ö', 'ü', 'Ä', 'Ö', 'Ü', '/', '€', '’', 'ß']

  - file: 'fonts/OpenSans-Bold.ttf'
    id: watch_font
    size: 90
    glyphs:
      [':', ".", '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
      
  # https://pictogrammers.github.io/@mdi/font/6.5.95/    Unicodes
  - file: 'fonts/materialdesignicons-webfont.ttf'
    id: materialdesign_icons_25
    size: 25
    glyphs: [
      "\U000F050F", # mdi-thermometer
      "\U000F0F55", # mdi-home-thermometer-outline
      "\U000F0F54", # mdi-home-thermometer
      "\U000F058E", # mdi-water-percent
      "\U000F029A", # mdi-gauge
      "\U000F059B", # mdi-weather-sunset
      "\U000F059C", # mdi-weather-sunrise
      "\U000F10C2", # mdi-thermometer-high
      "\U000F10C3"  # mdi-thermometer-low
      ]
      
  - file: 'fonts/materialdesignicons-webfont.ttf' 
    id: materialdesign_icons_32
    size: 32
    glyphs: [
      "\U000F091F", # mdi-wifi-strength-1
      "\U000F0922", # mdi-wifi-strength-2
      "\U000F0925", # mdi-wifi-strength-3
      "\U000F0928", # mdi-wifi-strength-4
      "\U000F092B", # mdi-wifi-strength-alert-outline
      
      "\U000F0590", # weather-cloudy
      "\U000F0F2F", # weather-cloudy-alert
      "\U000F0E6E", # weather-cloudy-arrow-right
      "\U000F0591", # weather-fog
      "\U000F0592", # weather-hail
      "\U000F0F30", # weather-hazy
      "\U000F0898", # weather-hurricane
      "\U000F0593", # weather-lightning
      "\U000F067E", # weather-lightning-rainy
      "\U000F0594", # weather-night
      "\U000F0F31", # weather-night-partly-cloudy
      "\U000F0595", # weather-partly-cloudy
      "\U000F0F32", # weather-partly-lightning
      "\U000F0F33", # weather-partly-rainy
      "\U000F0F34", # weather-partly-snowy
      "\U000F0F35", # weather-partly-snowy-rainy
      "\U000F0596", # weather-pouring
      "\U000F0597", # weather-rainy
      "\U000F0598", # weather-snowy
      "\U000F0F36", # weather-snowy-heavy
      "\U000F067F", # weather-snowy-rainy
      "\U000F0599", # weather-sunny
      "\U000F0F37", # weather-sunny-alert
      "\U000F14E4", # weather-sunny-off
      "\U000F059A", # weather-sunset
      "\U000F059B", # weather-sunset-down
      "\U000F059C", # weather-sunset-up
      "\U000F0F38", # weather-tornado
      "\U000F059D", # weather-windy
      "\U000F059E" # weather-windy-variant
      ]
      
  - file: 'fonts/materialdesignicons-webfont.ttf' 
    id: materialdesign_icons_50
    size: 80
    glyphs: [
      "\U000F0590", # weather-cloudy
      "\U000F0F2F", # weather-cloudy-alert
      "\U000F0E6E", # weather-cloudy-arrow-right
      "\U000F0591", # weather-fog
      "\U000F0592", # weather-hail
      "\U000F0F30", # weather-hazy
      "\U000F0898", # weather-hurricane
      "\U000F0593", # weather-lightning
      "\U000F067E", # weather-lightning-rainy
      "\U000F0594", # weather-night
      "\U000F0F31", # weather-night-partly-cloudy
      "\U000F0595", # weather-partly-cloudy
      "\U000F0F32", # weather-partly-lightning
      "\U000F0F33", # weather-partly-rainy
      "\U000F0F34", # weather-partly-snowy
      "\U000F0F35", # weather-partly-snowy-rainy
      "\U000F0596", # weather-pouring
      "\U000F0597", # weather-rainy
      "\U000F0598", # weather-snowy
      "\U000F0F36", # weather-snowy-heavy
      "\U000F067F", # weather-snowy-rainy
      "\U000F0599", # weather-sunny
      "\U000F0F37", # weather-sunny-alert
      "\U000F14E4", # weather-sunny-off
      "\U000F059A", # weather-sunset
      "\U000F059B", # weather-sunset-down
      "\U000F059C", # weather-sunset-up
      "\U000F0F38", # weather-tornado
      "\U000F059D", # weather-windy
      "\U000F059E" # weather-windy-variant
    ]


# --- Display Layout -----------------------------------------------------------
display:
  - platform: waveshare_epaper
    cs_pin: 15
    dc_pin: 27
    busy_pin: 25
    reset_pin: 26
    model: 7.50inv2
    update_interval: 60s
    lambda: |
     int x, y;
     
     // Grid
     it.line(0, 108, 800, 108); // Horizontal header
     it.line(0, 440, 800, 440); // Horizontal footer
     it.line(266, 108, 266, 440); // Vertical first line
     it.line(532, 108, 532, 440); // Vertical second line
     
    
     // Sunrise / Sunset
     it.printf(5, 40, id(materialdesign_icons_25), TextAlign::BASELINE_LEFT, "\U000F059C");
     it.printf(35, 40, id(openSansBold_font), TextAlign::BOTTOM_LEFT, id(epaper_sunrise).state.c_str());
      
     it.printf(5, 70, id(materialdesign_icons_25), TextAlign::BASELINE_LEFT, "\U000F059B");
     it.printf(35, 70, id(openSansBold_font), TextAlign::BOTTOM_LEFT, id(epaper_sunset).state.c_str());
     
     // Temperature inside / outside
     it.printf(100, 35, id(materialdesign_icons_25), TextAlign::BASELINE_LEFT, "\U000F0F54"); 
     //it.printf(130, 40, id(openSansBold_font), TextAlign::BOTTOM_LEFT, "%s °C", id(temperature_inside).state.c_str()); // use your own temp sensor
     
     it.printf(100, 65, id(materialdesign_icons_25), TextAlign::BASELINE_LEFT, "\U000F0F55"); 
     //it.printf(130, 70, id(openSansBold_font), TextAlign::BOTTOM_LEFT, "%s °C", id(temperature_outside).state.c_str());// use your own temp sensor
     
     //Time
     it.strftime(540, 100, id(watch_font),TextAlign::BOTTOM_LEFT, "%H:%M", id(time_homeassistant).now());
     it.strftime(540, 110, id(openSansBold_font),TextAlign::BOTTOM_LEFT, "%A, %d.%m.%y, KW %W", id(time_homeassistant).now());
      
     // Current weather 
     // https://www.home-assistant.io/integrations/weather/
     // weahtericon;temperature;humidity,pressure;wind_speed
     // ex. data:   cloudy;5,9;50;1025,6;16,9

     std::map <std::string, std::string> weatherMap =  { 
      std::make_pair("exceptional","\U000F0F2F"),
      std::make_pair("cloudy","\U000F0590"),
      std::make_pair("cloudy-alert","\U000F0F2F"),
      std::make_pair("fog","\U000F0591"),
      std::make_pair( "hail","\U000F0592"),
      std::make_pair( "hazy","\U000F0F30"),
      std::make_pair( "hurricane","\U000F0898"),
      std::make_pair( "lightning","\U000F0593"),
      std::make_pair( "lightning-rainy","\U000F067E"),
      std::make_pair( "night","\U000F0594"),
      std::make_pair( "clear-night","\U000F0594"),
      std::make_pair( "night-partly-cloudy","\U000F0F31"),
      std::make_pair( "partly-cloudy","\U000F0595"),
      std::make_pair( "partlycloudy","\U000F0595"),
      std::make_pair( "partly-lightning","\U000F0F32"),
      std::make_pair( "partly-rainy","\U000F0F33"),
      std::make_pair( "partly-snowy","\U000F0F34"),
      std::make_pair( "partly-snowy-rainy","\U000F0F35"),
      std::make_pair( "pouring","\U000F0596"),
      std::make_pair( "rainy","\U000F0597"),
      std::make_pair( "snowy","\U000F0598"),
      std::make_pair( "snowy-heavy","\U000F0F36"),
      std::make_pair( "snowy-rainy","\U000F067F"),
      std::make_pair( "sunny","\U000F0599"),
      std::make_pair( "sunny-alert","\U000F0F37"),
      std::make_pair( "sunny-off","\U000F14E4"),
      std::make_pair( "tornado","\U000F0F38"),
      std::make_pair( "windy","\U000F059D"),
      std::make_pair( "windy-variant","\U000F059E")};
      
     if(id(epaper_weather_actual).has_state()) {
       std::string actualWeatherCSV = id(epaper_weather_actual).state; //("cloudy;5,9;50;1025,6;16,9");
       ESP_LOGI("Weather today", "%s", actualWeatherCSV.c_str());
       std::size_t current, previous = 0;
       char delim = ';';
       current = actualWeatherCSV.find(delim);
       x = 5; y = 200;
       for (int i=0; i<5; i++) {
           const char * value = actualWeatherCSV.substr(previous, current - previous).c_str();
           if(i == 0) { // icon
             std::string unicodeWeatherIcon = weatherMap.at(value);
             it.printf(x , y, id(materialdesign_icons_50), TextAlign::BASELINE_LEFT, unicodeWeatherIcon.c_str()); 
             y = 120;
             x = x + 90;
           } else if (i == 1) { // temperature
              it.printf(x, y, id(openSansBold_font), TextAlign::BASELINE_LEFT,"%s  °C", value);
           } else if (i == 2) { // humidity
              it.printf(x, y, id(openSansBold_font), TextAlign::BASELINE_LEFT,"%s %s", value, "%");
           } else if (i == 3) { // pressure
              it.printf(x, y, id(openSansBold_font), TextAlign::BASELINE_LEFT,"%s PA", value);
           } else if (i == 4) { // windpeed
              it.printf(x, y, id(openSansBold_font), TextAlign::BASELINE_LEFT,"%s m/s", value);
           }
           y += 25;
           previous = current + 1;
           current = actualWeatherCSV.find(delim, previous);
       }
     }
     
     // Weather Forecast
     if(id(epaper_weather_forecast).has_state()) {
       std::string forecastWeatherCSV = id(epaper_weather_forecast).state; // Mon;sunny;16,5;5,1;Tue;sunny;17,2;6,8;Wed;sunny;15,4;2,7;Thu;sunny;15,3;4,6;Fri;partlycloudy;16,0;3,5
       ESP_LOGI("Weather forecast", "%s", forecastWeatherCSV.c_str());
       std::size_t current, previous = 0;
       char delim = ';';
       current = forecastWeatherCSV.find(delim);
       x = 5; y = 270;
       int nextRow =0;
       for (int i=0; i<20; i++) {
           const char * value = forecastWeatherCSV.substr(previous, current - previous).c_str();
           if(i == 0 || i == 4 || i == 8 || i == 12 || i == 16) { // Weekday
              it.printf(x, y, id(openSansBold_font), TextAlign::BASELINE_LEFT,"%s", value);
           } else if (i == 1 || i == 5 || i == 9 || i == 13 || i == 17) { // icon
             it.printf(x + 50  , y, id(materialdesign_icons_32), TextAlign::BASELINE_LEFT, weatherMap.at(value).c_str()); 
           } else if (i == 2 || i == 6 || i == 10 || i == 14 || i == 18) { // Temp high
              it.printf(x + 100 , y, id(openSansBold_font), TextAlign::BASELINE_LEFT,"%s°C", value);
           } else if (i == 3 || i == 7 || i == 11 || i == 15 || i == 19) { // Temp low
              it.printf(x + 170, y, id(openSansBold_font), TextAlign::BASELINE_LEFT,"%s °C", value);
           }
           nextRow = nextRow + 1;
           if (nextRow == 4) {
             y += 28;
             nextRow = 0;
           }
           previous = current + 1;
           current = forecastWeatherCSV.find(delim, previous);
       }
     }
      
     // -- Footer ---
     //IP Adress
     if (id(ip_address).has_state()) {
         it.printf(5, 470, id(openSansBold_font), TextAlign::BASELINE_LEFT, "IP: %s", id(ip_address).state.c_str());
     }
      
     // WiFi Signal Strength
     if(id(wifisignal).has_state()) {
       x = 210, y = 475;
       if (id(wifisignal).state >= -50) {
           it.print(x, y, id(materialdesign_icons_32), TextAlign::BOTTOM_RIGHT, "\U000F0928");
           ESP_LOGI("WiFi", "Exellent");
       } else if (id(wifisignal).state  >= -60) {
           it.print(x, y, id(materialdesign_icons_32), TextAlign::BOTTOM_RIGHT, "\U000F0925");
           ESP_LOGI("WiFi", "Good");
       } else if (id(wifisignal).state  >= -67) {
           it.print(x, y, id(materialdesign_icons_32), TextAlign::BOTTOM_RIGHT, "\U000F0922");
           ESP_LOGI("WiFi", "Fair");
       } else if (id(wifisignal).state  >= -70) {
           it.print(x, y, id(materialdesign_icons_32), TextAlign::BOTTOM_RIGHT, "\U000F091F");
           ESP_LOGI("WiFi", "Weak");
       } else {
           it.print(x, y, id(materialdesign_icons_32), TextAlign::BOTTOM_RIGHT, "\U000F092B");
           ESP_LOGI("WiFi", "Unlikely");
       }
     }
     
     // ESP Home UpTime
     if (id(uptime_human).has_state()) {
         it.printf(520, 470, id(openSansBold_font), TextAlign::BASELINE_LEFT, "UpTime: %s", id(uptime_human).state.c_str());
     }
     
     
     
    

# --- Sensors ------------------------------------------------------------------
sensor:

    # ESP Home UpTime
  - platform: uptime
    id: uptime_sensor
    update_interval: 60s
    on_raw_value:
      then:
        - text_sensor.template.publish:
            id: uptime_human
            state: !lambda |-
              int seconds = round(id(uptime_sensor).raw_state);
              int days = seconds / (24 * 3600);
              seconds = seconds % (24 * 3600);
              int hours = seconds / 3600;
              seconds = seconds % 3600;
              int minutes = seconds /  60;
              seconds = seconds % 60;
              return (
                (days ? String(days) + ":" : "000:") +
                (hours ? String(hours) + ":" : "00:") +
                (minutes ? String(minutes) + ":" : "00:") +
                (String(seconds) + "")
              ).c_str();  
  - platform: wifi_signal
    id: wifisignal
    update_interval: 60s

text_sensor:
  # ESP WLAN IP Address
  - platform: wifi_info
    ip_address:
      name: "${name} IP Address"
      id: ip_address
  # ESP Home UpTime
  - platform: template
    id: uptime_human
    icon: mdi:clock-start
  # Weather forecast 
  - platform: homeassistant
    id: epaper_weather_actual
    entity_id: sensor.epaper_weather_actual
    internal: true
  - platform: homeassistant
    id: epaper_weather_forecast
    entity_id: sensor.epaper_weather_forecast
    internal: true
  - platform: homeassistant
    id: epaper_sunrise
    entity_id: sensor.epaper_sunrise
    internal: true
  - platform: homeassistant
    id: epaper_sunset
    entity_id: sensor.epaper_sunset   
    internal: true

time:
  - platform: homeassistant
    id: time_homeassistant

Home Assistant – Benzinpreise anzeigen

Tankerkönig biete eine REST API mit der aktuelle Spritpreise abgefragt werden können. Die Integration in Home Assistant gestaltet sich einfach, da bereits ein Plugin verfügbar ist. Um die Spritpreise als Sensor zur Verfügung zu stellen reichen folgende Schritte:

  • Zunächst must du einen API Schlüssel für die Nutzung der Tankerkönig API beantragen. Das geht auf der Tankerkönig Webseite bei dem Menüpunkt „API-Key“.
  • Mit dem API-Key kannst du nun alle Tankstellen im Umkreis von x Kilometern um einen Punkt abfragen. Dazu must du in der unteren URL deinen gewünschten Längen und Breitengrad eingeben. Diesen findest du z.B. mit Google Maps heraus, indem du in der Karte einen Rechtsklick machst. In dem PopUp Menü stehen dann oben die Koordinaten und lassen sich direkt in die Zwischenablage kopieren. Der Parameter „rad“ gibt den Radius in Kilometern um deinen Punkt an in dem die Tankstellen aufgelistet werden sollen und „key“ ist dein beantragter API Key.
    https://creativecommons.tankerkoenig.de/json/list.php?lat=51.297&lng=6.850&rad=1.5&sort=dist&type=all&apikey=00000000-0000-0000-0000-000000000002
    
  • Um die Tankstellen in Home Assistant zu integrieren must du noch die Tankerkönig Integration in der configurations.yaml eintragen und festlegen welche Tankstellen mit welchem Kraftstofftyp, in welchem Intervall abgefragt werden sollen. Nach dem Ändern der Konfiguration muss Home Assistant neu gestartet werden.

    tankerkoenig:
      api_key: "00000000-0000-0000-0000-000000000002"
      fuel_types:
        - "e5" 
      scan_interval: "0:10:01"
      stations:
        - 79fb1f24-bebb-489e-841f-728f9053b555
        - 7e4c09ab-ab7d-4a13-af99-d043a611e410
      show_on_map: true
    
  • Nun solltest du für jede iengetragene Tabkstelle einen Sensor finden. Diese beginnen mit „sensor.tankerkoenig_“. Kontrollieren kannst du dies z.B. in der Liste der Sensoren bei „Entwicklerwerkzeuge -> Zustände“. Eine Integration in die GUI sieht in der einfachsten Form so aus.
  • Pro Tipp: Ich hatte es schon zwei mal das alle Tankerkönig Sensoren nicht verfügbar waren. Dies lag bei mir daran, das eine der Tankstellen in meiner Liste eine neue ID erhalten hatte. Dies kommt z.B. vor wenn eine Tankstelle von einer anderen Marke übernommen wird. Hier scheint das Home Assistant Plugin nicht sehr fehlertolerant programmiert zu sein, so das dann alle Sensoren nicht verfügbar sind. In einem solchen Fall empfiehlt es sich daher einmal seine konfigurierten Tankstellen IDs mit denen aus der Umkreissuche abzugleichen.

Home Assistant – Netzwerkfreigaben für Dateien mit Samba

Um auf die Konfigurationsdateien auf dem Home Assistant direkt unter Windows zugreifen zu können, empfiehlt es sich, diese per Netzwerkfreigabe zur Verfügung zu stellen. Unter Linux sorgt die Samba für die Unterstützung des SMB/CIFS Protokolls für die Netzwerkfreigaben. Samba kannst du einfach als Erweiterung aus dem Home Assistant Add-On Store laden:

Einstellungen -> Add-ons, Backups & Supervisor -> Add-on Store 
-> "Samba" (Im Suchfeld eingeben) -> Installieren

In der Konfiguration des Plugins musst du dann noch dein Arbeitsgruppen-Namen deines Windows Netzwerkes eintragen, sowie deinen Windows-Account, mit dem du dich auf die Home Assistant Netzwerkfreigabe verbinden möchtest. Bei den „Allowed Hosts“ kannst du die Netzwerksegmente einstellen, die Zugriff erhalten. In der Regel fällt dein privates Netzwerk bereits in den unten angegebenen Bereich.

workgroup: WORKGROUP
username: USER
password: PASSWORD
allow_hosts:
  - 10.0.0.0/8
  - 172.16.0.0/12
  - 192.168.0.0/16
veto_files:
  - ._*
  - .DS_Store
  - Thumbs.db
  - icon?
  - .Trashes
compatibility_mode: false
interface: eth0

Nun ist alles eingerichtet und du kannst einfach auf die Dateien des Home Assistant zugreifen, indem du im Windows Dateiexplorer den UNC Pfad deines Home Assistant eingibst.

\\IP_ADRESSE_HOME_ASSISTANT

Unter „Computer -> Netzlaufwerk verbinden“ kannst du der Netzwerkfreigabe auch einen permanenten Laufwerksbuchstaben zuweisen.

Die zentrale Konfiguration von Home Assistant findest du im Verzeichnis „config“ in der Datei „configurations.yaml“. Custom Components werden im Verzeichnis „config/custom_components“ abgelegt. Diese können komfortabel mit HACS installiert werden, oder manuell in das Verzeichnis kopiert werden.

Home Assistant – Browserbasierte Konfiguration

Die Konfiguration von Home Assistant erfolgt mittels YAML Syntax in der Datei „/config/configuration.yaml“. Wenn YAML für dich neu ist der wichtige Hinweis, dass die Verschachtelung über Leerzeichen erreicht wird und diese daher für eine korrekt formatierte Datei wichtig ist. Achte also immer auf die Einrückungen.

Du kannst die Datei direkt auf deinem Home Assistant Server editieren. z.B. indem du auf diesen mittels SSH, FTP oder Samba (CIFS Windows Share) zugreifst. Komfortabler geht dies aber direkt über die Home Assistant Weboberfläche mithilfe des „File Editor“ Plugins. Das Plugin zeigt dir auch oben rechts mit einem roten Icon wenn deine Datei nicht YAML konform ist.

Das Plugin ist Ruck Zuck installiert:

Einstellungen -> Add-ons, Backups & Supervisor -> Add-on Store -> "File Editor" (Im Suchfeld eingeben) -> Installieren

Ein Klick auf „Benutzeroberfläche öffnen“ startet den Editor.

Das Ordnersymbol oben rechts lässt dich die zentrale Konfigurationsdatei „/config/configuration.yaml“ auswählen.