Domotica con Raspberry. Home Assistant + MQTT e Arduino

Nell’ultimo articolo che ho scritto, ho parlato di come configurare Home Assistant e Wake On Lan.

Visto che ormai iniziamo a spingerci oltre il semplice concetto di domotica, oggi andremo a vedere come utilizzare il protocollo MQTT, per poter leggere dati in Wi-Fi da un nostro sensore in qualsiasi punto della casa.

La cosa interessante è che questo progetto ha un budget inferiore ai 20€.

Hai già dato un occhio all’indice di articoli inerenti la Domotica presenti nel mio sito? Facci un salto: Indice articoli di Domotica

Il cuore di tutti i nostri progetti futuri in ambito MQTT e “Domotica con Raspberry“, sarà questo simpatico ma potentissimo giocattolino: ESP8266 Node MCU con modulo Wi-Fi integrato.

Ora che ci siamo dotati di Raspberry, Modulo Wifi per l’utilizzo del protocollo MQTT ed il sensore (in questo caso il DS18B20), possiamo iniziare il nostro progetto.

1) Pre-configurazione MQTT su Home Assistant

Un piccolo Focus sul protocollo MQTT. Questo protocollo in sostanza viene sfruttato con l’utilizzo di un “Topic” (una stringa) al quale il Broker (In questo caso Home Assistant) e il nostro client (ESP8266), si inscrivono. Immaginate di essere dentro uno specifico topic come nei forum online.

All’interno di questo Topic, i clients inscritti possono pubblicare messaggi. Nel nostro caso, il client sarà L’ESP8266 il quale pubblicherà nel topic condiviso con Home Assistant i dati relativi alla temperatura del sensore. Home Assistant si occuperà di aggiornare l’interfaccia grafica.

Lato Raspberry e Home Assistant dobbiamo fare veramente poco. Se avete installato Home Assistant come ho indicato nella guida su come Installare Home Assistant, troverete già installato il broker MQTT Mosquitto. Il file di configurazione di Mosquitto è già buono in termini di sicurezza e configurazioni.

L’unica cosa da fare è creare uno username e una password da utilizzare per lo scambio di informazioni tra Client/Broker. Connettetevi in SSH alla Raspberry e lanciate questo comando:

sudo mosquitto_passwd -c /etc/mosquitto/pwfile username

Durante la stesura di questo post, il servizio Mosquitto MQTT era configurato per avviarsi automaticamente, fate un controllo per verificare che sia correttamente avviato.

In caso negativo, impostatelo in autostart così ad ogni riavvio del Raspberry il servizio torna su in automatico.

Potete verificare se il servizio è correttamente configurato tramite questi 2 comandi:

mosquitto_sub -d -u username -P password -t “dev/test”

mosquitto_pub -d -u username -P password -t “dev/test” -m “Hello world”

Aprite 2 console SSH dalla vostra Raspberry. Il primo comando fa “inscrivere” la Raspberry al topic “dev/test“, il secondo comando pubblicherà il messaggio “Hello word” all’interno del topic.

Occhio che il topic “dev/test” è diverso da “dev/test/”. Tenetelo a mente se in futuro volete ideare progetti simili.

Se nella seconda console SSH vi compare la scritta “Hello word”, con la parte di MQTT su Raspberry abbiamo terminato. Bravo.

2) Configurazione Home Assistant. Broker + Sensore.

Aggiungiamo nel file “configuration.yaml” questi 2 blocchi di configurazione:

mqtt:
  broker: !secret broker_ip
  port: !secret broker_port
  client_id: !secret broker_client_id
  username: !secret broker_username
  password: !secret broker_password

Come indicato nella guida su Home Assistant + HTTPS, io utilizzo il file secrets.yaml dove salvare tutte le mie credenziali. Vi consiglio di fare lo stesso.

Se non avete modificato nulla su Home Assistant, il broker sarà 127.0.0.1, la porta 1883, e il client_id: home-assistant-1.

sensor:
  - platform: mqtt
    state_topic: 'sensor/temperature'
    name: 'Ground Temperature'
    unit_of_measurement: "C"

In questo caso, il Topic che andremo ad utilizzare sarà “sensor/temperature“. Banalmente questo estratto di codice dice solo: prepara un sensore di temperatura in scala Celsius che utilizza il topic indicato.

Per quanto concerne Home Assistant, abbiamo terminato. Riavviamo i servizi e passiamo ad Arduino.

3) Configurazione Fisica Arduino

Io chiamo la scheda ESP8266 Arduino per facilitare le cose. Iniziamo subito con un’informazione vitale. La piedinatura di questa scheda!

L’ESP8266 si alimenta a 5V. Vi consiglio di utilizzare una BreadBoard per iniziare.

Il collegamento è molto elementare. Una volta alimentato l’Arduino ed il sensore, connettete il cavo Giallo (dati) al piedino D4 dell’arduino.

4) Configurazione Software Arduino

Ora che abbiamo preparato tutto per quello che concerne la parte pratica, passiamo alla parte software. Scaricate il programma per Arduino a questo link.

Quello che interessa a noi è Arduino IDE.

Una volta installato il programma dobbiamo scaricare alcune librerie. Andiamo quindi su Sketch -> Include Libraries -> Manage Libraries. Le librerie ci serviranno per interfacciare tutti i componenti che andremo ad utilizzare.

Cerchiamo ed installiamo queste Librerie qui:

• ESP8266WiFi
• OneWire
• PubSubClient
• DallasTemperature

Configuriamo il software in modo che possa caricare il programma che andremo a scrivere nella nostra scheda.

Sotto Tools, configurate come da foto:

L’unica cosa a cui dovrete fare attenzione è la “Port“. Quella varia in base a che USB utilizzate.

Connettete l’arduino al PC con un cavo USB e procediamo con la parte di codice.

5) Arduino, il programma

Dovete compilare i campi vuoti all’interno degli “”

#include <ESP8266WiFi.h>
#include <OneWire.h>
#include <PubSubClient.h>
#include <DallasTemperature.h>

//AP definitions
#define wifi_ssid “” //Nome della vostra rete wifi
#define wifi_password “” //Password della vostra rete wifi

//MQTT Settings for Home Assistant
#define mqtt_server “” //Ip Home assistant
#define mqtt_user “” // Username di Home Assistant
#define mqtt_password “” //Password dello username creato prima.
#define temperature_topic “sensor/temperature” //Topic utilizzato.

#define ONE_WIRE_BUS 4 // ESP8266 Pin Number. GPIO2. Variate il numero se dovete cambiare PIN
#define REPORT_INTERVAL 15 // in sec

WiFiClient espClient;
PubSubClient client(espClient);
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

boolean configMode = false;

//Begin Program
void setup() {
Serial.begin(115200);
setup_wifi();
client.setServer(mqtt_server, 1883); //Cambiate la porta se l’avete cambiata anche su Home Assistant
sensors.begin();
}

void setup_wifi() {
delay(10);
Serial.println();
Serial.print(“Connecting to “);
Serial.println(wifi_ssid);

WiFi.begin(wifi_ssid, wifi_password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(“.”);
}

Serial.println(“”);
Serial.println(“WiFi connected”);
Serial.println(“IP address: “);
Serial.println(WiFi.localIP());
}

void reconnect() {
// Loop until we’re reconnected
while (!client.connected()) {
Serial.print(“Attempting MQTT connection…”);
// Attempt to connect
if (client.connect(“ESP8266Client”, mqtt_user, mqtt_password)) {
Serial.println(“connected”);
} else {
Serial.print(“failed, rc=”);
Serial.print(client.state());
Serial.println(” try again in 5 seconds”);
// Wait 5 seconds before retrying
delay(5000);
}
}
}

void loop() {
if (!client.connected()) {
reconnect();
}
client.loop();

float temp;
sensors.requestTemperatures();
temp = sensors.getTempCByIndex(0);
Serial.print(“Temperature: “);
Serial.println(temp);
Serial.println(String(temp).c_str());

//Condivide i dati con Home Assistant
client.publish(temperature_topic, String(temp).c_str(), true);
int cnt = REPORT_INTERVAL;

while(cnt–)
delay(1000);
}

Ecco cosa fa il programma in sintesi:

• La funzione reconnect, in base ai dati che avete fornito prima, tenta di connettersi al server MQTT (Home assistant), in caso non riesca riprova dopo 5 secondi.
• La funzione loop, finchè non viene effettuata la connessione con il server MQTT, riprova.
• Il corpo del programma sta in quello che succede dopo la riga “client.loop();” Qui viene letta la temperatura del sensore, stampata nella console seriale (per questioni di DEBUG) e pubblicata nel topic che abbiamo indicato prima.

Per verificare che tutto sia stato scritto correttamente, andiamo su Sketch e clicchiamo “Verify“. Se non sono presenti errori, clicchiamo su “Uplioad“.

Se la porta COM è corretta e il programma è scritto correttamente, il processo di Upload avrà inizio. Il processo di caricamento è riconoscibile in quanto il led blu della scheda inizierà a flashare.

6) Verificare il funzionamento

Prima di tutto verifichiamo che il nostro Arduino faccia il suo lavoro.

Clicchiamo su “Tools” e poi su “Serial Monitor“. Controllate che nella console il numero in basso a destra sia impostato su 115200. Se nella console compare “Connessione in corso…” e “Connesso al MQTT” vuol dire che siamo online.

Successivamente ogni 15 secondi vi dovrebbe comparire la temperatura rilevata dal sensore di temperatura.

Accediamo alla console di Home Assistant. Se tutto è corretto, dovremmo già iniziare a vedere i primi dati che il sensore sta collezionando.

7) Considerazioni finali

Questo è solo un assaggio di cosa è possibile fare con una manciata di euro e 2 schede. Il passo successivo potrebbe essere quello di dire a Home Assitant che superata una determinata temperatura accenda il climatizzatore. Un altro progetto che possiamo ideare è applicando lo stesso principio ma per l’umidità.

Il tema “Domotica con Raspberry” ha ancora molti aspetti interessanti da scoprire!