DomotiCasa

La tua guida alla casa intelligente

Come integrare dispositivi non compatibili con Home Assistant

Come integrare dispositivi non compatibili con Home Assistant

Giovanni Provenzano018 mins

Home Assistant è una delle piattaforme domotiche più potenti e aperte, ma non tutti i dispositivi smart sono nativamente compatibili.

I motivi principali:

  • Cloud proprietario obbligatorio (Tuya, eWeLink, app cinesi senza API locali)

  • Protocolli chiusi non documentati

  • Nessuna integrazione ufficiale sviluppata dalla community

  • Firmware limitato che blocca controllo locale

La buona notizia: nella maggior parte dei casi puoi aggirare questi limiti usando tecniche avanzate come flash firmware custom, bridge MQTT, integrazioni locali o API REST.​

Questa guida ti mostra 5 metodi collaudati per portare quasi qualsiasi dispositivo smart dentro Home Assistant, con controllo locale e senza dipendenze cloud.

Metodo 1: Flash firmware Tasmota o ESPHome (dispositivi WiFi ESP8266/ESP32)

Cos’è e quando usarlo

Il metodo più potente per dispositivi WiFi economici basati su chip ESP8266 o ESP32 (Sonoff, Tuya rebrand, prese smart no-name) è sostituire il firmware proprietario con uno open source come Tasmota o ESPHome.

​Vantaggi:

  • Controllo 100% locale (no cloud, niente ritardi)

  • Auto-discovery in Home Assistant

  • Aggiornamenti OTA (Over-The-Air)

  • Personalizzazione totale (GPIO, sensori custom, automazioni)

Requisiti:

  • Dispositivo con chip ESP8266 o ESP32 (verifica su database Tasmota/ESPHome)

  • USB-to-Serial adapter (CP2102, CH340G, ~5€)

  • Cavetti dupont per collegamento GPIO

  • PC con Windows/Mac/Linux

Passo 1: Verifica compatibilità hardware

Prima di smontare, controlla su:

Se trovi il tuo dispositivo, hai già la configurazione GPIO pronta!

Passo 2: Disassembla il dispositivo

Attenzione: Lavora sempre scollegato dalla rete 220V!

Per prese smart tipo Sonoff S31:

  1. Rimuovi viti esterne (spesso nascoste sotto etichette)

  2. Apri il case con spatola plastica

  3. Individua il chip ESP (di solito 8 pin visibili)

Passo 3: Collega GPIO per flash

Pin necessari (standard ESP8266):

  • VCC (3.3V)

  • GND

  • TX (trasmissione)

  • RX (ricezione)

  • GPIO0 (per boot mode)

Schema collegamento USB-to-Serial:

ESP8266      →    USB Serial Adapter
VCC (3.3V)   →    3.3V
GND          →    GND
TX           →    RX
RX           →    TX
GPIO0        →    GND (durante boot, poi scollega)

Importante: GPIO0 a GND solo durante l’accensione per entrare in “flash mode”, poi puoi scollegarlo.

Passo 4: Flash firmware con ESPHome (metodo consigliato 2026)

4.1 Installa ESPHome in Home Assistant:

  • Vai su Impostazioni > Componenti aggiuntivi

  • Cerca ESPHome e installa

4.2 Crea nuovo device:

# Esempio: presa smart Sonoff S31
esphome:
  name: presa-soggiorno
  platform: ESP8266
  board: esp01_1m

wifi:
  ssid: "TuoWiFi"
  password: "TuaPassword"

api:
  encryption:
    key: !secret api_key

ota:
  password: !secret ota_password

logger:

switch:
  - platform: gpio
    name: "Presa Soggiorno"
    pin: GPIO12
    id: relay

binary_sensor:
  - platform: gpio
    name: "Pulsante Presa"
    pin:
      number: GPIO0
      inverted: true

4.3 Compila firmware:

  • Clicca Install > Manual download

  • Scarica file .bin

4.4 Flash con ESPHome Flasher:

  • Scarica ESPHome Flasher (Windows/Mac/Linux)

  • Seleziona file .bin

  • Scegli porta COM/USB

  • Clicca Flash ESP

4.5 Riassembla e testa:

  • Scollega USB adapter

  • Richiudi dispositivo

  • Alimenta normalmente 220V

  • Home Assistant rileva automaticamente il nuovo device!

Alternativa: Tasmota (più universale, meno integrato)

Quando preferire Tasmota:

  • Hai già molti dispositivi Tasmota

  • Vuoi interfaccia web standalone (non dipendi da HA)

  • Serve compatibilità con più piattaforme (Domoticz, openHAB, ecc.)

Configurazione Tasmota per Home Assistant:

  1. Flash Tasmota tramite Tasmotizer o esptool

  2. Configura WiFi via web interface (http://192.168.4.1)

  3. Imposta MQTT in Tasmota:

    • Configuration > Configure MQTT

    • Host: IP di Home Assistant

    • Topic: presa_soggiorno

  4. In Home Assistant:

    • Installa integrazione Tasmota (firmware 9.2+)

    • Auto-discovery attivato via MQTT

Tasmota crea automaticamente entità switch/sensor in HA.

Metodo OTA senza cavi: Tuya-Convert (funziona solo su vecchi firmware)

Per dispositivi Tuya mai aggiornati (firmware pre-2020), esiste Tuya-Convert che flasha WiFi senza aprire il dispositivo:

  1. Configura Raspberry Pi con tuya-convert

  2. Dispositivo Tuya in pairing mode

  3. Script automatico flasha Tasmota/ESPHome via WiFi

Limitazione: Tuya ha chiuso la vulnerabilità, funziona solo su stock vecchi.

Metodo 2: Local Tuya (dispositivi Tuya senza flash)

Quando usare Local Tuya

Se hai dispositivi Tuya/Smart Life che:

  • Vuoi mantenere compatibili con app originale

  • Non vuoi flashare (garanzia, difficoltà hardware)

  • Supportano comunicazione locale WiFi (la maggior parte)

Local Tuya permette di controllare dispositivi Tuya localmente senza passare dal cloud (dopo setup iniziale).

Prerequisiti

  • HACS installato in Home Assistant

  • Dispositivi Tuya sulla stessa rete WiFi di HA

  • Account Tuya/Smart Life (per recuperare chiavi iniziali)

Passo 1: Ottieni Local Key e Device ID

Metodo A: Via Tuya IoT Platform (ufficiale, consigliato 2026)

  1. Vai su https://iot.tuya.com/

  2. Crea account sviluppatore (gratuito)

  3. Crea “Cloud Project” > seleziona datacenter (EU/US/CN)

  4. Collega account Smart Life/Tuya esistente

  5. Vai su Devices > vedrai tutti i tuoi dispositivi con:

    • Device ID

    • Local Key

    • IP address (se online)

Metodo B: Via debug Smart Life app (alternativo)

Usa app tipo Packet Capture su Android per intercettare comunicazioni e estrarre local key (più complesso).

Passo 2: Installa Local Tuya in Home Assistant

  1. Apri HACS > Integrazioni

  2. Cerca “Local Tuya”

  3. Installa

  4. Riavvia Home Assistant

Passo 3: Configura integrazione

  1. Impostazioni > Dispositivi e servizi > Aggiungi integrazione

  2. Cerca Local Tuya

  3. Scegli “Do not configure Cloud API Account” (già abbiamo local key)

  1. ​Clicca Submit

Passo 4: Aggiungi dispositivo manualmente

  1. Nell’integrazione Local Tuya, clicca “Add a new device”

  2. Inserisci:

    • Host: IP locale del dispositivo (es. 192.168.1.50)

    • Device ID: copiato da Tuya IoT Platform

    • Local Key: copiato da Tuya IoT Platform

    • Protocol version: 3.3 (la maggior parte dei device 2020+)

  3. Clicca Submit

Passo 5: Configura DPS (Data Points)

Local Tuya chiede di mappare i DPS (funzioni del dispositivo):

Esempio presa smart:

  • DPS 1 = Switch (on/off)

  • DPS 18 = Corrente (mA)

  • DPS 19 = Potenza (W)

  • DPS 20 = Tensione (V)

Puoi trovare i DPS corretti su:

  • Database community Local Tuya

  • Sperimentando manualmente (cambia valore e vedi cosa accade)

Configurazione tipo:

Entity: switch
DPS: 1

Risultato: Home Assistant crea entità switch.presa_tuya controllabile localmente!

Metodo 3: Bridge MQTT per dispositivi con protocolli custom

Cos’è MQTT e quando usarlo

MQTT (Message Queue Telemetry Transport) è un protocollo leggero publish/subscribe perfetto per IoT.

Usa MQTT bridge quando:

  • Dispositivo ha API/SDK non integrato in HA

  • Vuoi centralizzare comunicazione tra piattaforme diverse

  • Hai dispositivi DIY (Arduino, ESP senza Tasmota, sensori custom)

Setup MQTT Broker in Home Assistant

Passo 1: Installa Mosquitto add-on

  1. Impostazioni > Componenti aggiuntivi > Archivio add-on

  2. Cerca Mosquitto broker

  3. Installa e avvia

Passo 2: Configura integrazione MQTT

  1. Impostazioni > Dispositivi e servizi > MQTT

  2. Home Assistant rileva automaticamente Mosquitto locale

  3. Conferma configurazione

Esempio: Dispositivo custom via MQTT

Scenario: Hai un sensore temperatura fatto con Arduino che pubblica su MQTT.

Codice Arduino (pubblica temperatura):

#include <PubSubClient.h>

void loop() {
  float temp = readTemperature();
  char msg[10];
  dtostrf(temp, 4, 1, msg);
  client.publish("casa/soggiorno/temperatura", msg);
  delay(60000); // ogni minuto
}

Configurazione Home Assistant (configuration.yaml):

mqtt:
  sensor:
    - name: "Temperatura Soggiorno"
      state_topic: "casa/soggiorno/temperatura"
      unit_of_measurement: "°C"
      device_class: temperature

Risultato: Entità sensor.temperatura_soggiorno visibile in HA!

MQTT Discovery (auto-creazione entità)

Per dispositivi avanzati, usa MQTT Discovery che crea automaticamente entità:

Topic speciale:

homeassistant/sensor/soggiorno_temp/config

Payload JSON:

{
  "name": "Temperatura Soggiorno",
  "state_topic": "casa/soggiorno/temperatura",
  "unit_of_measurement": "°C",
  "device_class": "temperature",
  "unique_id": "temp_soggiorno_01"
}

Home Assistant rileva automaticamente e crea l’entità senza modificare configuration.yaml!

Metodo 4: REST API per dispositivi con interfaccia web

Quando usare REST sensor/switch

Molti dispositivi smart hanno API REST (HTTP GET/POST) anche se non ufficialmente integrate in HA.

Casi tipici:

  • NAS (Synology, QNAP)

  • Router/switch gestiti

  • Dispositivi custom con web server

  • Servizi web (meteo, energia, trasporti)

Esempio: Sensore REST da API pubblica

Scenario: Vuoi mostrare prezzo Bitcoin in HA.

Configurazione (configuration.yaml):

sensor:
  - platform: rest
    resource: https://api.coindesk.com/v1/bpi/currentprice/EUR.json
    name: "Prezzo Bitcoin"
    value_template: "{{ value_json.bpi.EUR.rate_float }}"
    unit_of_measurement: "€"
    scan_interval: 300  # Aggiorna ogni 5 minuti

Risultato: sensor.prezzo_bitcoin con valore aggiornato.

Esempio: Switch REST per dispositivo custom

Scenario: Hai un relay controllabile via HTTP (es. ESP8266 custom).

Configurazione:

switch:
  - platform: rest
    name: "Luce Garage Custom"
    resource: http://192.168.1.100/relay
    body_on: '{"state":"ON"}'
    body_off: '{"state":"OFF"}'
    is_on_template: "{{ value_json.state == 'ON' }}"
    headers:
      Content-Type: application/json

Funzionamento:

  • Accensione: POST a http://192.168.1.100/relay con body {"state":"ON"}

  • Spegnimento: POST con {"state":"OFF"}

  • Stato: GET ritorna JSON con campo state

REST con autenticazione

Per API protette:​

Funzionamento:

    Accensione: POST a http://192.168.1.100/relay con body {"state":"ON"}

    Spegnimento: POST con {"state":"OFF"}

    Stato: GET ritorna JSON con campo state

REST con autenticazione

Per API protette:
​

Metodo 5: Node-RED per logiche complesse e bridge custom

Cos’è Node-RED

Node-RED è una piattaforma visual programming perfetta per creare bridge custom tra dispositivi incompatibili e Home Assistant.

Quando usarlo:

  • Dispositivo ha protocollo troppo complesso per configurazione YAML

  • Serve pre-elaborazione dati (parsing, calcoli, conversioni)

  • Vuoi automazioni grafiche invece che YAML

Installazione Node-RED in Home Assistant

  1. Impostazioni > Componenti aggiuntivi > Archivio add-on

  2. Cerca Node-RED

  3. Installa (include già integrazione Home Assistant)

  4. Avvia e apri interfaccia web (porta 1880)

Esempio: Bridge HTTP → MQTT → Home Assistant

Scenario: Dispositivo invia dati solo via HTTP GET non standard.

Flow Node-RED:

  1. HTTP IN node (ascolto su /webhook/dispositivo)

  2. Function node (parsing e trasformazione):

    // Estrai temperatura da query params
var temp = msg.payload.t;
msg.payload = {
  temperatura: parseFloat(temp),
  timestamp: new Date()
};
return msg;

  3. MQTT OUT node (pubblica su casa/dispositivo/temp)

  4. Home Assistant legge via MQTT sensor (come Metodo 3)

Risultato: Dispositivo HTTP incompatibile → Node-RED → MQTT → Home Assistant ✅

Controllo dispositivi da Node-RED

Node “call service” permette di chiamare servizi HA:

  • Accendi luci

  • Invia notifiche

  • Cambia clima

  • Triggera automazioni

Vantaggio: Puoi creare logiche complesse con UI grafica invece che YAML!

Metodo 6: Template sensor/switch per aggregazioni custom

Quando usare template

Se hai dispositivi parzialmente integrati ma vuoi:

  • Aggregare più sensori (es. media temperatura casa)

  • Calcolare valori derivati (consumo orario da watt istantanei)

  • Creare switch virtuali che controllano gruppi

Template sensor è potentissimo e non richiede hardware/software extra!

Esempio: Temperatura media da 3 sensori

# configuration.yaml
template:
  - sensor:
      - name: "Temperatura Media Casa"
        unit_of_measurement: "°C"
        state: >
          {{
            (
              states('sensor.temp_soggiorno')|float +
              states('sensor.temp_camera')|float +
              states('sensor.temp_cucina')|float
            ) / 3 | round(1)
          }}

Esempio: Switch virtuale per gruppo luci

switch:
  - platform: template
    switches:
      tutte_luci_piano_terra:
        friendly_name: "Tutte Luci Piano Terra"
        value_template: "{{ is_state('light.soggiorno', 'on') or is_state('light.cucina', 'on') }}"
        turn_on:
          - service: light.turn_on
            target:
              entity_id:
                - light.soggiorno
                - light.cucina
                - light.ingresso
        turn_off:
          - service: light.turn_off
            target:
              entity_id:
                - light.soggiorno
                - light.cucina
                - light.ingresso

Risultato: Un solo switch controlla 3 luci insieme.

Quale metodo scegliere?

Checklist finale prima di integrare

Verifica se esiste integrazione ufficiale (https://www.home-assistant.io/integrations/) – magari è già supportato!

Controlla database community:

  • Tasmota templates

  • ESPHome devices

  • HACS custom integrations

Documenta configurazione originale prima di flashare (screenshot app, backup configurazioni)

Testa su un solo dispositivo prima di flashare 10 prese uguali

Fai backup Home Assistant prima di modifiche importanti a configuration.yaml

Home Assistant è incredibilmente flessibile: quasi ogni dispositivo smart può essere integrato con uno dei metodi sopra.

Per il 2026, l’approccio consigliato è:

  1. Prima opzione: Cerca integrazione ufficiale o HACS

  2. Dispositivi WiFi economici: Flash ESPHome (massimo controllo locale)

  3. Dispositivi Tuya da mantenere stock: Local Tuya

  4. Dispositivi con API: REST sensor/switch

  5. Casi complessi: Node-RED o MQTT bridge

Con questi strumenti, nessun dispositivo smart resta escluso dalla tua domotica Home Assistant!

Titoli Correlati