Realizzare un sistema di notifiche visive LED (con NodeMCU, Tasmota e MQTT)

Scopi del progetto: Assemblare un dispositivo da applicare a muro (o altre modalità) atto a segnalare stati della propria domotica tramite diodi LED colorati Livello di difficoltà: medio Costo: intorno ai 60 euro (in base ai materiali scelti) Concetti affrontati: Costruzione prototipo Configurazione software Componenti software utilizzate: Varie, in relazione all’HUB personale in uso	Materiali NECESSARI: Un modulo NodeMCU Diodi LED multicolore Una basetta Breadboard Cavo USB / Micro-USB Cavetti Dupont Resistenze da 470ohm Una basetta  di legno Un trasformatore 230v-12v Interruttore monofase Pistola per colla a caldo Nastro telato Guaina termorestringente scatola murale (da incasso o altro tipo)
GUIDA maggiormente indicatA per:
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 caso di difficoltà, chiedere supporto alla community sul nostro forum o sulla nostra chat; se hai bisogno di orientarti, c'è la mappa.
Revisione progetto: 2.4

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
• Assunzioni
• Realizzazione prototipo
• Configurazione modulo
  • comandare tramite MQTT
• Integrare in domotica
  • Home Assistant (configurazione e automazione)
  • Homebridge (configurazione e automazione)
• Realizzazione opera muraria

Filosofia e scopi del progetto

NodeMCU è una piccola board basata sul system-on-a-chip (SOC) ESP8266 perfetta per realizzare prototipi. Una sua grande caratteristica – oltre alla flessibilità e al basso costo – è quella di essere programmabile con firmware Tasmota, il che la abilita a una facile e rapida integrazione con le domotiche personali basate su HUB personali (Home Assistant, Homebridge, openHAB eccetera) tramite protocollo MQTT.

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 Tasmota: 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 Tasmota;
• il firmware Tasmota di permette di controllare i suoi GPIO;
• i suoi GPIO così controllati possono essere “mappati” e controllati come “interruttori virtuali” (una delle tante funzioni attribuibili dal firmware Tasmota ai vari GPIO) presso la nostra domotica, tramite MQTT.

Pertanto, se su quei GPIO attesteremo dei diodi LED e li configureremo come “switch” potremo dunque controllarli come fossero “lampadine” presso la nostra domotica sfruttando il protocollo MQTT.

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+Tasmota – 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 v3
• 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.

Assunzioni

Il presente progetto dà per scontato che:

• si disponga di un HUB personale;
• si disponga di un broker MQTT;
• il modulo NodeMCU sia già programmato con firmware Tasmota e sia quindi già in grado di accedere alla Wi-Fi sulla quale opera l’UB personale di cui sopra.

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.

FINE!
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).

Configurazione modulo

A questo punto è necessario “istruire” NodeMCU rispetto al fatto che sul GPIO “D8” sia ora attestato un LED.
Da interfaccia web del NodeMCU (disponibile grazie al firmware Tasmota) entrare nella configurazione MQTT (“Configuration” > “Configure Module”) e impostare, per ognuno dei GPIO sul quale si sia attestato l’anodo di LED impostare la modalità “Relay”, utilizzandone la numerazione crescente.

Nell’esempio che segue ipotizziamo la presenza di due LED, uno su GPIO15 (D8) e uno su GPIO5 (D1)

Cliccato su “Save”, anche questa configurazione sarà completata!
A questo punto sulla Home Page dell’interfaccia web appariranno due interruttori virtuali: se azionati, i LED si accenderanno/spegneranno.

COMANDARE I LED TRAMITE MQTT

Ora è necessario capire la “logica” di comando MQTT per i vari LED configurati; prima, però, accertarsi che il protocollo MQTT sia correttamente configurato lato broker, lato Home Assistant e Sonoff. A tal proposito si consiglia la lettura attenta della guida dedicata alla configurazione dei componenti MQTT nella propria domotica.

Recarsi dunque presso la “Console” disponibile presso l’interfaccia web del NodeMCU. Il comando per accendere un LED è il seguente (si assume che in configurazione MQTT il modulo si chiami “NodeMCU”):

cmnd/NodeMCU/POWERX ON

mentre quello per spegnerlo

cmnd/NodeMCU/POWERX OFF

dove X sarà il numero di “Relay” configurato precedentemente.

Va da sé che, sulla base della configurazione d’esempio di cui sopra, il comando di accensione (per esempio) del LED numero 2 (ovvero quello attestato sul GPIO5), sarà:

cmnd/NodeMCU/POWER2 ON

e così via.
Capire bene questo passaggio è estremamente importante per riuscire poi a configurare gli elementi presso la nostra domotica personale.

N.b. Nessuno vieta l’uso di modalità diverse dalla modalità tradizionale di accensione/spegnimento: dato l’uso del firmware Tasmota, è possibile pensare all’implementazione di lampeggii e flash tramite l’uso dei comandi “BLINK” e “PULSETIME“.

Configurazione in domotica

Ultimo step relativo al prototipo è quello di configurare tanti “switch” (“interruttori”) quanti sono i nostri LED presso la nostra domotica. Di seguito riporteremo le strategie di configurazione relative a due HUB personali tra i più noti: Home Assistant e Homebridge.

Home Assistant

Per quanto riguarda Home Assistant è necessario configurare tanti interruttori quanti sono i LED configurati su NodeMCU. Per fare questo si faccia riferimento alla guida inDomus “Aggiungere un interruttore MQTT alla configurazione Home Assistant“.

Un rapido esempio di configurazione (legato alla configurazione d’esempio di cui sopra) tramite è il seguente:

mqtt:
  switch:
  - name: "LED1"
    state_topic: "stat/NodeMCU/POWER1"
    command_topic: "cmnd/NodeMCU/POWER1"
    availability_topic: "tele/NodeMCU/LWT"
    qos: 1
    payload_on: "ON"
    payload_off: "OFF"
    payload_available: "Online"
    payload_not_available: "Offline"
    retain: false

AUTOMAZIONE

A questo punto è necessario collegare il comportamento del LED (o dei LED) ai cambi di stato di altre entità.
Ipotizziamo di voler “visualizzare” tramite l’accensione del LED1 lo stato di un’entità chiamata “switch.pompa” e di LED2 quello di un’entità chiamata “switch.termoventilatore“.

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 è il 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.

Homebridge

Analogamente a Home Assistant, anche per Homebridge è necessario configurare tanti interruttori quanti sono i LED configurati su NodeMCU. Per fare questo si faccia riferimento alla guida inDomus “Aggiungere un interruttore Sonoff a Homebridge usando Tasmota e MQTT“.

Un rapido esempio di configurazione (legato alla configurazione d’esempio di cui sopra) tramite l’uso del plugin “homebridge-mqtt-switch-tasmota” è il seguente:

{
  "accessory": "mqtt-switch-tasmota",
  "switchType": "light",
  "name": "LED1",

  "url": "mqtt://MQTT–BROKER-ADDRESS",
  "username": "MQTT USER NAME",
  "password": "MQTT PASSWORD",

 "topics": {
    "statusGet": "stat/NodeMCU/RESULT",
    "statusSet": "cmnd/NodeMCU/POWER1",
    "stateGet": "tele/NodeMCU/STATE"
  },
  "onValue": "ON",
  "offValue": "OFF",
    
  "activityTopic": "tele/NodeMCU/LWT",
  "activityParameter": "Online",
    
  "startCmd": "cmnd/NodeMCU/TelePeriod",
  "startParameter": "60"
}

AUTOMAZIONE

L’automazione in ambito HomeKit, come sempre, è (purtroppo) legata ai limiti dell’app Apple “Casa”. Sarà comunque sufficiente seguire la guida “Gestire e automatizzare un interruttore su Apple HomeKit” e impostare, come trigger, “Un accessorio viene controllato” mentre, come azione finale, l’accensione/spegnimento dell’interruttore LEDx precedentemente configurato.

---

Una volta completate le configurazioni relative all’automazione – indipendentemente dal tipo di domotica personale che si utilizza – avremo dei LED che, autonomamente, si accenderanno/spegeranno in base agli stati delle entità indicate in configurazione.

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 caso di difficoltà, chiedere supporto alla community sul nostro forum o sulla nostra chat;
• se hai bisogno di orientarti, c'è la mappa.

---

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à.

Questo slideshow richiede JavaScript.

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.

Questo slideshow richiede JavaScript.

Fissare infine i cavi in un unico fascio utilizzando la guaina termorestringente.

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.

Esempio di funzionamento

Ecco un nostro video che dimostra il funzionamento a lavoro completato:

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.