Controllo degli interruttori di casa con Raspberry PI

Benvenuti nella rubrica "l'angolo dei lettori". Questo spazio è una sezione del blog che permette a chiunque di scrivere un articolo o realizzare un video, effettuare prove e test che riguardano il mondo della tecnologia e proporne la pubblicazione su queste pagine.

Oggi Nicola Bertelli, che ringraziamo per questa splendida guida, ci spiegherà come come controllare le luci di casa utilizzando gli interruttori già presenti nel nostro impianto:

Prima di tutto vi devo spiegare brevemente la differenza tra pulsante, interruttore, deviatore e invertitore.

Il pulsante, detto in modo molto grossolano, si differenzia dagli altri 3 in quanto è l’unico che ha una molla la quale provvede a riportarlo alla posizione di partenza dopo essere stato azionato.

L’interruttore ha due posizioni fisse: con una interrompe un circuito di corrente (aperto) e con l’altra unisce i due contatti (chiuso).

Il deviatore invece non fa una vera e propria apertura/chiusura del circuito in quanto “devia” il flusso di corrente su un’altro contatto del deviatore stesso.

L’invertitore fa un movimento simile al deviatore e si inserisci quando le zone del quale si vuole controllare il punto luce sono più di due.

In parole povere, il circuito di controllo di una lampada gestita da due o più punti di comando (n), dovrà essere composta da 2 deviatori e da n-2 invertitori.

L’obiettivo di questa guida sarà di domotizzare il nostro impianto senza per questo stravolgerlo, mantenendo i punti di controllo così come sono, ma dividendo, come poi vedremo, la parte di alimentazione del nostro punto luce dalla parte di comando.

E qui entra in gioco il nostro Raspberry (modello zero W per l’occasione) che avrà il compito di elaborare il segnale proveniente dal circuito dei deviatori/invertitori ed il comando proveniente da Home Assistant (tramite MQTT) per poi alimentare o meno i nostri relè, ciò corrisponderà all’accensione o spegnimento del nostro lampadario. Il linguaggio che userò è Python, nella versione 2.7, molti che hanno smanettato come me con Home Assistant ne avranno già sentito parlare, anche se lì viene usata un’altra versione più recente.

Come avrete ben capito le operazioni da fare sono in linea di massima 3:

1. installazione di Rasbian, programmazione del nostro Raspberry e test al banco con dei semplici interruttori

2. modifica dell’impianto di casa per “accogliere” il nostro controllore

3. cablaggio e test finale all’opera

Fase 1

Per iniziare vi inviterei a seguire la guida di Vincenzo in merito all’installazione di Home Assistant, fino al punto in cui suggerisce di abilitare l’interfaccia SSH e VNC.

ATTENZIONE, per il nostro scopo sconsiglio di abilitare VNC ma solo SSH per poter gestire la nostra scheda da remoto.

LINK articolo di Vincenzo: http://www.vincenzocaputo.com/picoblog/view/41/home_assistant_guida_allinstallazione_su_raspberry

NB: Se lavorerete sulla stessa rete del Raspberry non è necessario aprire nessuna porta del router per poter operare su di esso.

Per conoscere l’indirizzo IP della scheda, prima di poter staccare definitivamente il cavo HDMI, aprite il terminale del Raspberry

digitate ip address e date invio

La risposta dovrebbe essere simile a questa, nella sezione 2: wlan0:, accanto a inet, potete visualizzare l’indirizzo ip, annotatelo, vi servirà spesso.

Ora non ci resta che spegnere il Raspberry, staccare il cavo HDMI, e riavviarlo.

Dopo pochi istanti saremo pronti per connetterci con il protocollo SSH. Da notare che di default SSH occupa la porta 22, ma se volete potete cambiarla:

da terminale date    sudo nano /etc/ssh/sshd_config   , togliere il commento da Port e mettere il numero che preferite, in questo caso 2107, poi diamo control + x, rispondiamo s e invio, a questo punto riavviamo (sudo reboot).

Un’altro passaggio che consiglio di fare prima di metterci all’opera sul serio, è installare Samba, ciò  permette, da qualsiasi sistema operativo, di accedere ai file che dovremo gestire come se fossero sul nostro PC.

Quindi sempre da terminale diamo  sudo apt-get install samba samba-common-bin, al termine dell’installazione (breve) digitare  sudo nano /etc/samba/smb.conf, ed alla fine del lungo file inserire le seguenti righe:

[luci-salotto]Comment = Pi luci salottoPath = /home/piBrowseable = yesWriteable = Yesonly guest = nocreate mask = 0777directory mask = 0777Public = noGuest ok = no

diamo control + x, rispondiamo s e invio,  infine  sudo smbpasswd -a pi, inserire e reinserire la password che useremo per accedere ai file  (utente pi ,password passwod inserita). Terminiamo lanciando il comando sudo /etc/init.d/samba restart.Ora siamo pronti per collegarci via Samba ai nostri files.

Da Mac

gestione dei file:

Aprire finder e premere  command + k  , inserire smb:// seguito dall’indirizzo ip individuato precedentemente e dare connetti.

A quel punto selezionare il nome inserito nelle impostazioni di Samba (basculante nel mio esempio)

ed inserire id e password, ci troveremo nella nostra cartella /home/pi del Raspberry.

Per controllare il Raspberry aprite Terminale dal Launchpad e dare il comando ssh -l pi indirizzo_ip_raspberry -p porta_ssh

a quel punto inserire la password ssh e saremo direttamente nel terminale della nostra schedina

Da Windows:

aprire esplora file, selezionare Questo PC e poi alto Aggiungi percorso di rete,

poi avanti dunque Scegliere un percorso di rete personalizzato

inserire indirizzo_ip_raspberry e cliccare sfoglia , selezionare il server nella lista che ci viene mostrata, quindi immettere le credenziali di Samba, scegliere la cartella che ci interessa ed indicare il nome che vogliamo dare alla nostra risorsa

quindi avanti  e poi fine

Per visualizzare il terminale scaricare Putty a questo indirizzo: https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html, apritelo inserite ip del Raspberry e porta SSH, immettere un nome a piacere in Saved session, premere Save e poi premere open, confermare l’alert e loggarsi con pi e la password SSH

Eccoci nel terminale del Raspberry

Da Linux:

volendo non è necessario utilizzare Samba in quanto linux è pienamente compatibile con SSH: apriamo quindi il file manager e digitiamo nella barra degli indirizzi  sftp://indirizzo_ip:porta_ssh/home/pi/, logghiamoci e ci troveremo direttamente nella cartella /home/pi del Raspberry

per quanto riguarda il terminale il procedimento è simile al Mac:

Eccoci ora alla lista della spesa per eseguire i collegamenti:

cavetti flessibili (Jumper) e una Breadboard, scegliete voi quella che preferite:

https://amzn.to/2Pv09x5

Alimentatore 5v , per esempio questo:

https://amzn.to/2PtLJgR

interruttori, intendo normali interruttori né deviatori né invertitori, ne avremo bisogno solo per un test al banco, quindi meno costano meglio è, per ora ne useremo 4:

Relè, dipende dal numero di luci che volete controllare, su Amazon se ne trovano di tutti i tipi:

https://amzn.to/2P47mFi

ATTENZIONE: la maggior parte di questi relè tiene fino a 10A (dichiarati).

In commercio ci sono anche dei relè a stato solido (solid-state relay o SSR), per chi volesse approfondire rimando alla pagina Wikipedia https://en.wikipedia.org/wiki/Solid-state_relay, sono  totalmente silenziosi ed alcuni supportano un amperaggio molto elevato. Momentaneamente sto provando questo tipo:

https://amzn.to/2ES0VAj

E devo dire che per ora si sono dimostrati affidabili.

Passiamo ora ai collegamenti ed al test al banco.In questa immagine viene rappresentata la GPIO BCM del Raspberry.

Per prima cosa vediamo come unire i 4 interruttori alla scheda, ognuno di questi rappresenta un circuiti di deviatori/invertitori che, a seconda del loro stato, lasciano passare o meno il flusso di corrente.Quindi un estremo di ciascun interruttore deve essere collegato ad una terra (GND), per comodità può essere usata la stessa per tutti e quattro, l’altro estremo andrà direttamente ad un pin a nostro piacere, saltando però il 2,314,15,10,9,11,8 e 9.

Per quanto riguarda i collegamenti dei relè dipende dal modello che avete preferito: se parliamo di una scheda relè avremo un pin di questa che va al GND , ed uno ai 5v o 3.3v, se invece utilizzate un relè come quello che vi ho proposto (SSR) ad ogni componente va collegata la terra (una in comune a tutti e 4) su un estremo e sull’altro il segnale per l’accensione proveniente dal Raspberry

I pin che ho scelto per i miei collegamenti sono:

interruttore uno

21

interruttore due

20

interruttore tre

16

interruttore quattro     

12

relè uno

26

relè due

19

relè tre

13

relè quattro

6

Colleghiamo anche l’alimentatore sfruttando uno dei due 5v (V+) ed un GND (V-)

Se tutto è andato per il verso giusto dopo pochi secondi saremo in grado di collegarci via SSH e di aprire il terminale del Raspberry.Lanciate i seguenti comandi:

sudo apt-get updatesudo apt-get upgrade (confermate se richiesto)sudo apt-get install python python-pip (confermate se richiesto) Molto probabilmente sono pacchetti che sono già installati in rasbian, ma è buona cosa lanciare comunque il comandopip install paho-mqtt

Ora andremo a creare due files che saranno in esecuzione continua sulla nostra schedina: uno che gestirà gli interruttori e comunicherà ad Home Assistant lo stato delle luci, ed uno che, al contrario, rimarrà in ascolto  in attesa di ricevere un comando, da home assistant o anche da altri Raspberry o Nodemcu,  lo elaborerà per alzare o abbassare il segnale che commuta il relè.

Ora scaricate la cartella seguente e copiatela così com’è nella home del vostro Raspberry

https://drive.google.com/drive/folders/1MLZ0ULDzYrwvlJnuYUWDNWDhHM8voSRZ?usp=sharing

Tornate al terminale entrate nella directory appena creata:

cd ~/luci_salotto

cominciamo col lanciare il file interruttori.py:

python interruttori.py

utilizzando i nostri interruttori vedremo i relè commutare e sul terminale un messaggio ci informa di ciò che sta avvenendo

per avere un riscontro in Home assistant andremo a creare 4 switch mqtt, scaricate il file dal link seguente ed aggiungete il suo contenuto al vostro configuration.yaml se avete una configurazione base, diversamente aggiungetelo al file che avete specificato nel configuration appunto

https://drive.google.com/file/d/1IkLo2LZfk-kOJdksD3_-iPqQaLSeLODR/view?usp=sharing

Per creare un gruppo unico delle 4 luci, per poter accendere o spegnere tutte e quattro le luci in un colpo solo, bisogna creare un gruppo.

Nel file groups.yaml aggiungete in fondo:

luci_prova:
    name: Luci prova
    entities:
      - switch.luce_1
      - switch.luce_2
      - switch.luce_3
      - switch.luce_4

potrete così inserire il group.luci_prova dove vi fa più comodo

Questo è ciò che otterrete:

Cambiando lo stato dell’interruttore vedrete spostarsi anche il selettore, verificate che lo stato di acceso del vostro relè coincida con il selettore sulla destra.

Ora, lasciando in esecuzione il file interruttori.py, aprite un secondo terminale, spostatevi nella cartella luci_salotto, e lanciate il file luci-mqtt.py:cd ~/luci_salottopython luci-mqtt.py

Muovendo il selettore da home assistant vedremo i nostri relè commutare, nella pagina del terminale al solito vedremo in ordine:topic di ricezione del comando da HA;stato che assume il relè;payload ricevuto.

Se tutto è andato per il verso giusto potrete sia commutare i relè con gli interruttori che con il selettore li Home assistant.

Vorrei spiegare per quanto possibile brevemente e più semplicemente possibile come sono strutturati i due file di gestione di questo sistema:

interruttori.yaml  :

Importo 3 librerie di Python: una per la gestione della GPIO del Raspberry, una per la gestione dei comandi Mqtt ed una per la gestione del tempo di attesa.

Dichiarazione della variabile attesa_pulsante

dichiaro i pin usati per i 4 interruttori (int_uno, int_due, int_tre, int_qua), impostandoli poi come input sfruttando inoltre le resistenze di pull-up interne al Raspberry attivabili via software.Creo 4 variabili a cui attribuisco lo stato dei 4 interruttori (stato_int_uno, stato_int_due, stato_int_tre, stato_int_qua)

Dichiaro i pin relativi ai relè (luce_uno, luce_due, luce_tre, luce_qua) e li imposto come segnale di uscita.Nella fase iniziale spengo tutte le luci e imposto lo stato degli switch mqtt di HA su 0

Qui mando un comando a Home assistant per lanciare una notifica, ciò mi permette di sapere quando il sistema è avviato. Per far questo è necessario creare un’automazione che al ricevimento di un messaggio mqtt al topic notify/notifica_nicola estrae il payload e lo gira al servizio notifica_nicola appunto

Avviso che la gestione delle luci è avviata e lancio un ciclo continuo di analisi dei pin relativi agli interruttori:

se lo stato del pin dell’interruttore (int_uno … ) diventa diverso dalla variabile stato_int_….  (stato_int_uno …) significa che abbiamo premuto un bottone, quindi dichiaro nuovamente la variabile stato_int… ed inverto lo stato del relè. Se la luce è accesa (stato_rele_uno==1) si spegne (stato_rele_uno=0) altrimenti viceversa.

GPIO.output(.....) cambio lo stato del pin relativo al relè, quindi pubblico il comando mqtt per cambiare lo stato del selettore di HA. Se registra un errore durante la connessione al server Mqtt (per mancanza wifi o altro) in questa ultima fase salta tale operazione e visualizzo “errore MQTT”. Infine mi comunica lo stato del relè in oggetto.

Nel ciclo continuo ovviamente analizzo tutti e 4 gli interruttori.

Infine aggiungo un tempo di attesa per permettere al nostro Raspberry di comunicare correttamente con HA

luci-mqtt.py:

Come prima importo le librerie, dichiaro le variabili relative ai pin dei 4 relè e li setto come output

definisco le funzioni che vengono eseguite qualora ci connettiamo o perdiamo la connessione dal server MQTT. In caso di disconnessione dal server MQTT aggiungo una linea al file log.txt dove inserisco data e ora dell’evento. Al momento della connessione invece mi sottoscrivo ai topic di mio interesse

definisco la funzione che viene eseguita al ricevimento di un messaggio da un topic a cui ci siamo iscritti precedentemente. Il payload viene elaborato e, se utilizzato, viene stampato un messaggio della commutazione eseguita.

All’avvio del sistema spengo tutte le luci qualora siano accese e definisco i parametri relativi alla sottoscrizione al server MQTT.

NB: i topic che vedete nel file e negli screenshot sono solo a titolo esemplificativo, nonostante ciò non vi è nessun problema ad utilizzarli così come sono. Ovviamente è possibile modificarli a piacere, la cosa fonda fondamentale è che i topic utilizzati da Home assistant coincidano perfettamente con quelli dichiarati nei vostri file

Ora che abbiamo verificato che tutto funzioni al meglio dobbiamo creare un file da rendere eseguibile all’avvio, che esegua i due file creati per Python:nano avvio.shinseriamo le seguenti righe:

#! bin/shsleep 15python /home/pi/luci_salotto/interruttori.py &python /home/pi/luci_salotto/luci-mqtt.py &

Quindi lo inseriamo nel file di configurazione di crontab:

sudo crontab -e

andate alla fine del file edi inserite una riga come segue:@reboot sh /home/pi/avvio.sh

quindi salvate, uscite e riavviate (sudo reboot).

Fase 2

Modifica dell’impianto

Per poter inserire i relè ed il nostro Raspberry dovremo andare a separare il circuito di ogni gruppo di controllo (interruttore, deviatore o inverrtitore) dalla parte di potenza vera e propria che alimenta le nostre luci.

E’ quindi necessario intercettare il filo che dall’uscita dell’ultimo deviatore o interruttore sale verso il lampadario per poterlo dividere: un capo andrà al Raspberry e l’altro all’uscita del relè.

La fase che prima entrava nel circuito dei deviatori dovrà andare all’entrata dei relè

Bene! La guida di Nicola Bertelli termina qui, lo ringraziamo ancora e ci godiamo il video di fine articolo dove Nicola ci mostra il risultato del suo lavoro in azione. Buona visione!