Configurare una VPN per collegarsi da remoto alla rete dell’ufficio

Collegarsi da remoto al proprio ufficio è ora più che mai una necessità, soprattutto per quei lavori che richiedono l’accesso continuo alle risorse di rete aziendali (disco di rete, altri PC, cartelle e file condivisi, stampanti, scanner, etc…).

Questa guida vi aiuterà a configurare una VPN, ossia un tunnel sicuro tra l’ufficio e il vostro PC di casa, in modo tale da poter lavorare come se il vostro PC fosse fisicamente collegato alla rete aziendale. Più nello specifico, potrete fare tutto esattamente come se vi trovaste li: vedere e accedere a file condivisi in rete, lanciare stampe, accedere a dischi di rete e backup, accedere a servizi locali dell’ufficio (es. programmi speciali che girano solo quando connessi alla rete LAN dell’ufficio).

Si ma ho già sentito parlare di VPN, e anche di TeamViewer…

Si parla molto spesso di VPN ma sempre in una accezione lievemente diversa (e a mio avviso non del tutto corretta), ossia quella di servizio di terze parti (e quindi a pagamento, come NordVPN, ExpressVPN, ProtonVPN etc..) che offre la possibilità di “apparire in rete” da una locazione diversa da quella in cui ci si trova; pur trattandosi della medesima tecnologia, non è questa la VPN che intendiamo configurare in questo articolo. Le VPN a pagamento sono senz’altro delle VPN a tutti gli effetti, ma sono utili in altri scenari di utilizzo, ad esempio: 1) per accedere a contenuti bloccati nella nostra regione oppure 2) per accedere ad internet da reti non sicure come ad esempio bar, caffè, aeroporti.

Analogamente il software TeamViewer, strumento che permette il controllo di un computer remoto come se vi fossimo davanti, non risolve esattamente lo stesso problema. TeamViewer è più simile ad un desktop remoto, ossia permette di controllare un PC prescelto dell’ufficio (che deve essere sempre acceso ovviamente) che comparirà in finestra sul vostro PC di casa; tutte le operazioni andranno eseguite dentro quella finestra, senza possibilità di “uscire fuori” (se non con scomodi passaggi avanti e indietro di “trasferimento file”). Ad esempio, non sarà possibile aprire un file CSV e vederlo sull’Excel del vostro PC, ma solo sull’Excel del computer controllato, ossia “in finestra”. Inoltre TeamViewer è a pagamento, e le sessioni rilevate come utilizzi aziendali non durano più di 10 minuti.

Soluzione VPN privata

La VPN che intendiamo realizzare in questo articolo è una estensione privata della propria rete aziendale, eseguita senza l’utilizzo di servizi terzi (perciò totalmente gratuita) e soprattutto sicura (i dati viaggiano dal nostro ufficio al nostro PC remoto, senza passare da server esterni). Il tunnel che andiamo a configurare connetterà il vostro PC di casa all’ufficio ed il risultato netto sarà quello di lavorare dal PC come se questo fosse collegato in WiFi (o cavo) direttamente alla rete dell’ufficio.

A chi si rivolge questa guida?

Elenco alcune tipologie:

  • Singoli professionisti che vogliono lavorare da casa con il proprio portatile come se fossero collegati fisicamente in ufficio, accedere ai dischi di rete, stampanti, scanner, cartelle condivise.
  • Piccole aziende che vogliono far lavorare i propri impiegati e collaboratori da casa, garantendo l’accesso agli stessi identici servizi, di qualsiasi natura (es. software interni aziendali, software vincolati a funzionare solo entro i confini aziendali, dischi di rete condivisi, etc…)

Configurazione della VPN

Iniziamo quindi a vedere la procedura nel dettaglio.

  • Prerequisiti
  • Download del software
  • Configurazione del server
  • Configurazione del router
  • Impostazione avvio automatico della parte server
  • Configurazione del client (PC remoto)

Prerequisiti

Quali sono i prerequisiti per mettere in funzione la nostra VPN? Sostanzialmente solo uno, ossia avere un server aziendale sempre acceso e collegato in rete. Per server si intende anche un banalissimo PC, che deve essere lasciato acceso, l’importante è che sia collegato in rete LAN. Chi non avesse un PC dedicato può anche utilizzare una postazione PC e “proclamarla” server.  Ovvio che per attivare un server VPN nella propria rete locale, la soluzione più semplice consiste nel dotarsi di un router che già supporti tale funzionalità. Ma questa guida si rivolge alla maggioranza degli utenti che non hanno tali router e vogliono comunque configurare un collegamento VPN professionale.

Download del software

Utilizzeremo OpenVPN, soluzione gratuita e open source. Il software andrà installato sia sul server che sul PC client che vuole connettersi da remoto.

Andiamo quindi sul server e scarichiamo OpenVPN dal seguente indirizzo: https://openvpn.net/community-download

Scegliamo l’installer adatto al nostro sistema operativo. Ad esempio, per Windows7 selezioniamo il penultimo link, per Windows10 l’ultimo link.

Avviamo quindi l’installer:

Una volta avviata la procedura di installazione, assicuriamoci che tutte le voci siamo selezionate:

  • OpenVPN Service
  • TAP Virtual Ethernet Adapter
  • OpenVPN GUI
  • EasyRSA 2 Certificate Management Scripts
  • Advanced

Attendiamo il termine dell’installazione.

Configurazione del server

Passiamo adesso a configurare il software che abbiamo appena installato. Andiamo in Pannello di controllo -> rete e internet -> connessioni di rete. Dovrebbe esserci una nuova scheda virtuale, chiamata TAP-Windows Adapter V9

Rinominiamola in ServerVPN

A questo punto avviamo la console dei comandi CMD in modalità amministratore: andiamo in “menu start” e facciamo click destro sopra “prompt dei comandi”, poi selezioniamo “esegui come amministratore”

Si dovrebbe ora aprire il prompt dei comandi:

Portiamoci ora all’interno della cartella OpenVPN. Per far ciò digitiamo nell’ordine i seguenti comandi:

cd ..

cd ..

cd “Program Files”

cd “OpenVPN”

cd “easy-rsa”

Adesso lanciamo i seguenti due comandi:

init-config.bat

copy vars.bat.sample vars.bat

Apriamo ora esplora risorse e portiamoci nella stessa cartella: C:\Program files\OpenVPN\easy-rsa

Ritorniamo nel prompt dei comandi e digitiamo ora i seguenti comandi:

vars

clean-all

Lanciamo ora il comando per la generazione dei parametri DH (parametri Diffie-Hellman)

build-dh

L’operazione potrebbe richiedere qualche secondo (o minuto, per macchine meno potenti)

Terminato il processo di generazione delle chiavi, apriamo ora esplora risorse e portiamoci nella cartella: C:\Program files\OpenVPN\easy-rsa\keys

Confermiamo che il file dh2048.pem è stato creato correttamente:

Adesso ritorniamo al prompt dei comandi e lanciamo il comando per la generazione dei certificati:

build-ca

Il comando ci chiederà alcuni dati aziendali quali “nome azienda”, “indirizzo” etc.. possiamo lasciare questi campi vuoti semplicemente premendo invio

Di nuovo, apriamo ora esplora risorse e portiamoci nella cartella: C:\Program files\OpenVPN\easy-rsa\keys

Confermiamo che i file ca.key e ca.crt sono stati creati correttamente:

Ritorniamo ora al prompt dei comandi e lanciamo il seguente comando:

build-key-server ServerVPN

Anche in questo caso ci verranno chieste alcune informazioni che possiamo evitare di inserire semplicemente premendo invio alla richiesta. All’ultima domanda “sign the certificate? [y/n]” occorre invece rispondere affermativamente con premendo “y”.

Tornando in esplora risorse, sempre nella stessa cartella, dovremmo adesso vedere tre nuovi file: ServerVPN.crt, ServerVPN csr e ServerVPN.key

Adesso generiamo le chiavi per il client:

build-key ClientVPN

Anche in questo caso, il comando ci chiederà alcuni dati che possiamo lasciare vuoti premendo invio. Alla richiesta del “common name” inseriamo però “ClientVPN”

In esplora risorse dovremmo adesso vedere tre nuovi file: ClientVPN.crt, ClientVPN.csr e ClientVPN.key

Lanciamo ora il comando finale che genererà le chiavi statiche per la connessione TLS (il protocollo sottostante alla nostra VPN):

openvpn –genkey –secret keys/ta.key

E convalidiamo come al solito la buona riuscita del comando; dovremmo vedere un nuovo file ta.key:

A questo punto non ci rimane che creare il file di configurazione del server (Server.ovpn). In questo file vengono indicati numerosi parametri tra i quali la porta del server e un range di  indirizzi IP che il server VPN assegnerà ai client una volta connessi. Ovviamente  queste informazioni dipendono dalla propria configurazione di rete. Per comodità ho incluso un file di configurazione di esempio che specifica:

porta = 12345

indirizzi di rete disponibili per i client = da 192.168.13 a 192.168.1.19

indirizzo IP del bridge = 192.168.1.12

network mask = 255.255.255.0

Scarica file configurazione server

Questo file va posizionato in C:\Program files\OpenVPN\config

Avviamo ora VPN server cliccando su OpenVPN GUI (sul desktop) e poi cliccando con il tasto destro sull’icona accanto all’orologio in basso a destra e poi selezionando “connect”.

L’icona dovrebbe diventare verde, ad indicare che VPN server è attivo e in ascolto

Dobbiamo ora collegare assieme l’interfaccia virtuale TAP ServerVPN e l’interfaccia di rete Ethernet che il nostro server utilizza. L’operazione si chiama in gergo “bridging”. Il risultato finale e una terza interfaccia, unione delle due, che sarà quella effettivamente utilizzata dal nostro server (il computer stesso) e che risponderà sia del normale traffico di rete in LAN che del traffico in VPN.

A tal fine apriamo il pannello di controllo -> rete e internet -> connessioni di rete. Selezioniamo entrambe le interfacce “Local Area Connection” e “ServerVPN”. Clicchiamo con il tasto destro e selezioniamo “bridge connection”.

Verrà creata una nuova interfaccia di rete “Network bridge”.

Questa interfaccia è quella adesso realmente utilizzata dal server; Windows disabilita automaticamente le altre due. Ovviamente questa interfaccia non eredita le configurazioni TCP/IP che avevano le due precedenti (indirizzo IP statico o DHCP, DNS primario, gateway, subnet mask etc..), occorre quindi reimpostare questi parametri. Molto probabilmente vorremo reimpostare gli stessi identici parametri della interfaccia originale “Local Area Connection”:

Configurazione del router

Il server VPN è pronto ma dobbiamo esporre il servizio all’esterno della nostra rete locale, in modo tale che client remoti abbiamo la possibilità di connettersi. A tal fine occorre aprire in NAT la porta locale che abbiamo utilizzato per il server VPN (nel nostro esempio, porta 12345). Entriamo quindi nel nostro router ed apriamo la porta 12345 verso l’esterno, possiamo anche utilizzare una porta differente (es. 8888)

Impostazione avvio automatico della parte server

A questo punto vogliamo avviare il server VPN automaticamente all’avvio di Windows, per poter garantire l’accesso anche in caso di riavvio della macchina. Questo passaggio è facoltativo ma altamente consigliato.

A tal fine apriamo il prompt dei comandi in modo amministratore e lanciamo il seguente comando:

sc create vpnserver start= auto binPath= “C:\Program Files\OpenVPN\bin\openvpnserv.exe”

Il comando dovrebbe rispondere con:

[SC] CreateService SUCCESS

Se vogliamo confermare la presenza del nuovo servizio ci basterà andare nella lista dei servizi (menu start -> esegui -> “services.msc”):

Configurazione del client (PC remoto)

Finalmente procediamo a configurare un client PC. Questa procedura andrà ripetuta per tutti i computer che vogliamo connettere in VPN con il nostro server.

Per prima cosa installiamo OpenVPN esattamente come abbiamo visto nel caso del server.

Successivamente, andiamo nel server e copiamo i seguenti file:

  • ca.crt
  • ClientVPN.crt
  • ClientVPN.csr
  • ClientVPN.key
  • ta.key

Questi file andranno copiati nel PC client, all’interno della cartella C:\Program Files\OpenVPN\config

 

All’interno della medesima cartella andrà posizionato il file di configurazione del client (Client.ovpn). Analogamente a quanto visto per la parte server, questo file contiene le informazioni necessarie al client per connettersi in VPN, una fra tutte l’indirizzo IP esterno della rete dell’ufficio e la porta (vedi sezione precedente).

Per comodità ho creato un file di configurazione di esempio, scaricabile qui

Infine, testiamo la connessione avviando OpenVPN sul PC client (icona OpenVPN GUI sul desktop). L’icona in basso a destra dovrebbe diventare verde e un popup ci segnalerà l’indirizzo IP che abbiamo ricevuto dal server. L’indirizzo IP sarà uno di quelli previsti nel range che abbiamo specificato nel file di configurazione del server. In questo caso abbiamo ottenuto il primo disponibile, ossia 192.168.1.13

 

Una volta connesso, il PC client opererà in tutto e per tutto come se si trovasse in ufficio: potrà avviare stampe, vedere cartelle condivise, collegarsi a server FTP e accedere a servizi interni dell’ufficio.

 

 

 

 

 

 

 

 

 

[Domotica IoT] Controllo relè da remoto (ESP8266 + WiFi + Android app)

Vi presento un piccolo progetto che ho realizzato per comandare 8 relè da remoto. La scheda monta un ESP8266 (ESP-01) e si collega alla wifi di casa. Tramite una semplice applicazione Android possiamo comandare in modo indipendente gli 8 relè via internet, da ovunque e in qualunque momento. E’ sufficiente che lo smartphone sia connesso (dati o wifi).

Cosa possiamo fare con questa scheda? Avendo 8 relè a disposizione, possiamo comandare fino a 8 carichi 220v 3A, come ad esempio:

  • cancelli di casa
  • porte garage
  • portone di casa
  • caldaia
  • aria condizionata
  • allarmi

In sostanza un pò tutto quello che è già comandato da un interruttore. Forni o stufe elettriche non possono essere collegati perchè la potenza massima gestibile dai relè che ho utilizzato è di 600W circa (220V 3A). A meno che ovviamente questi dispositivi non abbiano un segnale di controllo a bassa tensione oppure si utilizzi un relè di potenza in grado di gestire alte correnti.

Il comando che arriva al relè può essere configurato in diversi modi:

  • impulso monostabile (esempio: 1 secondo ON e poi di nuovo OFF automaticamente)
  • bistabile (ossia rimane nella posizione assegnata ON o OFF)
  • temporizzato (esempio: ON la mattina, OFF la sera)
  • treno di impulsi (se occorre inviare segnali particolari a dispositivi più sofisticati)

Ovviamente in commercio esistono numerose schede già fatte, ma richiedono software o applicazioni specifiche, a volte a pagamento e non sempre i relè solo configurabili a piacimento (vedi punti sopra).

Schema di base

Lo schema di base è abbastanza semplice: la board si connette ad internet tramite il router wifi di casa. Lo smartphone invia comandi alla board tramite la propria connessione dati. L’utente non deve essere necessariamente connesso direttamente in wifi.

Protocollo di comunicazione

Per l’invio dei comandi da smartphone a board ho deciso di implementare il protocollo MQTT, uno degli standard più famosi ed utilizzati per lo scambio di dati tra dispositivi IoT e non.

http://www.itdistribuzione.com/portale/html/NewsPage.html?idNews=2954

http://mqtt.org/

Il bello di questo protocollo sta nel fatto che è estremamente semplice da implementare, anche su piattaforma Arduino (e in modo particolare sull’ESP01) e non richiede l’apertura di porte lato router wifi: l’ESP01 si connette verso un server MQTT esterno, instaura una connessione persistente e resta in attesa di comandi. Lo smartphone invia comandi al server MQTT esterno che a sua volta recapita i messaggi all’ESP01. Ovviamente possiamo anche inviare messaggi MQTT in direzione opposta, dall’ESP01 verso lo smartphone, sebbene questo progetto non implementi tale funzionalità.

Grazie a questo protocollo non dobbiamo né aprire porte in NAT, né conoscere il nostro indirizzo IP, né tantomeno contattare periodicamente un server esterno in polling.

Esistono numerosi server MQTT gratuiti, tra i quali Maqiatto e HiveMQ. Il primo in particolare non ha alcuna restrizione di banda o di dispositivi, ed è accessibile 24h su 24h sulla porta 1883.

Componenti

La board IoT si compone di 3 elementi principali:

  • ESP01
  • board Arduino 8 relè
  • GPIO expander PCF8574

L’ESP01 è l’elemento principale: si connette in wifi e riceve comandi dall’esterno; traduce inoltre questi comandi in appositi segnali per pilotare la board relè. Siccome l’ESP01 non ha abbastanza GPIO per comandare direttamente la board (ne servirebbero 8, uno per relè), ho utilizzato un GPIO expander (PCF8574) che sostanzialmente permette di comandare 8 GPIO tramite I2C: l’ESP01 invia una richiesta I2C all’expander che ha sua volta aziona i GPIO opportuni.

ESP01

L’ESP01 è un microcontrollore a basso costo basato sul micro ESP8266 con wifi integrato, compatibile con Arduino. Costa poco più di un euro ed il primo di una lunga famiglia: esistono numerosi altri modelli, ESP-02, ESP-03 etc.. ognuno dei quali possiede caratteristiche e funzionalità via via più sofisticate. Ad oggi ne esistono ben 12 modelli, da ESP-01 a ESP-12.

Il pinout dell’ESP01 è veramente ridotto all’osso: 8 pin in totale:

  • VCC – alimentazione (3.3V)
  • GND – massa
  • RST – reset
  • CH_PD – chip enable
  • TX, RX – seriale per la programmazione
  • GPIO0, GPIO2 – gli unici due GPIO disponibili

La seriale TX e RX è riservata per la programmazione iniziale, sebbene poi possa essere riallocata come seriale generica durante il normale funzionamento. Il pin CH_PD è il chip enable: abilita l’ESP01 e va quindi sempre tenuto HIGH. Il pin RST è il reset, anch’esso va tenuto HIGH. Occhio che l’ESP01 lavora con i livelli di tensione 3.3V e 0V, quindi HIGH corrisponde a 3.3V, LOW corrisponde a 0V. Anche la seriale è a 3.3V quindi nel caso avessimo un programmatore a 5V occorrerà convertire opportunamente i livelli di tensione.

L’ESP01 può essere avviato in due modi operativi differenti: modo programmazione e modo esecuzione. Nel modo programmazione, l’ESP01 si mette in ascolto sulla seriale (TX,RX,GND) in attesa di ricevere il programma da memorizzare nella flash interna. Nel modo esecuzione invece, l’ESP01 si avvia normalmente eseguendo il programma memorizzato nella flash.

Per avviare l’ESP01 in modo programmazione basta impostare i due GPIO nel seguente modo: GPIO0 = LOW e GPIO2 = HIGH. Per avviare l’ESP01 in modo esecuzione, occorre invece tenere HIGH entrambi i GPIO: GPIO0 = HIGH, GPIO2 = HIGH. Dopo l’avvio in una qualsiasi delle due modalità, non è più necessario tenere i GPIO impostati.

Board Arduino 8 relè

Questa board monta 8 relè pilotabili in modo indipendente grazie agli 8 pin di ingresso. Alimentazione a 5v (ma l’ho testata e funziona anche con 3.3V).  Il jumper permette di alimentare i relè con una alimentazione indipendente.

 

GPIO expander PCF8574

Si è reso necessario utilizzare un GPIO expander perchè l’ESP01 non ha abbastanza GPIO (soltanto 2 dei 8 necessari). Il PCF8574 è sicuramente il più adatto in questo caso. Questo expander riceve comandi tramite I2C e imposta i suoi GPIO in modo opportuno. Il comando I2C è un semplice pacchetto di 2 byte: il primo byte è l’indirizzo dell’expander, il secondo byte rappresenta lo stato dei GPIO (0 = HIGH, 1 = LOW). I GPIO possono anche essere impostati come ingressi, per leggerne lo stato è sufficiente inviare un comando I2C in modo lettura. Nel nostro caso non abbiamo implementato questa funzionalità.

Da notare i 3 jumper per impostare l’indirizzo dell’expander. Di default, l’indirizzo è 0x20.

Programmazione dell’ESP01 – Hardware

Per la programmazione ho utilizzato l’adattatore seriale FTDI 232RL USB

Questo adattatore si collega al PC tramite cavo USB e può essere configurato tramite jumper sia in modalità 5V che 3.3V (quella che ci serve per programmare l’ESP01).

Occorrerà inoltre realizzare una piccola board per collegare tra loro l’FTDI232RL all’ESP01 e per impostare GPIO0 e GPIO2 dell’ESP01 in modo programmazione (nonchè fornire l’alimentazione e polarizzare i pin CH_PD e RST). Ecco lo schema:

Sotto il programmatore completo, su basetta millefori. Sono necessari solo 4componenti esterni: 3 resistenze da 10 kohm e uno switch per il reset. Attenzione, impostate l’FTDI232BL in modalità 3.3V o rischiate di bruciare l’ESP01.

 

Programmazione dell’ESP01 – Configurare l’editor Arduino

Prima di poter programmare l’ESP01 occorre prima importare le configurazioni ESP8266 all’interno dell’editor Arduino. E’ sufficiente andare in “File” -> “preferences” e poi nella tab “settings” impostare nel campo “additional board manager URL” il seguente URL:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Date OK e riavviate l’editor Arduino. A questo punto occorre includere le librerie per ESP8266. Queste librerie vi daranno accesso al wifi per connettervi, creare un access point, e per gestire le comunicazioni via HTTP e TCP/UDP raw.

Per includere le librerie andate in “tools” -> “board: (la board corrente)” -> “board manager”. Cercate “ESP8266” e installate il pacchetto evidenziato (esp8266 by ESP8266 Community).

Riavviate Arduino IDE. Adesso, andando in “tools” -> “board:” dovreste vedere “Generic ESP8266 Module”. Selezionatelo. Inoltre impostate i seguenti parametri:

  • flash mode = DIO
  • flash frequency = 40MHz
  • CPU frequency = 80 MHz
  • Flash size = 512K (64K SPIFFS)
  • Debug port = disabled
  • Debug level = None
  • Reset Method = ck
  • Upload speed = 115200

Ed impostate la seriale COM opportuna. Il PC dovrebbe vedere l’FTDI232BL in modo automatico, se non dovesse dovrete scaricare i driver dal sito del produttore:

https://www.ftdichip.com/Drivers/VCP.htm

A questo punto siete pronti per programmare l’ESP01!

Circuito completo

Gli elementi base del circuito sono l’ESP01, la board Arduino 8 relè, e il GPIO expander PCF8574. L’ESP01 e l’expander richiedono una tensione di 3.3V, mentre la board relè 5V. Occorrerà quindi fornire queste due tensioni tramite appositi regolatori di tensione. l’ESP01 deve entrare in modo esecuzione (GPIO0 = HIGH e GPIO2 = HIGH). Fortunatamente, l’expander PCF8574 fornisce due resistenze di pull-up interne per le linee SDA e SCL

Firmware

Lo sketch Arduino è abbastanza semplice: ci connettiamo alla rete tramite WiFi (nome rete e password sono nello sketch), successivamente ci connettiamo al server MQTT e rimaniamo in attesa di comandi. Ad ogni comando ricevuto, decodifichiamo la richiesta ed inviamo il comando I2C opportuno al GPIO expander, che a sua volta azionerà il GPIO richiesto. Da notare che occorre includere la libreria MQTT, io ho scelto l’ottima pubSubClient:

https://github.com/knolleary/pubsubclient

e la libreria Wire, per la comunicazione tramite I2C:

https://www.arduino.cc/en/reference/wire

Entrambe queste librerie vanno importate esattamente allo stesso modo visto in precedenza per la libreria ESP8266

 

Setup()

Nella fase di setup() impostiamo i pin GPIO0 e GPIO2 come output. In più, prepariamo questi due gpio per la comunicazione via I2C con l’expander. GPIO0 = SDA e  GPIO2 = SDL. Da notare che utilizziamo la libreria Wire (#include(“Wire.h”)) per comunicare tramite I2C.

Successivamente resettiamo l’expander inviando il pacchetto I2C di due byte [0x20,0xff]. 0x20 è l’indirizzo che abbiamo assegnato all’expander tramite i jumper, mentre 0xff rappresenta lo stato dei GPIO, ossia tutti e 8 LOW. (1 = LOW, 0 = HIGH). Ovviamente, se assegnate un indirizzo diverso, dovrete inviare il byte opportuno. E’ anche possibile collegare in catena più expander, fino a 8 per un totale di 64 GPIO.

Fatto ciò impostiamo il client MQTT passando l’indirizzo del server e la porta, nel nostro caso “maqiatto.com” e 1883. In più, passiamo il puntatore alla nostra funzione callback che verrà invocata dalla libreria ogniqualvolta riceveremo un pacchetto MQTT.


void setup()
{
   pinMode(BUILTINLED, OUTPUT);
   digitalWrite(BUILTINLED, HIGH);

   // setup PCF8574
   pinMode(0, OUTPUT);
   pinMode(2, OUTPUT);

   delay(5000);

   Wire.begin(0, 2); // SDA = GPIO0, SDL = GPIO2
   Wire.beginTransmission(0x20);
   Wire.write(0b11111111);
   Wire.endTransmission();

   mqttClient.setServer(mqtt_server, mqtt_port);
   mqttClient.setCallback(callback);
}

Loop()

Nel loop principale effettuiamo in sequenza ciclica queste operazioni:

  • test & connessione wifi
  • test & connessione a server MQTT
  • gestione della coda MQTT

void loop()
{
   connectWifiReliable(); // connect wifi
   connectMqttReliable(); // connect mqtt
   mqttClient.loop();
}

La prima riga lancia connectWifiReliable(), una funzione che o ritorna immediatamente se l’ESP01 è connesso alla WiFi, di fatto rendendosi totalmente trasparente al loop, oppure (se l’ESP01 non fosse connesso in WiFi) procede alla connessione (riprovando più volte non dovesse riuscirci al primo tentativo). Al ritorno della funzione è garantita una connessione WiFi. Dopo un certo numero di tentativi falliti (io ho messo 200 tentativi), la funzione esegue il reboot completo dell’ESP01. Mettendo la funzione di connessione nel loop principale e controllando ad ogni ciclo che l’ESP01 sia connesso, rendiamo la connessione WiFi estremamente robusta: qualsiasi problema tipo disservizio di rete, router in riavvio, mancanza momentanea della WiFi, viene prima o poi intercettato dalla connectWifiReliable() che provvede a ripristinare il collegamento. Viene correttamente gestito anche il primo avvio dell’ESP01 (durante il quale la board non è ovviamente connessa). Di solito, su molti altri sketch Arduino, vedo il codice di setup della WiFi messo direttamente nella funzione setup() ma non credo sia ottimale perchè non vengono gestiti eventuali problemi di connessione.

Una funzione analoga, connectMqttReliable(), connette invece l’ESP01 al server MQTT. Funziona con lo stesso principio: non si esce dalla funzione fintanto che non è stabilita una connessione col server remoto. Dopo alcuni tentativi falliti anche questa funzione invoca il reboot dell’ESP01.

L’ultima funzione, ossia mqttClient.loop(), gestisce il protocollo MQTT stesso. Gestisce la coda interna e provvede ad invocare la nostra callback di gestione dei pacchetti MQTT remoti. Deve essere invocata ad intervalli regolari, idealmente in loop infinito. Ed è proprio quello che facciamo noi piazzandola nel loop principale.

Callback gestione dei comandi MQTT

Veniamo ora alla parte più interessante ossia la callback che gestisce il pacchetto MQTT in arrivo da un client remoto. Questa funzione è invocata dalla libreria MQTT stessa all’arrivo del pacchetto MQTT. La firma della funzione è la seguente:

void callback(char* topic, byte* payload, unsigned int length)

topic è il “canale” MQTT di ricezione (MQTT funziona secondo il classico patter publisher/subscriber per cui il client ESP01 si mette in ascolto (subscribe) solo a determinati “canali”.

payload è il pacchetto stesso, un array di byte

length è la lunghezza del pacchetto, in byte

Nel mio caso, avendo solo un topic registrato, non controllo questa variabile. Più topic magari richiederebbero l’esecuzione di codice diversificato a seconda del canale. Payload e length invece vengono passati direttamente a processRequest()


void callback(char* topic, byte* payload, unsigned int length)
{
    if(length != 18) return;
    processRequest(payload);
}

Nel mio caso faccio un ulteriore controllo sulla lunghezza: se il pacchetto non è lungo 18 byte, la funzione scarta tutto ed esce senza fare nulla. Il pacchetto MQTT che ho studiato è lungo infatti esattamente 18 byte:

Il primo byte definisce il modo di attivazione del relè: può essere “P” per PULSE oppure “T” per TOGGLE. PULSE implica l’attivazione per un secondo del relè, dopodichè il relè torna automaticamente in posizione di riposo. TOGGLE invece cambia stato al relè, che in questo rimane indefinitivamente nello stato impostato (a parte ovviamente riavvii dell’ESP01 oppure blackout completi). Il secondo byte definisce quale relè attivare: “0” attiva il primo relè, “1” il secondo, “2” il terzo e cosi via fino a 7. Gli ultimi 16 byte costituiscono invece la password: non strettamente necessaria, la password impedisce a client non autorizzati di inviare comandi alla board. Solo i client che sono a conoscenza della password possono attivare i relè. E’ possibile specificare una password diversa per ogni relè.

Ad esempio il seguente pacchetto MQTT attiva il relè numero 4 (indice GPIO 3) in modalità PULSE (un secondo ON e poi di nuovo OFF), con password “ABCDEFGH12345678”.


P3ABCDEFGH12345678

 

Se dunque il pacchetto supera il controllo di lunghezza, viene inviato alla funzione processRequest() che decodifica il payload, controlla la password e poi invia i comandi I2C opportuni all’expander.


void processRequest(byte* payload)
{
   char cmd = payload[0];
   char chn = payload[1];
   char password[16];
   for(int p = 0; p < 16; p++) password[p] = payload[2 + p];

   uint8_t chnNum;
   if(chn == '0') { chnNum = 0b00000001; if(strncmp(password, PASSWORD_CH0, 16) != 0) return; }
   else if(chn == '1') { chnNum = 0b00000010; if(strncmp(password, PASSWORD_CH1, 16) != 0) return; }
   else if(chn == '2') { chnNum = 0b00000100; if(strncmp(password, PASSWORD_CH2, 16) != 0) return; }
   else if(chn == '3') { chnNum = 0b00001000; if(strncmp(password, PASSWORD_CH3, 16) != 0) return; }
   else if(chn == '4') { chnNum = 0b00010000; if(strncmp(password, PASSWORD_CH4, 16) != 0) return; }
   else if(chn == '5') { chnNum = 0b00100000; if(strncmp(password, PASSWORD_CH5, 16) != 0) return; }
   else if(chn == '6') { chnNum = 0b01000000; if(strncmp(password, PASSWORD_CH6, 16) != 0) return; }
   else if(chn == '7') { chnNum = 0b10000000; if(strncmp(password, PASSWORD_CH7, 16) != 0) return; }
   else return;

   if(cmd == 'P')
   {
      sendGpio(gpioOut & ~chnNum);
      delay(1000);
      sendGpio(gpioOut | chnNum);

      digitalWrite(BUILTINLED, HIGH);
      delay(100);
      digitalWrite(BUILTINLED, LOW);
      delay(100);
   }
   else if(cmd == 'T')
   {
      gpioOut = gpioOut ^ chnNum;
      sendGpio(gpioOut);

      digitalWrite(BUILTINLED, HIGH);
      delay(100);
      digitalWrite(BUILTINLED, LOW);
      delay(100);
   }
   else
   {
      return;
   }
}

Per il resto allego lo sketch completo

download sketch Arduino (2Kb)

 

Client

Come dispositivo client possiamo utilizzare qualsiasi software in grado di inviare comandi MQTT: eseguibile standalone Windows, pagina web in PHP, oppure una applicazione Android. Io ho optato per l’ultima opzione, una applicazione Cordova Javascript in grado di inviare pacchetti arbitrari ad un server MQTT.

In questo caso l’applicazione permette di definire una lista di pulsanti, nominarli a piacere, selezionare il modo (PULSE o TOGGLE) e il GPIO corrispondente.

Il server Maquiatto offre anche una comoda interfaccia web per testare i propri sistemi MQTT. E’ possibile inviare pacchetti MQTT arbitrari, definire o registrarsi a topic già creati in precedenza etc…

http://maqiatto.com/webclient/

Grazie a questa interfaccia web non è necessario implementare il client per testare il funzionamento della board ESP01

 

 

 

 

 

 

 

 

 

 

Patch per PhpSpreadsheet, no ai valori in notazione scientifica

PhpSpreadsheet è, a mio avviso, la migliore libreria PHP per creare, leggere e modificare file Excel e CSV. Solo un piccolo problema: non ho capito se si tratta realmente di un bug, ma quando una cella contiene un valore numerico molto alto (es. 182342737354689352) la libreria restituisce l’equivalente valore in notazione scientifica (1.82342737E17), tra l’altro perdendo pure in precisione. Il problema si verifica anche utilizzando il formato CSV che di sua natura non codifica il tipo di dato per le colonne.

Per ovviare al problema ho realizzato una piccola patch che forza la libreria a considerare tutte le celle come testuali, ritornando sempre un valore stringa, indipendentemente dal tipo cella. Per applicare la patch è sufficiente sostituire il file Cell.php originale con quello alternativo.

Link patch ->PhpSpreadsheet-1.8.2-stringsonly-patch