Questo semplice progetto IoT (Internet Of Things) necessita di una importante premessa riguardante i rischi connessi alla sua realizzazione e messa in funzione:

Le applicazioni che prevedono l’uso di tensione alternata di 230v devono essere realizzate da personale qualificato e consapevole dei rischi a cui ci si espone.

L’accesso alla rete elettrica, a dispositivi elettrici e/o elettronici vi espone a tensioni di voltaggio letale per l’essere umano.

Informatica37.it non si assume nessuna responsabilità riguardante danni a persone e/o cose derivanti dall’esecuzione delle istruzioni sotto riportate, ogni vostra azione sarà sotto la vostra totale responsabilità. Il fine di questo articolo è puramente didattico e divulgativo.

Fatte le dovute premesse possiamo partire con il progetto per realizzare una presa elettrica connessa tramite wi-fi alla rete dati locale (LAN) e comandabile attraverso una pagina web  caricata sul web server di un microcontrollore. Ovviamente potrebbe essere comandabile anche fuori dall’ambito domestico ma in questa guida non spiegheremo il come gestire “ip pubblico e porte” nel router domestico.

Iniziamo elencando i componenti utilizzati nel progetto cercando di spiegare anche il motivo per cui sono stati scelti.

Microcontrollore wi-fi NodeMCU

Abbiamo optato per questa scheda microcontrollore perchè rispetto ad un modulo esp8266 è molto più semplice da collegare via USB per programmarlo con l’IDE Arduino ed alimentarlo con un comune alimentatore con connettore micro USB. Per utilizzare questa scheda è necessario installare dei driver e aggiungere il modello di scheda nell’IDE di Arduino. Questo modulo, da una parte funziona come un comune microcontrollore tipo Arduino su cui posso comandare dei pin digitali, dall’altro permette di implementare un web server connesso in wi-fi su cui posso creare interfacce web per interagire con l’hardware connesso fisicamente ai suoi pin.

Modulo relè doppio da 230V e 10A

Volendo realizzare un progetto che lavora a tensione di rete a 230v abbiamo pensato che possa offrire maggiore sicurezza il poter interrompere entrambi i fili di fase e neuro. Quando collego la spina di un utilizzatore ad una presa non posso sapere su quale contatto della spina avrò il filo di fase, usando il relè doppio potrò interrompere entrambi i conduttori e sarò certo di aver interrotto il filo di fase a prescindere dal verso in cui è infilata la spina nella presa. Se invece il vostro progetto prevede l’uso del relè in un circuito in bassa tensione continua, allora potreste limitarvi ad utilizzare solo uno dei due moduli o optare per una scheda con un solo relè. La scheda relè deve essere alimentata 5V per funzionare, purtroppo però l’alimentazione disponibile sul modulo NodeMCU è di soli 3,3V, nonostante questo abbiamo verificato praticamente su più schede che l’alimentazione è sufficiente a farla funzionare, nel caso non lo fosse bisognerebbe alimentare la scheda relè con l’alimentazione a 5V che alimenta la scheda NodeMCU. L’utima funzionalità da segnalare su questa scheda (valida anche per schede con più relè a bordo) è quella dell’ “optoisolamento“, garanzia di maggiore sicurezza tra la parte di potenza (230V alternata) e quella di controllo (5V continua), la quale, per poter essere implementata, necessita di una alimentazione separata dedicata al solo modulo relè ma che sfortunatamente complica un po’ il progetto, vedremo più avanti come eventualmente collegarla per usufruire di questo componente che contribuisce ad aumentare la sicurezza della nostra applicazione.

Alimentatore USB

Questo alimentatore è necessario per alimentare la scheda NodeMCU. Vi consigliamo di acquistarne uno con cavo USB separato in modo da poter utilizzare il cavetto USB sia per caricare il programma da PC che per l’alimentazione. Nel caso vogliate fornire alimentazione separata alla scheda relè per usufruire dell’optoisolamento dovreste comprarne anche un secondo (da modificare per essere connesso alla scheda). Attenzione: non acquistate alimentatori con doppia presa USB per alimentare le due schede, per usare l’optoisolamento è fondamentale avere due alimentatori “fisicamente” separati!

Varie: cavi, connettori, led, resistenze

Nel nostro progetto abbiamo inserito un led con resistenza da 220Ω (facoltativo) per avere un feedback visivo utile quando il progetto definitivo verrà chiuso in un contenitore. Come altro materiale consigliamo di avere un tester, una breadboard e dei jumper (maschio femmina, femmina femmina). Per testare le uscite dei relè prima di una eventuale connessione alla rete elettrica potrebbe essere utile costruirsi un circuito di test con batteria, resistenza e led. Per il progetto finale potrebbe tornarvi utile un saldatore a stagno, del materiale elettrico come scatole fili, spina elettrica, presa 10A, ecc.

 

Schema elettrico e collegamenti

Raccolto tutto il materiale necessario possiamo iniziare a collegare le parti tra loro secondo lo schema che segue:

In questa fase evitate di collegare qualsiasi cosa all’uscita dei moduli relè! Ai fini della realizzazione e test del programma non è necessario ne’ il collegamento alla rete elettrica ne’ la connessione di spine, prese o lampade. Per la verifica e test del programma basterà guardare i led a bordo della scheda relè e ascoltare i “click” emessi dai relè stessi, inoltre sarà sempre possibile controllare lo stato dei contatti di uscita tramite un tester. 

Le applicazioni che prevedono l’uso di tensione alternata di 230v devono essere realizzate da personale qualificato e consapevole dei rischi a cui ci si espone. L’accesso alla rete elettrica, a dispositivi elettrici e/o elettronici vi espone a tensioni di voltaggio letale per l’essere umano. Il fine di questo articolo è puramente didattico e divulgativo.

Informatica37.it non si assume nessuna responsabilità riguardante danni a persone e/o cose derivanti dall’esecuzione delle istruzioni riportate in questo articolo, ogni vostra azione sarà sotto la vostra totale responsabilità.

Come già anticipato, il modulo NodeMCU (microcontrollore) viene alimentato dall’alimentatore USB ed a sua volta alimenta i due relè del modulo. In questo caso il pin D6 (gpio 12) sarà riservato al led, mentre i pin D7 (gpio 13) e D8 (gpio 15) ai rispettivi relè.

Esaminiamo ora più da vicino il nostro modulo relè:

Nella parte destra abbiamo le connessioni della nostra presa che approfondiremo più avanti, mentre sulla parte sinistra in basso abbiamo i 4 ingressi del modulo: VCC e GND vanno collegati all’alimentazione del modulo NodeMCU, mentre IN 1 e IN 2 vanno collegati rispettivamente ai pin D7 e D8 del microcontrollore. Nella parte alta di sinistra è presente un “jumper”:

1. se il jumper è inserito, il modulo si alimenta dal modulo NodeMCU e non avremo la possibilità di utilizzare gli optisolatori che garantiscono una separazione fisica tra parte di controllo e parte di potenza.
2. se il jumper non è inserito, il modulo necessiterà di una alimentazione separata da quella del modulo NodeMCU sui pin JD-VCC e GND. Come si vede dallo schema che segue, l’alimentazione esterna non sostituisce quella del modulo NodeMCU ma va ad aggiungersi, va solo eliminato il filo GND dal microcontrollore al modulo relè. Questo perché l’alimentazione aggiuntiva servirà ai relè, mentre quella del microcontrollore controllerà la logica della scheda relè (fonti: [1] [2]).

In questo caso per rendere le cose più semplici realizzeremo la prima ipotesi, ovvero quella in cui il modulo NodeMCU alimenta la scheda relè autonomamente.

Prima di procedere con la programmazione vediamo anche l’altro lato del modulo relè in cui ci sono 2 morsettiere con 3 contatti:

• Normalmente Chiuso (NC, normally connected)
• Comune (COM)
• Normalmente Aperto (NO, normally open)

Il relè è un componente che si comporta come un “interruttore” di cui dobbiamo stabilire il suo “stato iniziale”. Introducendo un “interruttore” nel circuito ci troveremo ad avere due capi del circuito liberi: un capo da collegare obbligatoriamente al COM (comune), poi se decidiamo che come stato iniziale il filo debba essere “interrotto” (circuito aperto), dovremmo collegare l’altro capo al morsetto NO (normalmente aperto). Con questa configurazione, ogni volta che attiverò il relè questo passerà all’altro stato, ovvero quello di “circuito chiuso”. Ovviamente vale il viceversa, quindi se decido che il mio stato iniziale debba essere l’NC (normalmente chiuso) quando ecciterò il relè otterrò un cambiamento di stato a “circuito aperto” (interrotto).

Ricordiamo ancora una volta che ai fini della realizzazione e test del progetto non è necessario collegare nulla ai morsetti del relè.

 

Configurazione del microcontrollore NodeMCU

Per prima cosa scaricate ed installate il driver al seguente link in base al vostro sistema operativo in uso:  https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers .

Dopodiché bisognerà aggiungere la scheda all’IDE di Arduino. Per farlo aprite il software ed andate nel menù File > Preferenze , poi alla voce “URL aggiuntive per il Gestore schede” incollate il seguente link e salvate: https://arduino.esp8266.com/stable/package_esp8266com_index.json

Ora andate sul menù Strumenti > Scheda > Gestore Schede, cercate la stringa “esp8266” ed installate la libreria.

A questo punto potrete selezionare la scheda NodeMCU e la relativa porta di connessione

 

Programmazione del modulo microcontrollore NodeMCU

Il modulo microcontrollore NodeMCU, da una parte permette di poter gestire le uscite digitali, dall’altro di poter gestire un piccolo web server connesso Wi-Fi alla nostra rete locale su cui creare una pagina web contenente l’interfaccia di controllo della nostra applicazione.

Apriamo l’IDE di Arduino e iniziamo la scrittura dello sketch. Come prima cosa includiamo necessariamente la libreria esp2266wifi dopodiché dovremmo inserire i dati per la connessione alla rete Wi-Fi (nome della rete e password).

// Libreria Wi-Fi
#include 

// Dati connessione Wi-Fi
const char* ssid     = "NOME_DELLA_VOSTRA_RETE_WI-FI";
const char* password = "PASSWORD_DELLA_VOSTRA_RETE_WI-FI";

Successivamente, supponendo di voler assegnare un indirizzo ip statico alla scheda Wi-Fi del modulo, inseriamo i seguenti paramenti:

// Configurazione IP STATICO (da commentare in caso di DHCP)
IPAddress ip(192, 168, 1, 100);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

// Porta del web server
//WiFiServer server(8080);
WiFiServer server(80);

Impostate l’ip, il gateway e la subnet in base i dati della vostra rete locale, come porta potreste lasciare l’80, poi se pensate di voler controllare la scheda da remoto potrete sempre cambiarla con un’altra (es: 8080). Adiamo ora a definire le variabili necessarie al progetto:

// Variabile da salvare per richiesta HTTP
String header;

// Variabili per gli output (GPIO 13 = pin D7 ; GPIO 15 = pin D8 ; GPIO 12 = pin D6)
const int ledPin = 12;
const int output1 = 13;
const int output2 = 15;

// Variabili ausiliarie per memorizzare lo stato dei pin
String output1State = "off";
String output2State = "off";
String statoPresa = "SPENTA";
String statoLed = "off";

Per la definizione dei pin da utilizzare potete fare riferimento al seguente schema:

Possiamo quindi proseguire con il setup() al fine di inizializzare tutte le variabili:

void setup() {
  Serial.begin(9600);
  // Inizializzo i Pin
  pinMode(output1, OUTPUT);
  pinMode(output2, OUTPUT);
  pinMode(ledPin, OUTPUT);
  // Setto i Pin a livello alto
  digitalWrite(output1, HIGH);
  digitalWrite(output2, HIGH);
  // Setto livello LED
  digitalWrite(ledPin, LOW);

/* Decommentando queste righe per il DHCP dovremmo commentare quelle sopra
   relative alla "Configurazione IP STATICO" */
//  Connessione alla rete via DHCP
//  Serial.print("Connecting to ");
//  Serial.println(ssid);
//  WiFi.begin(ssid, password);
//  while (WiFi.status() != WL_CONNECTED) {
//    delay(500);
//    Serial.print(".");
//  }

  // Assegnazione IP statico (da commentare in caso di DHCP)
  WiFi.config(ip, gateway, subnet);

  // Start Server
  WiFi.begin(ssid, password);

  // Avvia il Web server e scrivi sulla seriale i dati di connessione
  Serial.println("");
  Serial.println("WiFi connected.");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  server.begin();
}

Un aspetto fondamentale riguarda la riga “Serial.begin(9600);”, non modificate mai questo valore altrimenti non sarete in grado di poter leggere i dati inviati al monitor seriale (utile anche per il debug dell’applicazione). Un altro aspetto importante invece riguarda il DHCP, ovvero l’assegnazione automatica dell’indirizzo ip. Come avrete già notato la parte relativa al DHCP è commentata perché abbiamo deciso di assegnare manualmente l’indirizzo ip alla scheda wi-fi. Nel caso in cui volessimo l’assegnazione automatica dell’indirizzo ip dovremmo decommentare la parte in questione e commentare sia il blocco successivo ” WiFi.config(ip, gateway, subnet);” che quello di assegnazione dell’indirizzo statico che abbiamo definito sopra, ovvero: “IPAddress ip(192, 168, 1, 100); IPAddress gateway(192, 168, 1, 1); IPAddress subnet(255, 255, 255, 0);”. Seguendo i commenti allo sketch dovreste riuscire a modificare il programma secondo le vostre necessità.

Entriamo ora nel loop() del programma, dove la prima parte riguarda le richieste http da parte dei client.

void loop(){
  WiFiClient client = server.available();   // Listen for incoming clients

  if (client) {                             // If a new client connects,
    Serial.println("Nuovo Client.");        // print a message out in the serial port
    String currentLine = "";                // make a String to hold incoming data from the client
    while (client.connected()) {            // loop while the client's connected
      if (client.available()) {             // if there's bytes to read from the client,
        char c = client.read();             // read a byte, then
        Serial.write(c);                    // print it out the serial monitor
        header += c;
        if (c == '\n') {                    // if the byte is a newline character
          // if the current line is blank, you got two newline characters in a row.
          // that's the end of the client HTTP request, so send a response:
          if (currentLine.length() == 0) {
            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
            // and a content-type so the client knows what's coming, then a blank line:
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println("Connection: close");
            client.println();

Poi si aggiunge la parte relativa al comando dei pin e aggiornamento degli stati delle variabili.

// Accendo/Spengo i due Pin GPIO
            if (header.indexOf("GET /pulsante/on") >= 0) {
              Serial.println("GPIO 13 e 15 on");
              output1State = "on";
              output2State = "on";
              statoPresa = "ACCESA";
              statoLed = "on";
              digitalWrite(output1, LOW);
              digitalWrite(output2, LOW);
              digitalWrite(ledPin, HIGH);
            } else if (header.indexOf("GET /pulsante/off") >= 0) {
              Serial.println("GPIO 13 e 15 off");
              output1State = "off";
              output2State = "off";
              statoPresa = "SPENTA";
              statoLed = "off";
              digitalWrite(output1, HIGH);
              digitalWrite(output2, HIGH);
              digitalWrite(ledPin, LOW);
            }

Leggendo il codice si potrebbe far confusione tra il concetto di LOW (pin allo stato basso), presa ACCESA e relè NORMALMENTE APERTO, l’unico modo per padroneggiare la logica dell’applicazione è quella di fare un po’ di pratica al fine di capire bene il comportamento che desideriamo in base al funzionamento della scheda relè e del microcontrollore. Ad esempio, il fatto che i relè siano inizialmente NO o NC potrebbe essere  indifferente per alcune applicazioni mentre in altre potreste voler tenere il circuito chiuso (NC) per la maggioranza del tempo quindi preferireste adottare una logica in cui si possa mantenere una situazione di “circuito chiuso” in cui la scheda relè non tenga i relè eccitati (in tensione) per dei periodi molto lunghi, o viceversa. Questo programma solo è un esempio, voi potrete modificarlo secondo le vostre esigenze e fare pratica con le diverse variabili in gioco. In questo caso il programma segue una logica per cui, usando i contatti NORMALMENTE APERTI della scheda relè, avrò :

• stato pin LOW –> relè acceso –> presa ACCESA – circuito CHIUSO (vedi foto seguente)
• stato pin HIGH –> relè spento –> presa SPENTA – circuito APERTO

Concludiamo l’ultima parte del programma, ovvero quella che riguarda la parte web. Nella prima parte viene creata l’intestazione della pagina html ed il foglio di stile, di seguito ci sono il titolo, il pulsante per “accendere/spegnere” la presa, poi immediatamente sotto una riga in cui visualizzo lo stato della presa “client.println(“

Presa ” + statoPresa + “

”);” e 3 righe usate come debug che mi dicono lo stato dei 3 pin utilizzati nel programma. Il resto del codice riguarda la chiusura della pagina web e della sessione per il client che si disconnette.

// Pagina Web
            client.println("");
            client.println("");
            client.println("");
            // CSS per lo stile del bottone on/off
            client.println("");
            
            // Titolo pagina
            client.println("
Presa Wireless
");
            
            // Pulsante ccensione/Spegnimento
            if (output1State=="off" && output2State=="off") {
              client.println("
ON
");
            } else {
              client.println("
OFF
");
            } 
            
            // Stato dei pin 13 e 15
            client.println("
Presa " + statoPresa + "
");
            client.println("
");
            client.println("DEBUG:");
            client.println("
GPIO_13 [In-1] - Stato " + output1State + "
");
            client.println("
GPIO_15 [In-2] - Stato " + output2State + "
");
            client.println("
GPIO_12  [Led] - Stato " + statoLed + "
");
            
            // Chiusa body della pagina web
            client.println("");
            
            // The HTTP response ends with another blank line
            client.println();
            // Break out of the while loop
            break;
          } else { // if you got a newline, then clear currentLine
            currentLine = "";
          }
        } else if (c != '\r') {  // if you got anything else but a carriage return character,
          currentLine += c;      // add it to the end of the currentLine
        }
      }
    }
    // Pulisci la variabile Header
    header = "";
    // Chiusura della connessione
    client.stop();
    Serial.println("Client disconnesso.");
    Serial.println("");
  }
}

Compilando e caricando il programma sul microcontrollore potrete finalmente collegarvi alla pagina web e testare l’applicazione. All’inizio dello sketch avevamo impostato l’ip come segue:

• IPAddress ip(192, 168, 1, 100);
• WiFiServer server(80);

Quindi per raggiungere l’interfaccia web basterà essere collegarsi con il vostro PC o smartphone alla stessa rete locale a cui è collegato il microcontrollore, aprire un browser e digitare l’indirizzo https://192.168.1.100 . Nel caso abbiate impostato il DHCP dovrete usare un tool come Angry IP per scansionare la vostra rete e conoscere l’indirizzo del microcontrollore oppure connettervi al monitor seriale dell’IDE di Arduino con il microcontrollore collegato al PC in modo da vedere quale indirizzo viene assegnato (solitamente il DHCP server, tende a dare lo stesso indirizzo per un certo periodo una volta assegnato un ip). Nel caso avessimo deciso di optare per una porta diversa, ad esempio la 8080, il server sarebbe raggiungibile all’indirizzo https://192.168.1.100:8080 .

 

Collegare un carico alla scheda relè

Vediamo infine come poter collegare un carico alla scheda relè. Non è obbligatorio l’uso di tensioni pericolose, potrebbe essere sufficiente controllare lo stato delle uscite con un tester, oppure realizzare un semplice circuito con led e batterie da connettere alle uscite in modo da poter testare il circuito in tutta sicurezza.

Le applicazioni che prevedono l’uso di tensione alternata di 230v devono essere realizzate da personale qualificato e consapevole dei rischi a cui ci si espone. L’accesso alla rete elettrica, a dispositivi elettrici e/o elettronici vi espone a tensioni di voltaggio letale per l’essere umano. Il fine di questo articolo è puramente didattico e divulgativo.

Informatica37.it non si assume nessuna responsabilità riguardante danni a persone e/o cose derivanti dall’esecuzione delle istruzioni riportate in questo articolo, ogni vostra azione sarà sotto la vostra totale responsabilità.

Nel nostro progetto il filo elettrico entra nel morsetto NO ed esce dal COM, questo va fatto sia con il filo di fase (marrone) sul primo relè che col filo di neutro (blu) sul secondo relè, mentre il filo di terra va direttamente dalla spina alla presa in uscita. Come anticipato all’inizio dell’articolo, nel caso si lavori a 230V, l’interruzione di entrambi i fili viene fatta al fine di aumentare la sicurezza del progetto:

Ovviamente la presa singola in figura potrebbe anche essere sostituita da una lampada, un motore, ecc., l’importante è ricordarsi di fare bene attenzione alle massime tensioni e correnti che la scheda relè può sopportare senza danneggiarsi.

Nel video che segue potrete vedere in azione il nostro prototipo.