---
title: "Integracja z Home Assistant - alerty inteligentnego domu"
sidebarTitle: Home Assistant
description: "Połącz Home Assistant z Echobell i odbieraj natychmiastowe alerty z domu: bezpieczeństwo, ruch, temperatura i automatyzacje jako push lub połączenie."
---

import { Step, Steps } from "fumadocs-ui/components/steps";

# Integracja z Home Assistant

[Home Assistant](https://www.home-assistant.io/) to rozbudowana, otwartoźródłowa platforma automatyki domowej, która stawia na lokalną kontrolę i prywatność. Łącząc Echobell z Home Assistant, możesz odbierać natychmiastowe powiadomienia, a nawet połączenia telefoniczne, gdy w Twoim inteligentnym domu wydarzy się coś ważnego — czy będzie to alert bezpieczeństwa, przekroczenie progu temperatury, czy zadziałanie automatyzacji.

Ten przewodnik przeprowadzi Cię przez konfigurację Echobell tak, aby odbierać powiadomienia z automatyzacji Home Assistant przy użyciu webhooków lub usługi RESTful Notify.

## Wymagania wstępne

Zanim zaczniesz, upewnij się, że masz:

- Zainstalowaną na urządzeniu mobilnym [aplikację Echobell](https://apps.apple.com/app/apple-store/id6743597198?pt=128151925&ct=docs-developer-home-assistant-pl&mt=8) / [Google Play](https://play.google.com/store/apps/details?id=one.echobell.echobellandroid)
- Aktywny kanał Echobell (jeśli jeszcze go nie masz, utwórz go w aplikacji)
- Działającą instancję Home Assistant (zalecana wersja 2023.1 lub nowsza)
- Dostęp do konfiguracji Home Assistant

## Metoda 1: wyzwalacze webhook (zalecana)

Metoda z webhookiem jest najbardziej elastyczna — pozwala wysyłać własne dane i używać [zmiennych szablonu](/docs/template) w powiadomieniach.

<Steps>
<Step>
### Pobierz adres URL webhooka Echobell

1. Otwórz aplikację Echobell i przejdź do swojego kanału
2. Dotknij kanału, aby zobaczyć jego szczegóły
3. Znajdź **adres URL webhooka** w sekcji wyzwalaczy
4. Skopiuj adres — będzie wyglądał tak: `https://hook.echobell.one/t/<channel-token>`
</Step>
<Step>

### Utwórz automatyzację w Home Assistant

W Home Assistant możesz wyzwalać powiadomienia Echobell przy użyciu usługi `rest_command`. Najpierw dodaj polecenie REST do pliku `configuration.yaml`:

```yaml
rest_command:
  echobell_notify:
    url: "https://hook.echobell.one/t/<channel-token>"
    method: POST
    content_type: "application/json"
    payload: '{"title": "{{ title }}", "message": "{{ message }}"}'
```

Zastąp `YOUR_TOKEN` swoim właściwym tokenem webhooka Echobell.

Po dodaniu tego wpisu zrestartuj Home Assistant, aby wczytać nową konfigurację.

</Step>
<Step>
### Użyj w automatyzacjach

Teraz możesz wywołać tę usługę z dowolnej automatyzacji. Oto przykład powiadomienia o otwarciu drzwi:

```yaml
automation:
  - alias: "Door Open Alert"
    trigger:
      - platform: state
        entity_id: binary_sensor.front_door
        to: "on"
    action:
      - service: rest_command.echobell_notify
        data:
          title: "Security Alert"
          message: "Front door opened at {{ now().strftime('%H:%M') }}"
```

</Step>
<Step>
### Skonfiguruj szablony powiadomień

W ustawieniach kanału Echobell skonfiguruj szablony powiadomień tak, aby wyświetlały dane z webhooka:

- **Szablon tytułu**: `{{title}}`
- **Szablon treści**: `{{message}}`

Od tej chwili, gdy automatyzacja zadziała, otrzymasz powiadomienie z własnym tytułem i treścią.

</Step>
</Steps>

## Metoda 2: platforma RESTful Notify

Jeśli wolisz ściślejszą integrację, możesz skonfigurować Echobell jako usługę notify w Home Assistant.

### Konfiguracja

Dodaj poniższy fragment do pliku `configuration.yaml`:

```yaml
notify:
  - name: echobell
    platform: rest
    resource: https://hook.echobell.one/t/<channel-token>
    method: POST_JSON
    data:
      title: "{{ title }}"
      message: "{{ message }}"
```

Zastąp `YOUR_TOKEN` swoim tokenem webhooka Echobell, a następnie zrestartuj Home Assistant.

### Korzystanie z usługi notify

Teraz możesz używać Echobell jak każdej innej usługi notify:

```yaml
automation:
  - alias: "Low Battery Alert"
    trigger:
      - platform: numeric_state
        entity_id: sensor.phone_battery
        below: 20
    action:
      - service: notify.echobell
        data:
          title: "Low Battery Warning"
          message: "Phone battery is at {{ states('sensor.phone_battery') }}%"
```

## Zaawansowane zastosowania

### Monitoring temperatury z alertami krytycznymi

Wykorzystaj [typy powiadomień](/docs/notification), aby wysyłać krytyczne alerty o temperaturze jako połączenia:

```yaml
rest_command:
  echobell_critical:
    url: "https://hook.echobell.one/t/<channel-token>"
    method: POST
    content_type: "application/json"
    payload: '{"temperature": "{{ temperature }}", "location": "{{ location }}", "severity": "critical"}'
```

W kanale Echobell ustaw [typ powiadomienia](/docs/notification) na „Połączenie” (Calling) i użyj takiego szablonu:

- **Tytuł**: `Critical Temperature Alert`
- **Treść**: `{{location}} temperature is {{temperature}}°C - Immediate attention required!`

### Integracja z systemem bezpieczeństwa

Skonfiguruj kompleksowy monitoring bezpieczeństwa:

```yaml
automation:
  - alias: "Security Breach Detection"
    trigger:
      - platform: state
        entity_id:
          - binary_sensor.motion_detector_1
          - binary_sensor.motion_detector_2
          - binary_sensor.window_sensor
        to: "on"
    condition:
      - condition: state
        entity_id: alarm_control_panel.home_alarm
        state: "armed_away"
    action:
      - service: rest_command.echobell_notify
        data:
          title: "🚨 Security Alert"
          message: "{{ trigger.to_state.attributes.friendly_name }} detected activity while system armed"
          sensor: "{{ trigger.entity_id }}"
          timestamp: "{{ now().isoformat() }}"
```

### Powiadomienia ze sprzętu AGD

Śledź cykle pracy urządzeń i dowiedz się, gdy się zakończą:

```yaml
automation:
  - alias: "Washing Machine Complete"
    trigger:
      - platform: state
        entity_id: sensor.washing_machine_power
        to: "0"
        for:
          minutes: 3
    action:
      - service: notify.echobell
        data:
          title: "Washing Machine Done"
          message: "Your laundry is ready to be moved to the dryer"
```

### Monitoring warunków otoczenia

Śledź jakość powietrza, wilgotność i inne parametry środowiskowe:

```yaml
automation:
  - alias: "High CO2 Alert"
    trigger:
      - platform: numeric_state
        entity_id: sensor.living_room_co2
        above: 1000
    action:
      - service: rest_command.echobell_notify
        data:
          title: "Air Quality Warning"
          message: "CO2 level in living room is {{ states('sensor.living_room_co2') }} ppm. Consider ventilating."
```

## Inteligentne filtrowanie przy użyciu warunków

Możesz użyć [warunków Echobell](/docs/conditions), aby filtrować powiadomienia według wybranych kryteriów. Na przykład powiadamiać tylko o określonych porach albo wtedy, gdy wartości przekroczą progi:

Ustaw warunek w swoim kanale Echobell:

```
severity == "critical" || (hour >= 22 || hour <= 7)
```

Powiadomienia zostaną wysłane tylko wtedy, gdy waga alertu jest krytyczna LUB gdy jest noc (od 22:00 do 7:00).

W automatyzacji Home Assistant dołącz odpowiednie dane:

```yaml
action:
  - service: rest_command.echobell_notify
    data:
      title: "Temperature Alert"
      message: "Freezer temperature: {{ states('sensor.freezer_temp') }}°C"
      severity: "{% if states('sensor.freezer_temp') | float > -10 %}critical{% else %}normal{% endif %}"
      hour: "{{ now().hour }}"
```

## Wysyłanie danych z czujników

Do powiadomień Echobell możesz przekazać dowolne dane z czujników Home Assistant:

```yaml
rest_command:
  echobell_sensor_update:
    url: "https://hook.echobell.one/t/<channel-token>"
    method: POST
    content_type: "application/json"
    payload: >
      {
        "sensor_name": "{{ sensor_name }}",
        "current_value": "{{ current_value }}",
        "unit": "{{ unit }}",
        "state": "{{ state }}",
        "timestamp": "{{ timestamp }}"
      }
```

## Obsługa nagłówków HTTP

Echobell ma dostęp do nagłówków HTTP z żądań webhooka. Przydaje się to przy uwierzytelnianiu lub śledzeniu:

```yaml
rest_command:
  echobell_with_headers:
    url: "https://hook.echobell.one/t/<channel-token>"
    method: POST
    headers:
      X-Home-Assistant-Instance: "{{ instance_name }}"
      X-Automation-ID: "{{ automation_id }}"
    content_type: "application/json"
    payload: '{"message": "{{ message }}"}'
```

W szablonie Echobell odwołasz się do nagłówków tak:

```
{{header["x-home-assistant-instance"]}}
```

## Diagnostyka i testowanie

### Przetestuj webhook

Skorzystaj z Narzędzi programisty → Usługi w Home Assistant, aby przetestować konfigurację:

1. Wybierz `rest_command.echobell_notify`
2. Wpisz dane testowe:

```yaml
title: "Test Notification"
message: "This is a test from Home Assistant"
```

3. Kliknij „Wywołaj usługę”
4. Sprawdź powiadomienie w aplikacji Echobell

### Sprawdź logi Home Assistant

Jeśli powiadomienia nie docierają, zajrzyj do logów Home Assistant:

```bash
# W Home Assistant przejdź do:
Settings → System → Logs

# Albo sprawdź plik dziennika:
config/home-assistant.log
```

Poszukaj błędów dotyczących `rest_command` lub żądań HTTP do `hook.echobell.one`.

### Zweryfikuj adres URL webhooka

Upewnij się, że adres URL webhooka jest poprawny:

- Powinien zaczynać się od `https://hook.echobell.one/t/`
- Token musi być dołączony
- Bez dodatkowych spacji i znaków

## Kwestie wydajnościowe

### Ograniczanie częstotliwości

Webhooki Echobell podlegają ograniczeniom częstotliwości, które chronią przed nadużyciami. Przy czujnikach o wysokiej częstotliwości:

- Nie wyzwalaj powiadomienia przy każdej aktualizacji czujnika
- Użyj `for` w wyzwalaczach, aby wygasić drgania:

```yaml
trigger:
  - platform: numeric_state
    entity_id: sensor.temperature
    above: 30
    for:
      minutes: 5 # Wyzwól dopiero po 5 minutach powyżej progu
```

### Grupowanie aktualizacji

Przy wielu powiązanych zdarzeniach rozważ połączenie ich w jedno powiadomienie:

```yaml
automation:
  - alias: "Daily Home Summary"
    trigger:
      - platform: time
        at: "09:00:00"
    action:
      - service: rest_command.echobell_notify
        data:
          title: "Morning Home Summary"
          message: >
            Temperature: {{ states('sensor.temperature') }}°C
            Humidity: {{ states('sensor.humidity') }}%
            Energy today: {{ states('sensor.daily_energy') }} kWh
            Windows open: {{ expand(states.binary_sensor) | selectattr('state', 'eq', 'on') | selectattr('attributes.device_class', 'eq', 'window') | list | count }}
```

## Dobre praktyki bezpieczeństwa

### Chroń adres URL webhooka

- Nigdy nie umieszczaj adresów URL webhooków w publicznych repozytoriach
- Do danych wrażliwych używaj mechanizmu secrets w Home Assistant
- Okresowo zmieniaj tokeny webhooków

Użycie secrets w `configuration.yaml`:

```yaml
# secrets.yaml
echobell_webhook: "https://hook.echobell.one/t/<channel-token>"

# configuration.yaml
rest_command:
  echobell_notify:
    url: !secret echobell_webhook
    method: POST
    content_type: "application/json"
    payload: '{"title": "{{ title }}", "message": "{{ message }}"}'
```

### Ograniczaj dane wrażliwe

Uważaj na to, jakie dane umieszczasz w powiadomieniach:

```yaml
# Dobrze - informacja ogólna
message: "Motion detected in living room"

# Unikaj - dane wrażliwe
message: "Security code: 1234, camera feed: http://..."
```

## Rozwiązywanie typowych problemów

### Powiadomienia nie docierają

1. **Sprawdź łączność sieciową**: upewnij się, że instancja Home Assistant ma dostęp do internetu
2. **Zweryfikuj adres URL webhooka**: skopiuj i wklej go uważnie, razem z tokenem
3. **Sprawdź aplikację Echobell**: upewnij się, że subskrybujesz dany kanał
4. **Przejrzyj logi Home Assistant**: poszukaj błędów HTTP lub przekroczeń limitu czasu

### Błędy szablonów

Jeśli szablony nie renderują się poprawnie:

1. Przetestuj szablony w Narzędziach programisty → Szablon
2. Upewnij się, że nazwy zmiennych zgadzają się między Home Assistant a Echobell
3. Sprawdź, czy nie ma literówek w składni: `{{variable}}`, a nie `{{ variable}}`

### Automatyzacja się nie wyzwala

1. Zweryfikuj warunki wyzwalania w Home Assistant
2. Uruchom automatyzację ręcznie z Narzędzi programisty
3. Sprawdź, czy stany encji odpowiadają konfiguracji wyzwalacza
4. Przeanalizuj ślady (traces) automatyzacji

## Przykład: kompletny system bezpieczeństwa

Oto rozbudowany przykład integrujący wiele czujników bezpieczeństwa:

```yaml
# configuration.yaml
rest_command:
  echobell_security:
    url: !secret echobell_security_webhook
    method: POST
    content_type: "application/json"
    payload: >
      {
        "event_type": "{{ event_type }}",
        "location": "{{ location }}",
        "sensor": "{{ sensor }}",
        "timestamp": "{{ timestamp }}",
        "alarm_state": "{{ alarm_state }}"
      }

# automations.yaml
- alias: "Security Event Handler"
  trigger:
    - platform: state
      entity_id:
        - binary_sensor.front_door
        - binary_sensor.back_door
        - binary_sensor.garage_door
        - binary_sensor.motion_hallway
        - binary_sensor.motion_living_room
      to: "on"
  action:
    - service: rest_command.echobell_security
      data:
        event_type: "{{ 'door' if 'door' in trigger.entity_id else 'motion' }}"
        location: "{{ trigger.to_state.attributes.friendly_name }}"
        sensor: "{{ trigger.entity_id }}"
        timestamp: "{{ now().strftime('%Y-%m-%d %H:%M:%S') }}"
        alarm_state: "{{ states('alarm_control_panel.home_alarm') }}"
```

W Echobell ustaw szablony:

- **Tytuł**: `Security Alert: {{event_type | upper}}`
- **Treść**: `{{location}} activated at {{timestamp}} (Alarm: {{alarm_state}})`

## Kolejne kroki

Skoro Echobell działa już z Home Assistant:

- Poznaj [typy powiadomień](/docs/notification) i różne poziomy pilności alertów
- Dowiedz się, jak [warunki](/docs/conditions) pozwalają inteligentnie filtrować powiadomienia
- Zajrzyj do [zmiennych szablonu](/docs/template) i zaawansowanego formatowania wiadomości
- Przeczytaj o [dobrych praktykach dla webhooków](/docs/webhook), aby zoptymalizować integrację

## Powiązane materiały

- [Dokumentacja Home Assistant REST Command](https://www.home-assistant.io/integrations/rest_command/)
- [Platforma RESTful Notify w Home Assistant](https://www.home-assistant.io/integrations/notify.rest/)
- [Dokumentacja webhooków Echobell](/docs/webhook)
- [System szablonów Echobell](/docs/template)