Home Assistant - come usare un gateway ZigBee USB cc2530 + ampli cc2592

Oggi torniamo a parlare di ZigBee.

ZigBee è il famosissimo protocollo di comunicazione scelto da tanti brand di accessori per le Smart Home.

Come sicuramente saprete, i dispositivi dotati di protocollo ZigBee non si collegano direttamente alla rete, ma lo fanno attraverso un Gateway.

Di fatto i sub-device non avranno bisogno di un indirizzo IP di conseguenza non andranno ad intasare il vostro router.

Un ulteriore vantaggio di questa tipologia di connessione è la modalità mesh.

Con questa caratteristica i dispositivi oltre che al gateway si connetteranno tra loro estendendo la portata del segnale ZigBee.

Questa caratteristica è associata di solito solo ai dispositivi ZigBee alimentati a corrente elettrica.

I device a batteria non godono di questo plus, tuttavia rispetto ai device WiFi hanno la caratteristica di consumare pochissima batteria: un device a batteria ZigBee tiene la carica anche fino a 2 anni.

Nella precedente immagine un esempio di sensore ZigBee a batteria Aqara.

Qui invece possiamo osservare i sensori ZigBee della famiglia Sonoff di cui abbiamo proposto varie recensioni.

• Sonoff SNZB-03 - il Sensore di Movimento ZigBee targato ITEAD
• Sonoff SNZB-02 - Sensore di Umidità e Temperatura ZigBee
• SONOFF SNZB-01 - Pulsante Wireless Zigbee by Itead
• Sonoff SNZB-04 - Il Sensore porta-finestra ZigBee di Itead
• Sonoff ZigBee Bridge - la recensione

Di solito ogni azienda propone un Hub ZigBee proprietario che è compatibile con il proprio ecosistema.

Già da tempo con Home Assistant e la chiavetta usb CC2531 avevamo proposto sistema per accorpare tutti i dispositivi ZigBee di varie marche sotto un unico controllo.

https://www.vincenzocaputo.com/langolo_dei_lettori/installazione-chiavetta-usb-zigbee-su-rpi-121

La guida che avevamo scritto è basata su Raspbian, magari facciamo un recap sulla configurazione con hassio/hassos in fondo all'articolo dato che non è il focus principale.

Veniamo all'argomento principale: 

Tutta la prefazione era necessaria a presentare l'ottimo lavoro eseguito da...

Giovanni Castanía.

Giovanni da tempo studia soluzioni per il protocollo ZigBee.

Come sapete ormai, ho una certa stima per chi con il proprio lavoro riesce a rendere un servizio utile alla comunità degli appassionati di Smart Home.

Dopo vari test Giovanni ha trovato una sostituta della CC2531 

che potete osservare nella foto sopra.

La soluzione adottata è una CC2530 munita di un amplificatore CC2592

Ricorderete che queste tipologie di chiavette andavano programmate con degli accessori come ad esempio un debugger.

Se non avete intenzione di cimentarvi nell'impervia impresa, Giovanni propone un suo store dove vende dispositivi già programmati e pronti all'utilizzo.

Il dispositivo sarà pronto e confezionato all'interno di un case stampato con stampante 3d direttamente da Giovanni.

Nella fattispece questo è il modello CC2530 con amplificatore che garantisce prestazioni fino a 10 volte superiori rispetto alla semplice CC2531.

Vi basterà collegarlo al device dove avete installato hassos/hassio per usufruirne.

Più avanti nella guida guarderemo la procedura esatta.

Giovanni propone nel suo store vari device assemblati da lui.

Potrete trovare maggiori indicazioni sul sito ufficiale.

https://www.tindie.com/stores/GiovanniCas/

Tra le altre cose potrete trovare la più recente e prestante CC2538 + CC2592 che, oltre ad essere ancora più prestante rispetto alla recensita CC2530, abbatte il limite dei 16/18 device abbinabili portando il numero a 150 dispositivi.

Spero di poterla testare al più presto.

Se i device sono out of stock non temete, Giovanni crea nuovi stock ogni 15 giorni quindi, prenotando il dispositivo, riceverete direttamente un avviso che vi indicherà la disponibilità alla vendita.

Da notare i prezzi più che onesti per i dispositivi assemblati con cura e arricchiti di cover stampata in 3d.

COME CONFIGURARE LA CHIAVETTA SU HASSIO/HASSOS

Nella mia configurazione casalinga come sapete ho utilizzato un Intel nuc con a bordo Proxmox e relativa macchina virtuale HassOS.

Ne ho parlato QUI

La procedura è identica ad eccezione che, nel caso di VM, dovrete fare il passtrought delle porte usb, procedura spiegata dettagliatamente nella guida linkata poco sopra.

Per prima cosa dovrete aver installato un Broker MQTT sul vostro HA.

Passo necessario perchè la chiavetta sfrutta il componente zigbee2mqtt ovvero converte la comunicazione ZigBee in comunicazione MQTT per poter comunicare con il nostro personal HUB.

Quindi se non lo avete ancora fatto, per prima cosa nel menù supervisor dovrete installare Mosquito Broker

... avendo cura di installare e configurare con una username e una password il componente.

Successivamente riavviate e al riavvio, nel menù integrazioni, dovreste avere la possibilità di aggiungere mqtt semplicemente cliccando mqtt tra le integrazioni disponibili.

Vi consiglio di spuntare la voce autodiscovery in modo da far riconoscere in automatico tutti i device connessi tramite mqtt ad Home Assistant, compresi ovviamente i dispositivi che andremo a collegare alla usb ZigBee.

Dopo aver effettuato questo step procedete a connettere ad una porta usb del vostro device la cc2530.

(nel mio caso è già presente una vecchia cc2531 così vedremo anche la differenza di qualità del link tra i vari device.)

Una volta inserita dovrete tornare sul menù supervisor.

cliccando nel sotto menù Add-on store dovrete cliccare sul simbolo con i 3 puntini in alto a destra.

Successivamente nel menù a tendina che compare cliccate su repositories.

dovrete aggiungere questo indirizzo alla repository

https://github.com/danielwelch/hassio-zigbee2mqtt

successivamente cliccate su ADD

una volta aggiunta noterete che nel menù dei vari add-on troverete due nuove icone.

installate quello di sinistra.

prima di avviarlo andate nella sezione configuration

e compilate il file di configurazione come nella foto tenendo presente che dovrete sostituire il broker mqtt come nella foto (se avete seguito le mie indicazioni su mqtt)

e dovrete inserire la username e la password precedentemente create su mosquito broker.

Se usate una cc2531 la configurazione poco sopra va bene.

Se invece utilizzate la nuova chiave di Giovanni allora dovrete sostituire la voce port come nell'immagine seguente

Successivamente salvate e avviate l'add-on.

Dal log dovreste vedere se è andato tutto a buon fine.

Per semplificare l'accoppiamento dei dispositivi esiste un package molto ben fatto che permette di gestire i vari parametri direttamente dall'interfaccia di Home Assistant.

Quindi nella cartella package andate a creare un file.

Chiamatelo zigbee2mqtt.yaml (o come meglio preferite)

e all'interno copiate e incollate queste stringhe:

# Input select for Zigbee2mqtt debug level
input_select:
  zigbee2mqtt_log_level:
    name: Zigbee2mqtt Log Level
    options:
      - debug
      - info
      - warn
      - error
    initial: info
    icon: mdi:format-list-bulleted

# Input text to input Zigbee2mqtt friendly_name for scripts
input_text:
  zigbee2mqtt_old_name:
    name: Zigbee2mqtt Old Name
  zigbee2mqtt_new_name:
    name: Zigbee2mqtt New Name
  zigbee2mqtt_remove:
    name: Zigbee2mqtt Remove

# Scripts for renaming & removing devices
script:
  zigbee2mqtt_rename:
    alias: Zigbee2mqtt Rename
    sequence:
      service: mqtt.publish
      data_template:
        topic: zigbee2mqtt/bridge/config/rename
        payload_template: >-
          {
            "old": "{{ states.input_text.zigbee2mqtt_old_name.state | string }}",
            "new": "{{ states.input_text.zigbee2mqtt_new_name.state | string }}"
          }
  zigbee2mqtt_remove:
    alias: Zigbee2mqtt Remove
    sequence:
      service: mqtt.publish
      data_template:
        topic: zigbee2mqtt/bridge/config/remove
        payload_template: "{{ states.input_text.zigbee2mqtt_remove.state | string }}"

# Timer for joining time remaining (120 sec = 2 min)
timer:
  zigbee_permit_join:
    name: Time remaining
    duration: 120

sensor:
  # Sensor for monitoring the bridge state
  - platform: mqtt
    name: Zigbee2mqtt Bridge state
    state_topic: "zigbee2mqtt/bridge/state"
    icon: mdi:router-wireless
  # Sensor for Showing the Zigbee2mqtt Version
  - platform: mqtt
    name: Zigbee2mqtt Version
    state_topic: "zigbee2mqtt/bridge/config"
    value_template: "{{ value_json.version }}"
    icon: mdi:zigbee
  # Sensor for Showing the Coordinator Version
  - platform: mqtt
    name: Coordinator Version
    state_topic: "zigbee2mqtt/bridge/config"
    value_template: "{{ value_json.coordinator }}"
    icon: mdi:chip

# Switch for enabling joining
switch:
  - platform: mqtt
    name: "Zigbee2mqtt Main join"
    state_topic: "zigbee2mqtt/bridge/config/permit_join"
    command_topic: "zigbee2mqtt/bridge/config/permit_join"
    payload_on: "true"
    payload_off: "false"

automation:
  # Automation for sending MQTT message on input select change
  - alias: Zigbee2mqtt Log Level
    initial_state: "on"
    trigger:
      platform: state
      entity_id: input_select.zigbee2mqtt_log_level
    action:
      - service: mqtt.publish
        data:
          payload_template: "{{ states('input_select.zigbee2mqtt_log_level') }}"
          topic: zigbee2mqtt/bridge/config/log_level
  # Automation to start timer when enable join is turned on
  - id: zigbee_join_enabled
    alias: Zigbee Join Enabled
#    hide_entity: true
    trigger:
      platform: state
      entity_id: switch.zigbee2mqtt_main_join
      to: "on"
    action:
      service: timer.start
      entity_id: timer.zigbee_permit_join
  # Automation to stop timer when switch turned off and turn off switch when timer finished
  - id: zigbee_join_disabled
    alias: Zigbee Join Disabled
#    hide_entity: true
    trigger:
      - platform: event
        event_type: timer.finished
        event_data:
          entity_id: timer.zigbee_permit_join
      - platform: state
        entity_id: switch.zigbee2mqtt_main_join
        to: "off"
    action:
      - service: timer.cancel
        data:
          entity_id: timer.zigbee_permit_join
      - service: switch.turn_off
        entity_id: switch.zigbee2mqtt_main_join

salvate e riavviate Home Assistant.

al riavvio potrete inserire queste stringe sulla configurazione di lovelace:

entities:
  - entity: switch.zigbee2mqtt_main_join
  - entity: timer.zigbee_permit_join
  - entity: script.update_mappa_zigbee
  - type: divider
  - entity: sensor.bridge_state
  - entity: sensor.zigbee2mqtt_version
  - entity: sensor.coordinator_version
  - entity: input_select.zigbee2mqtt_log_level
  - type: divider
  - entity: input_text.zigbee2mqtt_old_name
  - entity: input_text.zigbee2mqtt_new_name
  - entity: script.zigbee2mqtt_rename
  - type: divider
  - entity: input_text.zigbee2mqtt_remove
  - entity: script.zigbee2mqtt_remove
  - type: divider
  - entity: input_text.zigbee2mqtt_update
  - entity: script.zigbee2mqtt_update
show_header_toggle: false
title: ZigBee
type: entities

per avere una card adatta come nell'esempio sottostante.

 una volta effettuati tutti i passaggi ci sarà uno switch su Home Assistant che abiliterà l'accoppiamento dei device.

Una volta acceso avrete 2 minuti di tempo per accoppiare un nuovo device ZigBee.

Dal log del add-on zigbee2mqtt vedrete tutti i vari passaggi compresa l'inclusione di un nuovo device mentre avete lo switch acceso.

Una volta che avete configurato il tutto c'è un altra repository molto interessantere da aggiungere con la stessa modalità con la quale avete aggiunto quella di zigbee2mqtt sul menù supervisor.

Questa volta l'indirizzo da aggiungere alla repository dell'add-on store è il seguente:

https://github.com/yllibed/hassio 

vi comparira un add-on chiamato zigbee2mqtt assistant

installate la versione di sinistra

prima di avviarlo andate nella configurazione dell'add on e aggiungete user e password, gli stessi che utilizzate per l'add on zigbee2mqtt

una volta configurato non solo vi darà una lista di device ma vi creerà una mappa della connessione ZigBee. 

a tal proposito questa è la mappa con la vecchia chiave cc2531

vediamo la differenza con la mappa creata con la chiave cc2530 inviatami da Giovanni 

Come potete notare è molto più prestante della precedente.