Scopi del progetto:
Concetti affrontati:
Componenti software utilizzate:
|
Materiali NECESSARI:
|
Progetto indicato per utenti con installazione: |
|
NOTE E DISCLAIMER
|
|
| Revisione progetto: 1.0 | |
Abstract
La domotica ci dota di sistemi estremamente moderni atti a perfezionale l’esperienza del vivere, quotidianamente, i nostri spazi domestici.
Chi già da tempo si è imbarcato in tale avventura saprà quanto, in senso pratico, tali sistemi siano davvero utili nel quotidiano: riscaldamenti che si auto-regolano in base alla nostra presenza, sistemi di allarme che si armano da soli in nostra assenza, luci che offrono la possibilità di configurare scenari legati all’orario e molto, molto, molto altro ancora.
Spesso capita che si abbia bisogno di un’informazione puntuale su determinati stati della propria domotica.
Ad esempio:
- Il riscaldamento è attivo?
- È notte. L’allarme è armato in modalità notturna ?
- La luce in garage è spenta?
- L’erogazione di acqua e gas è aperta?
- Il cancello è aperto?
e così via.
Questo genere di domande trova risposta, solitamente, presso il nostro/i strumento/i di gestione finale, i quali dispongono di tutti gli stati della domotica in tempo reale.
Le domande (esemplificative) di cui sopra condividono però una caratteristiche: prevedono tutte delle risposte binarie, ovvero “sì/no”, “vero/falso”. “1/0”. Qual è l’oggetto fisico che, per definizione, dispone di due soli stati? La lampadina, la quale prevede lo stato “acceso” e lo stato “spento”.
Questo progetto si propone di realizzare un prototipo e poi un sistema a incasso murale (che ovviamente si presta a innumerevoli modifiche e declinazioni diverse) il quale presenti una serie di “lampadine” (n realtà useremo dei piccoli LED colorati) le quali, una volta attestate sulla domotica, si accendano/spengano in modo sincrono agli stati di determinate entità presenti in domotica, permettendo agli utenti di dedurne lo stato con un solo colpo d’occhio, senza il bisogno di accedere alla propria dashboard di controllo.
Un po’ HAL9000, un po’ USS Enterprise.
Si parte
- Filosofia e scopi del progetto
- Lista materiali
- prototipo
- basetta per muro
- Realizzazione prototipo
- ESPHome
- Configurazione modulo
- Integrazione Home Assistant
- Realizzazione opera muraria
Filosofia e scopi del progetto
NodeMCU è una piccola board basata sul system-on-a-chip (SOC) ESP8266 o ESP32 perfetta per realizzare prototipi. Una sua grande caratteristica – oltre alla flessibilità e al basso costo – è quella di essere programmabile con diversi firmware: nel caso del presente progetto adotteremo ESPHome, firmware che lo abilita a una facile e rapida integrazione con le domotiche personali basate su HUB personali (Home Assistant, Homebridge, openHAB eccetera) tramite protocollo MQTT o API standard.
NodeMCU è fornito di una serie di contatti chiamati GPIO (General Purpose Input/Output, contatti input/output ad uso generico) sui quali è possibile attestare i più diversi componenti: piccoli motori elettrici, attuatori, sensori e… diodi LED.
Tali contatti GPIO presenti sui moduli NodeMCU hanno un corrispettivo logico presso la configurazione del firmware: ad ognuno è possibile attribuire una funzione specifica in base a tipo di componente ad esso collegato, per permettere poi ai comandi del firmware stesso di poterli controllare correttamente.
Quindi, ricapitolando:
- NodeMCU è un dispositivo Wi-FI a basso consumo e può essere programmato con firmware ESPHome;
- il firmware ESPHome ci permette di controllarne i GPIO;
- i suoi GPIO così controllati possono essere “mappati” e controllati come “interruttori virtuali” (una delle tante funzioni attribuibili dal firmware ESPHome ai vari GPIO) presso la nostra domotica.
Pertanto, se su quei GPIO attesteremo dei diodi LED e li configureremo adeguatamente potremo dunque controllarli come fossero “luci” da integrare e quindi gestire presso la nostra domotica.
Una volta ottenuto il risultato di riuscire a controllare i LED attraverso il nostro HUB personale, dovremo solo scrivere le automazioni necessarie a far sì che essi si accendano/spengano in base agli stati di altre entità domotiche già presenti nella configurazione in base alle nostre esigenze.
Lo scopo primario di questo progetto è quello di assemblare un prototipo composto da LED controllabili tramite NodeMCU+ESPHome – e quindi automaticamente dalla nostra domotica; secondariamente, assembleremo il prototipo su una basetta in legno tale da essere montata a muro e alimentata da un trasformatore 230v/12v.
Lista materiali
PROTOTIPO
Per quanto riguarda il prototipo, concepito per prendere dimestichezza con le funzionalità, è sufficiente un NodeMCU, un cavo Micro-USB per alimentarlo, una basetta Breadboard sul quale attestarlo, dei diodi LED, infine dei cavetti Dupont con cui collegarli.
Noi abbiamo usato:
- NodeMCU (ESP8266);
- cavo USB/Micro-USB (va bene anche un comune il cavo ricarica dei telefoni Android);
- basetta Breadbord e cavi Dupont;
- diodi LED multicolore.
Esistono anche degli economici kit completi contenenti basetta(e) Breadboard, cavi Dupont e diodi LED multicolore più tutta una serie di altri componenti utilizzabili per altri progetti.
BASETTA PER MURO
Se, dopo la prototipazione si decidesse di montare a muro il sistema visivo di notifiche realizzato, sarebbe necessario dotarsi di una base sulla quale montare i LED e dalla quale far partire il fascio di cavi destinati al NodeMCU, posizionato in una scatola murale (o altro tipo) assieme al trasformatore 230v/12v.
Noi abbiamo usato:
- una basetta di legno alta circa un centimetro (reperibile in qualunque negozio di bricolage – si consiglia un legno tenero);
- un trasformatore 230v-12v;
- interruttore monofase;
- pistola per colla a caldo;
- nastro telato;
- guaina termorestringente;
- scatola murale (da incasso o altro tipo – reperibile in qualunque negozio di bricolage).
La scelta della scatola murale è legata alla realtà in cui verrà calato il modulo. Dato che nella scatola confluiranno i cavi provenienti dalla basetta e dai relativi LED e ospiterà il trasformatore e il NodeMCU, dev’essere sufficientemente ampia; se sia da incasso o pensile, è una scelta di chi implementa il tutto.
Nel nostro caso, dato che il modulo è stato montato su un muro sottile che affaccia da un lato nell’ambiente vivibile e dall’altro in una cantina, si è scelto di far passare il fascio di cavi attraverso il muro e montare una scatola pensile dal lato cantina.
Realizzazione prototipo
Cominceremo dalla cosa più semplice, ovvero la connessione del/dei LED al NodeMCU.
Per chi fosse completamente a digiuno di elettronica, qui è disponibile un’interessante pagina dedicata all’anatomia di un diodo ad emittenza luminosa, o LED.
Alimentiamo ora il NodeMCU col cavo USB/Micro-USB e colleghiamo (utilizzando la basetta Breadboard e i cavi Dupont) un LED al GPIO15 “D8” (scelta arbitraria, non obbligata – si sarebbe potuto scegliere uno qualunque degli altri) – applicando una resistenza – come da schema:
| N.b. SI consiglia di applicare una resistenza da 470ohm per evitare di friggere i LED o, peggio ancora, la board. |
Non c’è molto altro da fare.
Ovviamente, qualora i LED siano più di uno (in questo progetto ne collocheremo otto) basterà collegarne gli anodi (polo +) ai vari GPIO liberi, e gli anodi (-) tutti quanti a “GND” (terra).
Bene, abbiamo capito come configurare fisicamente NodeMCU, ma ovviamente sotto il cofano manca ancora un firmware che sappia gestirlo in modo appropriato.
ESPHome
ESPHome è un firmware “modulare” che consente, appunto, di installare sui dispositivi target (in questo caso il nostro NomeMCU – o quel che sia) le componenti utili agli scopi prefissi “assemblate” in un unico compilato.
| N.b. Se non si conosce questo firmware è necessario dare una veloce lettura alla scheda ad esso dedicata; diversamente non si comprenderanno gli aspetti che verranno spiegati in seguito e, fatalmente, si fallirà. |
Nel caso di questo specifico progetto il componente ESPHome utile allo scopo è “Switch“, il quale consente di definire, lato Home Assistant, delle entità di tipo interruttore.
| N.b. Ovviamente, se si preferisce avere lato domotica delle entità di tipo luce e non di tipo interruttore generico, il componente da utilizzare è “Light“. |
La porzione aggiuntiva di configurazione YAML di ESPHome (la “ricetta” del nostro firmware) allo scopo del nostro progetto è la seguente:
switch:
- platform: gpio
pin: D0
name: "LED1"
icon: "mdi:led-on"
- platform: gpio
pin: D1
name: "LED2"
icon: "mdi:led-on"
- platform: gpio
pin: D2
name: "LED3"
icon: "mdi:led-on"
- platform: gpio
pin: D3
name: "LED4"
icon: "mdi:led-on"
- platform: gpio
pin: D4
name: "LED5"
icon: "mdi:led-on"
- platform: gpio
pin: D5
name: "LED6"
icon: "mdi:led-on"
- platform: gpio
pin: D6
name: "LED7"
icon: "mdi:led-on"
- platform: gpio
pin: D7
name: "LED8"
icon: "mdi:led-on"
La configurazione proposta andrà ovviamente sommata alla parte di default, quella nella quale vengono indicate le credenziali di accesso Wi-Fi e altro.
Una configurazione tipo, completa, potrebbe essere come la seguente:
esphome:
name: wallboard
platform: ESP8266
board: nodemcuv2
wifi:
ssid: "PROPRIA-Wi-Fi"
password: "PASSWORD-Wi-Fi"
# Enable fallback hotspot (captive portal) in case wifi connection fails
ap:
ssid: "Esp32Blt2Wifi Fallback Hotspot"
password: "PASSWORD_FALLBACK"
captive_portal:
# Enable logging
logger:
# Enable Home Assistant API
api:
encryption:
key: "metterequidentrounachiavepersonalequalunque"
ota:
password: "PASSWORD_UPDATE_OTA"
switch:
- platform: gpio
pin: D0
name: "LED1"
icon: "mdi:led-on"
- platform: gpio
pin: D1
name: "LED2"
icon: "mdi:led-on"
- platform: gpio
pin: D2
name: "LED3"
icon: "mdi:led-on"
- platform: gpio
pin: D3
name: "LED4"
icon: "mdi:led-on"
- platform: gpio
pin: D4
name: "LED5"
icon: "mdi:led-on"
- platform: gpio
pin: D5
name: "LED6"
icon: "mdi:led-on"
- platform: gpio
pin: D6
name: "LED7"
icon: "mdi:led-on"
- platform: gpio
pin: D7
name: "LED8"
icon: "mdi:led-on"
| N.b. A prescindere, su qualsiasi configurazione ESPHome consigliamo sempre di includere alcuni componenti secondo noi sempre utili, come quelli illustrati su questa scheda. |
Installazione
A questo punto si è pronti per la compilazione e la successiva installazione sul proprio attuatore.
Le tecniche per farlo sono le più disparate – tutto dipende ovviamente da dove si ha installato e in che modalità la suite ESPHome.
CON DISPOSITIVO DI FABBRICA
Se l’attuatore è originale, solitamente l’unica possibilità di installare il compilato ESPHome è utilizzando cavo USB/Micro-USB a collegare il computer che monta ESPHome e l’attuatore, avendo cura di disconnettere l’alimentazione esterna (alla quale provvede, durante la programmazione, l’interfaccia USB). Collegare i due tramite il cavo e poi impostare la modalità di flash premendo il bottone preposto presente sull’unità.
A questo punto eseguire la compilazione del firmware seguendo una delle guide dedicate al tema in base alla propria modalità d’uso di ESPHome e alla propria installazione.
CON DiSPOSITIVO GIÀ DOTATO DI ESPHOME
In caso l’attuatore sia già dotato di firmware ESPHome, la quale precedente compilazione prevedesse il codice:
ota:
password: "PASSWORD_UPDATE_OTA"
e avesse lo stesso “name“, allora non sarà necessario il cavo, ma basterà avviare la compilazione del firmware provvedendo all’accensione normale dell’attuatore il quale, entrando nella stessa rete LAN (tramite Wi-Fi) del computer sul quale viene eseguito ESPHome, verrà aggiornato.
Integrazione Home Assistant
A questo punto basterà riavviare l’attuatore e provvedere all’integrazione delle sue funzionalità di BRIDGE/Gateway sul proprio HUB personale. In caso di utilizzi Home Assistant, la guida è questa:
Questa integrazione genererà, come da premesse, un’entità di tipo “Switch” lato Home Assistant, le quali potranno direttamente essere utilizzate, manualmente o in modo automatico, per controllare l’accesione/spegnimento dei LED.
Automazione
A questo punto è necessario collegare il comportamento del LED (o dei LED) ai cambi di stato di altre entità. Questo, ovviamente, tramite automazione.
Ipotizziamo di voler “visualizzare” tramite l’accensione del LED1 lo stato di un’entità chiamata “switch.pompa” relativa alla gestione di una pompa idraulica e di LED2 quello di un’entità chiamata “switch.termoventilatore” per la gestione di un termoventilatore da bagno.
L’automazione, semplicissima, sarà la seguente:
automation:
- alias: "Notifiche LED"
trigger:
platform: state
entity_id: switch.pompa, switch.termoventilatore
condition:
condition: template
value_template: "{{ trigger.to_state.state != trigger.from_state.state }}"
action:
service: >
{% if trigger.to_state.state == 'on' %}
switch.turn_on
{% else %}
switch.turn_off
{% endif %}
data:
entity_id: >
{% if trigger.entity_id == 'switch.pompa' %}
switch.LED1
{% elif trigger.entity_id == 'switch.termoventilatore' %}
switch.LED2
{% endif %}
Il trigger è rappresentato dal cambio di stato di una qualsiasi delle due entità. La condition per l’esecuzione dell’action è che il cambio di stato sia diverso dal precedente (da ‘on’ a ‘off’ o viceversa). Infine, l’action definisce se applicare “.turn_on” o “.turn_off“, e a quale delle due entità sulla base di quale sia stata oggetto del trigger.
Realizzazione opera muraria
Vogliamo ora traslare il prototipo in una realtà muraria. Da scienziati pazzi della domotica diventiamo artigiani e muratori!
N.b. I passi che andiamo ora ad illustrare sono solo una delle tantissime possibilità e varianti applicabili al progetto. È tutta una questione di budget, fantasia, capacità manuali.
Ricordiamo che:
NOTE E DISCLAIMER
- qualsiasi eventuale modifica agli impianti domestici dev'essere progettata e realizzata SOLO da personale qualificato;
- qualsiasi modifica non prevista attuata in proprio è a propria responsabilità personale nonché a proprio rischio e pericolo (i contenuti della presenta pagina hanno infatti puro scopo didattico) e fa decadere garanzia, omologazioni e certificazioni di qualità; dei dispositivi interessati;
- tutte le tecniche descritte si intendono applicate a software e firmware aggiornati alle ultime versioni disponibili;
- questa pagina è materialmente scritta e manutenuta da più individui: non ci si aspetti né si pretenda un supporto personale. In presenza di difficoltà, chiedere supporto alla community sul nostro forum o sulla nostra chat.
Le unità da realizzare sono due:
- la tavoletta dotata di LED;
- la scatola di alimentazione e controllo.
Tavoletta
È il momento della tavoletta.
Predisporremo su di essa un determinato numero di fori in base ai LED che collocheremo (adeguati alla dimensione del LED stessi – noi abbiamo usato una punta da legno da 5), rifiniremo i contorni dei fori, stuccheremo in modo il più possibile uniforme, carteggeremo delicatamente e verniceremo (un paio di mani) dello stesso colore della parete sulla quale collocheremo l’unità.
Una volta ben asciugata la vernice, cominceremo a smontare il nostro prototipo rimontando all’interno dei fori i LED, fissandoli con una goccia di colla a caldo sul retro.
A questo punto si inizierà a cablare le connessioni dei contatti LED, avendo cura di tagliare i terminali troppo lunghi. Una volta verificata l’accensione, fissare progressivamente i vari cavi e connettori tramite colla a caldo. Al termine del cablaggio si dovranno avere tanti cavi connessi agli anodi (+) quanti sono i LED, e un unico cavo da collegare alla terra del NodeMCU (“GND”) connesso con tutti i catodi dei LED (-). Per quest’ultimo si consiglia utilizzare un cavo nero per maggior riconoscibilità.
Terminato tutto il cablaggio si provvederà a coprire l’intera superficie posteriore (dove si trovano i cavi connessi ai LED) tramite nastro telato.
Volendo, fissare infine i cavi in un unico fascio utilizzando la guaina termorestringente indicata nella lista materiali.
A questo punto provvedere alla produzione della nicchia nel muro nella quale murare la tavoletta. Il fascio di cavi, in base alla soluzione scelta, passerà in una traccia in direzione della scatola di alimentazione e controllo. Nel nostro caso, il fascio di cavi attraversa il muro e arriva alla scatola posta dall’altro lato.
Sarà cura di chi effettua il lavoro completarlo con una buona stuccatura, rifinitura, verniciatura, per far sì che la tavoletta visivamente sparisca completamente nel muro, lasciando solo le sue luci ad apparire come, dal nulla, nel proprio minimalismo funzionale.
Scatola di alimentazione e controllo
La scatola è un dispositivo semplice: contiene l’alimentatore (al quale portare i 230v di linea) un interruttore generale (che interrompe la fase in ingresso al trasformatore), il nostro NodeMCU e, ovviamente, i cavi in arrivo dalla tavoletta.
Lo schema elettrico (ricordiamo sempre di far realizzare tale schema a un professionista) è semplice: la fase entra ed esce dall’interruttore generale, va assieme al polo neutro all’ingresso di linea del trasformatore (“AC 230v”), mentre dall’uscita del trasformatore (“DC 12v”) i due poli (+ e -) andranno rispettivamente ai pin “VIN” e “GND” del NodeMCU. “VIN” è infatti l’entrata di alimentazione del NodeMCU che accetta tensioni variabili dai 3 ai 20 volt.
Terminato il cablaggio dell’alimentazione sarà il momento di ricollegare i pin dei vari LED ai vari GPIO, come da configurazione precedentemente definita.
Il lavoro sarà così stato terminato.
Una volta attivato l’interruttore, la tavoletta LED sarà operativa.
| Questa pagina è redatta, manutenuta e aggiornata dallo staff di inDomus, un gruppo di persone molto diverse tra loro che trovi, per domande e supporto, sul forum e sulla chat del sito. Se ti sei perso, a tua disposizione c'è la mappa. |