Utilizzo home assistant già da qualche anno. Mi avanzano per degli acquisti fatti qualche anno fa su aliexpress due cloni Arduino (UNO e Nano) ed un paio di shield economici ENC28J60. Direi il tutto per un valore di meno di 8€ (adesso costerebbero di più).
Abito in una strada molto trafficata è al momento ho quattro cani, che non sono molto bravi a restare nel giardino se trovano il cancello aperto. E’ quindi importante sapere se per qualche motivo uno dei cancelli oppure uno dei garage è rimasto aperto, prima di fare uscire i cani nella parte di giardino collegata alla strada.
Per il controllo degli ingressi e delle porte dell’abitazione, visto che sono tutti sensori all’asciutto e vicini alla scatolina del coordinatore ZigBee, ho utilizzato semplici sensori reed ZigBee comprati su AliExpress.
Ma per l’esterno sarebbe stato difficile fare arrivare con affidabilità il segnale ZigBee e proteggere gli stessi dalle intemperie, per cui ho optato per dei sensori reed cablati, normalmente aperti da collegare all’hardware di recupero che già avevo.
La domotica dal mio punto di vista
Circolano parecchie definizioni di domotica. Di fatto è un termine che è parecchio di moda e che quindi corre il rischio di essere abusato. Prima di passare alla parte più tecnica voglio quindi spendere qualche parola riguardo il mio punto di vista.
Il mio approccio è forse estremo. In fin dei conti mi aspetto solo che, la mia casa “intelligente”, prenda “autonomamente” decisioni, rispettando degli specifici algoritmi. Tutto questo, possibilmente, in modo affidabile.
Per fare questo sono necessarie almeno due cose: Le informazioni, e le applicazioni.
Le informazioni
Le informazioni possono essere raccolte in molti modi differenti. Da sensori (temperatura, apertura, presenza), dal tempo (meteorologico, dell’orologio), da comparazioni e operazioni.
Le applicazioni
Le applicazioni, le attuazioni, possono variare dall’attivare un interruttore, al informare gli utenti con un messaggio (audio o sul telefono), ad applicare ulteriori calcoli, comparazione o letture di sensori.
La sintesi
La sintesi di tutto questo è che la casa reagisca seguendo specifici algoritmi a quello che succede. Per esempio se il sole va sotto l’orizzonte la casa si prepara per la notte. Accende le luci del giardino. Cambia la tonalità delle luci. E viceversa quando qualcuno si sveglia (può saperlo da appositi sensori sui telefoni o sugli orologi indossati) accende la macchinetta del caffè, apre le persiane ecc ecc.
Il solo limite è la disponibilità di un sensore e la fantasia (e la precisione) nel comporre un codice che reagisca a quello che sta succedendo. Anche l’affidabilità di un sensore è decisamente importante.
La tecnologia deve essere al servizio della persona.
Hardware necessario
Per il mio piccolissimo progetto ho pensato di usare il seguente hardware:
- Un PC, un Rasperry, una macchina virtuale con installato e funzionante Home assistant;
- Un Arduino (Nano, Uno, un clone quello che volete);
- Un sistema per collegare Arduino alla rete (ho usato uno shield ENC28J60 è il più economico, ma vanno bene anche altri tipi di shield ethernet o WiFi. Ovviamente cambiando shield, il codice Arduino andrà modificato di conseguenza.);
- Un terminal block specifico per il vostro Arduino per evitare di avere i collegamenti con i cavetti DuPont ® e poter serrare con sicurezza i cavi del segnale.
Preparare home assistant
Do per scontato che ci sia già una installazione di home assistant funzionante e collegata alla rete. Ci serve un broker MQTT che è facilmente installabile utilizzando il componente aggiuntivo mosquitto broker. E’ abbastanza facile da fare, eventualmente seguendo la pagina di github del componente oppure la pagina dedicata a MQTT sul sito istituzionale di home assistant.
Possiamo intanto aggiungere anche i sensori che ci serviranno direttamente nel file di configurazione configuration.yaml di home assistant. Lo state_topic qui definito dovrà essere coincidente con quello definito nel codice di Arduino.
mqtt:
binary_sensor:
- name: "Cancellino"
state_topic: "nano-ha/cancellino"
device_class: opening
- name: "Cancello"
state_topic: "nano-ha/cancello"
device_class: opening
- name: "Garage 1"
state_topic: "nano-ha/garage1"
device_class: garage_door
- name: "Garage 2"
state_topic: "nano-ha/garage2"
device_class: garage_doorPreparare Arduino
Anche in questo caso do per scontato di avere un minimo di dimestichezza con Arduino. Il dispositivo scelto va collegato ad un PC via seriale e poi va caricato il codice (come quello riportato più avanti).
I collegamenti, abbastanza banali, sono riportati in questa immagine. Alla fine fa praticamente tutto lo shield. Da ogni sensore partono due fili. Uno di ognuno si collega insieme a GND l’altro terminale va uno per ogni canale (4, 5, 6, 7). I sensori non sono altro che interruttori, se l’accesso è chiuso l’interruttore è chiuso, e viceversa.
Questo è invece il codice per leggere e trasmettere via ethernet ogni 3 secondi lo stato dei sensori.
#include <EthernetENC.h> //queste sono le librerie necessarie per ENC28J60
#include "PubSubClient.h" // nel caso sono da cambiare a seconda dello shield
#define CLIENT_ID "nanoMQTT"
#define INTERVAL 3000 // 3 sec intervallo fra due pubblicazioni
bool statusCM=HIGH;//cancello lato monte
bool statusCMM=HIGH;//cancello lato mare
bool statusPG1=HIGH;//garage door 1
bool statusPG2=HIGH;//garage door 2
uint8_t mac[6] = {0x00,0x01,0x02,0x03,0x04,0x05};
EthernetClient ethClient;
PubSubClient mqttClient;
long previousMillis;
void setup() {
pinMode(4,INPUT_PULLUP); //resistenze interne di pullup
pinMode(5,INPUT_PULLUP);
pinMode(6,INPUT_PULLUP);
pinMode(7,INPUT_PULLUP);
// setup serial communication // queste sono parti che poi ho commentato per fare un po' di debug sulla porta seriale
//Serial.begin(9600);
// setup ethernet communication using DHCP
if(Ethernet.begin(mac) == 0) {
// Serial.println(F("Ethernet configuration using DHCP failed"));
for(;;);
}
// setup mqtt client
mqttClient.setClient(ethClient);
//mqttClient.setServer("test.mosquitto.org",1883);
mqttClient.setServer("192.168.1.xxx",1883); // questo è l'indirizzo del mio broker locale gli altri sono nel caso siano server mqtt esterni
//mqttClient.setServer("broker.hivemq.com",1883);
//Serial.println(F("MQTT client configured"));
previousMillis = millis();
}
void loop() { \\qui leggiamo lo stato digitale dei canali ad intervalli prestabiliti
statusCM=digitalRead(4);
statusCMM=digitalRead(5);
statusPG1=digitalRead(6);
statusPG2=digitalRead(7);
// check interval
if(millis() - previousMillis > INTERVAL) {
sendData();
previousMillis = millis();
}
mqttClient.loop();
}
void sendData() {
char msgBuffer[20];
// qui a seconda del fatto che il reed sia aperto o chiuso pubblica sul server mqtt il valore ON oppure OFF
if(mqttClient.connect(CLIENT_ID,"username","password")) {
mqttClient.publish("nano-ha/cancellino", (statusCM == HIGH) ? "OFF" : "ON");
mqttClient.publish("nano-ha/cancello",(statusCMM == HIGH) ? "OFF" : "ON");
mqttClient.publish("nano-ha/garage1",(statusPG1 == HIGH) ? "OFF" : "ON");
mqttClient.publish("nano-ha/garage2", (statusPG2 == HIGH) ? "OFF" : "ON");
}
}Automazioni
Finita la parte hardware e software dei sensori, mi sono potuto cominciare a sbizzarrire con le automazioni.
Come prima cosa ho messo dei trigger, cioè dei sistemi per disattivare o attivare le automazioni stesse, in particolare escludendo la “sicurezza cani” oppure escludendo le attivazioni relative al cancello pedonale che in alcuni casi posso lasciare aperto (mettendo in questo caso in sicurezza i cani all’interno dell’abitazione.
Su home assistant diventano dei sensori boleani. Che si creano comodamente come commutatori dalla vista Impostazioni => Dispositivi ecc => Aiutanti.
Di seguito mostro una automazione per essere avvisati che uno dei cancelli è rimasto aperto mentre si apriva la porta di ingresso dell’abitazione. Ed una seconda che avvisa se uno dei cancelli rimane aperto per più di cinque minuti.
In particolare "notify.mobile_app_moto_g4" è un vecchio telefono che ho attaccato a delle ancor più vecchie casse per pc con le quali condivide l’alimentatore che funziona come se fosse un Google Home. L’unica spina delle casse alimenta tutto, e, volendo, è possibile interagire come fosse proprio un Google Home.
Le automazioni poi le ho complicate ulteriormente inviandole anche via testo a tutti i telefoni che condividono l’app companion.
E ovviamente non sono ferme, ogni volta che viene la fantasia di inserire qualcos’altro si può aggiungere senza problemi.
alias: sicurezza cani 3
description: ""
trigger:
- platform: state
entity_id:
- binary_sensor.cancellino
- binary_sensor.cancello
- binary_sensor.ingresso_iaszone
to: "on"
condition:
- condition: and
conditions:
- condition: state
entity_id: input_boolean.sicurezza_cani
state: "on"
- condition: or
conditions:
- condition: and
conditions:
- condition: state
entity_id: binary_sensor.cancellino
state: "on"
- condition: state
entity_id: input_boolean.escludi_cancellino
state: "off"
- condition: state
entity_id: binary_sensor.cancello
state: "on"
- condition: state
entity_id: binary_sensor.ingresso_iaszone
state: "on"
action:
- service: notify.mobile_app_moto_g4
data:
message: TTS
data:
tts_text: Attenzione ingresso e cancelli sono aperti insieme
mode: single
alias: Sicurezza cani 2
description: ""
trigger:
- platform: state
entity_id:
- binary_sensor.cancellino
- binary_sensor.cancello
to: "on"
for:
hours: 0
minutes: 5
seconds: 0
condition:
- condition: state
entity_id: input_boolean.sicurezza_cani
state: "on"
action:
- service: notify.telefoni
data:
title: "!!!Attenzione!!!"
message: Un cancello è aperto da più di 5 minuti
- service: notify.mobile_app_moto_g4
data:
message: TTS
data:
tts_text: Attenzione! Un cancello è aperto da più di 5 minuti
mode: singleConclusioni
Non ho riportato tutte le automazioni e tutti i passaggi con precisione, nel caso sia di interesse per qualcuno potrò aggiungere direttamente in questo articolo altre specifiche o foto. Alcune cose sono dipendenti dall’hardware utilizzato e quindi vanno adattate alle esigenze.
Arduino è stata una mia vecchia passione, e vedo che, anche allo stato attuale delle cose, di fatto è possibile utilizzare quella magica schedina anche in progetti più propriamente “domotici”. Per esempio la mia centralina di controllo solare è proprio una schedina Arduino UNO (pagata 25€ contro gli almeno 300€ della centralina consigliata dall’idraulico) e fa il suo dovere da quasi 10 anni. Magari se trovo uno shield ethernet a buon prezzo scrivo un altro articolo in proposito.
