---
title: "Integrazione Home Assistant - Avvisi per la casa intelligente"
sidebarTitle: Home Assistant
description: "Collega Home Assistant a Echobell per avvisi immediati dalla tua casa intelligente: sicurezza, movimento, temperatura ed eventi di automazione come notifiche push o chiamate."
---

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

# Integrazione Home Assistant

[Home Assistant](https://www.home-assistant.io/) è una potente piattaforma open source per la domotica che mette al primo posto il controllo locale e la privacy. Integrando Echobell con Home Assistant puoi ricevere notifiche immediate e persino chiamate quando in casa succede qualcosa di importante: un allarme di sicurezza, il superamento di una soglia di temperatura o l'attivazione di un'automazione.

Questa guida ti accompagna passo per passo nella configurazione di Echobell per ricevere le notifiche dalle tue automazioni Home Assistant tramite webhook o il servizio RESTful Notify.

## Prerequisiti

Prima di iniziare, assicurati di avere:

- L'[app Echobell](https://apps.apple.com/app/apple-store/id6743597198?pt=128151925&ct=docs-developer-home-assistant-it&mt=8) / [Google Play](https://play.google.com/store/apps/details?id=one.echobell.echobellandroid) installata sul tuo dispositivo mobile
- Un canale Echobell attivo (se non ne hai ancora uno, crealo nell'app)
- Un'istanza di Home Assistant in esecuzione (consigliata la versione 2023.1 o successiva)
- L'accesso alla configurazione di Home Assistant

## Metodo 1: trigger webhook (consigliato)

Il metodo basato su webhook è il più flessibile: ti permette di inviare dati personalizzati e di usare le [variabili dei modelli](/docs/template) nelle tue notifiche.

<Steps>
<Step>
### Recupera l'URL webhook di Echobell

1. Apri l'app Echobell e vai al tuo canale
2. Tocca il canale per vederne i dettagli
3. Individua l'**URL webhook** nella sezione Trigger
4. Copia l'URL, che avrà questo aspetto: `https://hook.echobell.one/t/<channel-token>`
</Step>
<Step>

### Crea un'automazione in Home Assistant

In Home Assistant puoi attivare le notifiche di Echobell con il servizio `rest_command`. Per prima cosa, aggiungi il comando REST al tuo `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 }}"}'
```

Sostituisci `YOUR_TOKEN` con il token webhook effettivo del tuo canale Echobell.

Dopo averlo aggiunto, riavvia Home Assistant per caricare la nuova configurazione.

</Step>
<Step>
### Utilizzo nelle automazioni

Ora puoi richiamare questo servizio da qualsiasi automazione. Ecco un esempio che ti avvisa quando si apre una porta:

```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>
### Configura i modelli di notifica

Nelle impostazioni del tuo canale Echobell, configura i modelli di notifica in modo che mostrino i dati del webhook:

- **Modello del titolo**: `{{title}}`
- **Modello del contenuto**: `{{message}}`

Da questo momento, ogni volta che l'automazione si attiva ricevi una notifica con il titolo e il messaggio personalizzati.

</Step>
</Steps>

## Metodo 2: piattaforma RESTful Notify

Se preferisci un approccio più integrato, puoi configurare Echobell come servizio di notifica in Home Assistant.

### Configurazione

Aggiungi quanto segue al tuo `configuration.yaml`:

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

Sostituisci `YOUR_TOKEN` con il tuo token webhook di Echobell, poi riavvia Home Assistant.

### Usare il servizio notify

Ora puoi usare Echobell come qualsiasi altro servizio di notifica:

```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') }}%"
```

## Casi d'uso avanzati

### Monitoraggio della temperatura con avvisi critici

Usa i [tipi di notifica](/docs/notification) per far arrivare gli avvisi critici di temperatura sotto forma di chiamata:

```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"}'
```

Nel tuo canale Echobell, imposta il [tipo di notifica](/docs/notification) su "Chiamata" e usa questo modello:

- **Titolo**: `Critical Temperature Alert`
- **Contenuto**: `{{location}} temperature is {{temperature}}°C - Immediate attention required!`

### Integrazione con il sistema di sicurezza

Imposta un monitoraggio della sicurezza completo:

```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() }}"
```

### Notifiche dagli elettrodomestici smart

Tieni d'occhio i cicli degli elettrodomestici e fatti avvisare quando finiscono:

```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"
```

### Monitoraggio ambientale

Tieni sotto controllo la qualità dell'aria, l'umidità o altri parametri ambientali:

```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."
```

## Filtrare le notifiche con le condizioni

Con le [condizioni di Echobell](/docs/conditions) puoi filtrare le notifiche in base a criteri specifici: per esempio, farti avvisare solo in certe fasce orarie o solo quando un valore supera una soglia.

Imposta una condizione nel tuo canale Echobell:

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

Così la notifica parte solo se la gravità è critica oppure se è notte (dalle 22 alle 7).

Nell'automazione di Home Assistant, includi i dati corrispondenti:

```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 }}"
```

## Inviare i dati dei sensori

Puoi passare alle notifiche di Echobell i dati di qualsiasi sensore di 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 }}"
      }
```

## Gestire gli header HTTP

Echobell può leggere gli header HTTP delle richieste webhook, utili per l'autenticazione o per il tracciamento:

```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 }}"}'
```

Nel modello di Echobell puoi leggerli così:

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

## Debug e test

### Prova il webhook

Per verificare la configurazione, usa Strumenti per sviluppatori → Servizi di Home Assistant:

1. Seleziona `rest_command.echobell_notify`
2. Inserisci dei dati di prova:

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

3. Fai clic su "Chiama servizio"
4. Controlla che la notifica sia arrivata nell'app Echobell

### Controlla i log di Home Assistant

Se le notifiche non arrivano, dai un'occhiata ai log di Home Assistant:

```bash
# In Home Assistant, go to:
Settings → System → Logs

# Or check the log file:
config/home-assistant.log
```

Cerca errori legati a `rest_command` o alle richieste HTTP verso `hook.echobell.one`.

### Verifica l'URL webhook

Assicurati che l'URL del webhook sia corretto:

- Deve iniziare con `https://hook.echobell.one/t/`
- Deve contenere il token
- Non deve avere spazi o caratteri in più

## Considerazioni sulle prestazioni

### Limiti di frequenza

I webhook di Echobell sono soggetti a un limite di frequenza per prevenire gli abusi. Con i sensori che si aggiornano spesso:

- Evita di inviare una notifica a ogni aggiornamento del sensore
- Usa `for` nei trigger per fare debounce:

```yaml
trigger:
  - platform: numeric_state
    entity_id: sensor.temperature
    above: 30
    for:
      minutes: 5 # Only trigger after 5 minutes above threshold
```

### Raggruppare gli aggiornamenti

Se hai più eventi correlati, valuta di raggrupparli in un'unica notifica:

```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 }}
```

## Buone pratiche di sicurezza

### Proteggi il tuo URL webhook

- Non pubblicare mai gli URL dei webhook in repository pubblici
- Usa i secret di Home Assistant per i dati sensibili
- Ruota periodicamente i token dei webhook

Come usare i secret in `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 }}"}'
```

### Limita le informazioni sensibili

Fai attenzione ai dati che inserisci nelle notifiche:

```yaml
# Good - General information
message: "Motion detected in living room"

# Avoid - Sensitive details
message: "Security code: 1234, camera feed: http://..."
```

## Risoluzione dei problemi più comuni

### Le notifiche non arrivano

1. **Controlla la connessione di rete**: verifica che la tua istanza di Home Assistant raggiunga internet
2. **Verifica l'URL webhook**: copialo e incollalo con attenzione, token compreso
3. **Controlla l'app Echobell**: assicurati di esserti iscritto al canale
4. **Rivedi i log di Home Assistant**: cerca errori HTTP o timeout

### Errori nei modelli

Se i modelli non vengono elaborati correttamente:

1. Prova i modelli in Strumenti per sviluppatori → Modello
2. Verifica che i nomi delle variabili coincidano tra Home Assistant ed Echobell
3. Controlla che non ci siano refusi nella sintassi: `{{variable}}`, non `{{ variable}}`

### L'automazione non si attiva

1. Verifica le condizioni del trigger in Home Assistant
2. Esegui l'automazione a mano dagli Strumenti per sviluppatori
3. Controlla che gli stati delle entità corrispondano alla configurazione del trigger
4. Consulta le tracce dell'automazione per il debug

## Esempio: configurazione completa di un sistema di sicurezza

Ecco un esempio completo che integra più sensori di sicurezza:

```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') }}"
```

In Echobell, imposta i tuoi modelli:

- **Titolo**: `Security Alert: {{event_type | upper}}`
- **Contenuto**: `{{location}} activated at {{timestamp}} (Alarm: {{alarm_state}})`

## Prossimi passi

Ora che hai integrato Echobell con Home Assistant:

- Esplora i [tipi di notifica](/docs/notification) per gestire priorità diverse degli avvisi
- Scopri le [condizioni](/docs/conditions) per filtrare le notifiche in modo intelligente
- Dai un'occhiata alle [variabili dei modelli](/docs/template) per formattare i messaggi in modo avanzato
- Leggi le [buone pratiche per i webhook](/docs/webhook) per un'integrazione ottimale

## Risorse correlate

- [Documentazione REST Command di Home Assistant](https://www.home-assistant.io/integrations/rest_command/)
- [Piattaforma RESTful Notify di Home Assistant](https://www.home-assistant.io/integrations/notify.rest/)
- [Documentazione webhook di Echobell](/docs/webhook)
- [Sistema di modelli di Echobell](/docs/template)