Gestiamo carichi tramite relé, da remoto utilizzando uno smartphone, tablet o PC connesso in rete in cui è installato un Web Server.
Di solito, si parla della domotica come di un insieme di sistemi elettromeccanici automatizzati che nell’ambiente domestico consentono di migliorare la qualità della vita degli occupanti, eliminando quanto più possibile l’intervento umano; ma in realtà c’è qualcosa di più, perché la domotica comprende forme selezionate di intelligenza, rete domestica e/o rete distribuita centralizzata, logica o unità di controllo specifica. Il sistema più semplice di domotica si basa su un approccio in cui la funzionalità è cablata e integrata nel sistema e non può essere modificata automaticamente senza l’intervento di un tecnico esperto. La tecnologia dei sensori moderni, con l’evoluzione delle soluzioni wireless, espande le possibilità di rilevamento collegando le reti di comunicazione e il mondo fisico e consentendo applicazioni domotiche ad ampio raggio.
Per introdurvi alla comprensione delle potenzialità dei sistemi di controllo nell’automazione domestica, in questo articolo proponiamo un semplice progetto pratico di controllo di relé da remoto mediante un web server.
Il progetto
L’obiettivo del nostro progetto è dimostrare come sia relativamente semplice controllare uno o più moduli relé da remoto utilizzando uno smartphone, tablet o PC connessi in rete in cui è installato un web server. I relé possono essere impiegati per l’attivazione e disattivazione a distanza di carichi elettrici come lampade, prese elettriche, attuatori in genere, ecc. Il circuito prevede l’impiego della scheda di sviluppo ESP32 NodeMCU (Fig. 1) e di un set di 5 relé controllati dall’ESP32 mediante le uscite digitali GPIO02, GPIO26, GPIO27, GPIO25 e GPIO33 collegate rispettivamente agli ingressi dei relé IN1, IN2, IN3,IN4 e IN5.
Nella Fig. 2 vedete lo schema a blocchi di principio del controllore a relé che implementeremo, mentre nella Fig. 3 proponiamo il relativo schema di cablaggio, ossia quello del sistema al completo, con tanto di scheda relé ad 8 canali.
La ESP32 NodeMCU
La scheda di sviluppo ESP32 NodeMCU è una piattaforma IoT basata sul modulo ESP-WROOM-32 della Espressif Systems; nella Fig. 4 ne vedete la pin-out. L’ESP-WROOM-32 è un potente microcontrollore WiFi e Bluetooth BLE 4.2 che può essere utilizzato in un’ampio range di applicazioni che può spaziare dalle reti di sensori a bassa potenza fino ad impieghi più impegnativi come la codifica vocale, streaming audio e decodifica MP3. Nel modulo è integrato il chip ESP32-D0WD che appartiene alla serie di chip ESP32. Il chip embedded è progettato per essere scalabile e adattivo.
Ci sono due core della CPU che possono essere controllati individualmente; la frequenza di clock della CPU è regolabile da 80 MHz a 240 MHz. È anche possibile spegnere la CPU e utilizzare il coprocessore a bassa potenza per monitorare costantemente le periferiche allo scopo rilevare eventuali modifiche. L’ ESP32 integra un ricco set di periferiche che comprendono: sensori tattili capacitivi, sensori ad effetto di Hall, SD-Card, interfaccia della scheda, Ethernet, SPI ad alta velocità, UART, I²S e I²C.
Connettività e caratteristiche del modulo
L’integrazione del Bluetooth, Bluetooth LE e WiFi, garantisce un’ampia gamma di applicazioni. L’utilizzo del WiFi consente un’ampia portata e una connessione diretta a Internet tramite un router WiFi, mentre l’utilizzo del Bluetooth consente all’utente di connettersi comodamente al telefono o di trasmettere a bassa energia per consentirne la rilevazione da altri dispositivi Bluetooth. La corrente di sleep del chip ESP32 è inferiore a 5 µA, il che lo rende adatto nelle applicazioni elettroniche alimentate a batteria e nei dispositivi indossabili.
Il modulo supporta una velocità di trasmissione dati fino a 150 Mbps, e ha una potenza di uscita di 20 dBm in antenna, garantendo un’ampia portata al segnale RF. Il modulo si dimostra altamente idoneo nelle applicazioni IoT offrendo specifiche avanzate e le migliori prestazioni per l’integrazione elettronica, portata, consumo energetico e connettività. Il sistema operativo scelto per l’ESP32 è freeRTOS con accelerazione hardware integrata. Supporta anche l’aggiornamento sicuro (crittografato) via OTA (Over The Air), in modo che gli utenti possano aggiornare i propri prodotti anche dopo l’installazione, con il minimo costo e dispendio di tempo ed energie.
Specifiche tecniche e programmazione della scheda
Nella Fig. 5 è riportato lo schema a blocchi del modulo ESP32. La scheda di sviluppo ESP32 NodeMCU, essendo dotata di connettore micro USB, è programmabile tramite cavo di collegamento al PC (USB-A/micro USB-B) attraverso il quale avviene anche la programmazione. Riguardo alla connettività, è compatibile con i protocolli WLAN 802.11 b / g / n e Bluetooth 4.2 / BLE.
La CPU è una dual-core a 32 bit Tensilica L108 da 160 MHz, 512 kB SRAM e 16 MB di memoria Flash. Dispone di 32 pin I / O digitali (livelli logici a 3,3 V), 6 pin analogici-digitali e varie interfacce di comunicazioni: 3 UART, 2 porte SPI, 2 interfacce I²C e un’interfaccia da USB a UART mediante il chip CP2102 integrato nella scheda. La scheda di sviluppo ESP32 NodeMCU può essere programmata tramite codice Arduino, Lua, MicroPython. Nella tabella di Tabella 1 sono elencate le specifiche tecniche della scheda ESP32 NodeMCU.
Il Modulo relé
In questo progetto vengono utilizzati 5 relé; per praticità questi relé possono essere ripartiti su schede a relé attivabili con livelli logici TTL tipo quelle per Arduino, quindi più schede a due relé come quella proposta in Fig. 6, una a 4 relé più una a 2 relé, ovvero una ad 8 relé.
Queste schede hanno tipicamente un linea di alimentazione comune a 5Vcc e gli ingressi di comando facenti capo ciascuno alla base (con l’interposizione di una resistenza di limitazione) di un transistor NPN connesso a emettitore comune, con il collettore che pilota la bobina di un relé.
Come funziona il modulo relé
Per effetto di tale configurazione, quando si porta un ingresso a livello logico alto il rispettivo transistor va in saturazione e porta praticamente a massa la bobina del relé, che avendo il capo opposto collegato all’alimentazione eccita il relé stesso muovendone l’equipaggio mobile e collegando insieme il contatto Normalmente Aperto (NA o NO) ed il comune (C).
Sul lato vicino ai relé ci sono le morsettiere a tre morsetti (sezione di alta tensione fino a 250 VAC) per ciascun relé per il collegamento di carichi elettrici: Comune (COM), Normalmente Chiuso (NC), Normalmente Aperto (NO); sul lato opposto si trovano pin per l’alimentazione dei relé e il comando di attivazione e disattivazione di ogni relé (ingressi). Usualmente al morsetto COM (comune, altrimenti indicato con C) si collega uno dei due conduttori della sorgente di alimentazione del carico che si desidera controllare (ad esempio, uno dei due conduttori della tensione di rete) interrompendolo; il pezzo di cavo che va al carico si collega invece al morsetto NC o NO (NA), a seconda dell’applicazione.
Configurazioni NC e NO
Il morsetto NC (Normalmente Chiuso) viene utilizzato quando si desidera che il relé sia chiuso a riposo. In questa modalità, NC e COM sono collegati, ovvero, il conduttore della sorgente di alimentazione è in comune con NC. Viceversa, NO (Normalmente aperto) non è connesso a COM, quindi il conduttore della sorgente di alimentazione connesso al COM non è in comune con NO. Ogni modulo dispone di un LED di stato per ciascun canale (alimentato in parallelo alla bobina del relativo relé) la cui accensione indica l’attivazione di ciascun relé. Spesso le schede a relé hanno gli input optoisolati, ossia accoppiati alle basi dei transistor mediante un fotoaccoppiatore; in questo caso con un livello LOW applicato all’ingresso IN1, il LED del fotoaccoppiatore andrà in conduzione, si accenderà il LED di stato del rispettivo canale e andrà in conduzione il transistor interno al fotoaccoppiatore, mandando in saturazione il transitor che attiverà il relé.
Disponendo dell’intero scambio per ciascun relé si possono prospettare i seguenti scenari:
- Configurazione normalmente chiusa (NC): con segnale d’ingresso a livello logico alto la corrente scorre fra COM e NC del relé, mentre quando l’ingresso è a livello basso la corrente viene interrotta;
- Configurazione normalmente aperta (NO): con segnale d’ingresso a livello alto il relé è a riposo e la corrente viene interrotta, mentre con ingresso a zero logico la corrente scorre fra COM e NO.
Esistono anche schede a relé che prevedono due linee di alimentazione: una per la logica di comando e l’altra per le bobine dei relé; dispongono, allo scopo, di un ponticello per scegliere a cosa collegare l’alimentazione delle bobine, ossia se ai 5V della logica o all’apposito contatto. Quest’ultima configurazione si utilizza per isolare elettricamente il relé dal circuito di comando (l’ESP32, nel nostro caso).
Programmazione dell’ESP32
Esaurita la descrizione dell’hardware del progetto, passiamo all’aspetto software: per programmare la scheda ESP32 occorre innanzitutto installare il driver che consente la comunicazione della scheda con il PC attraverso l’USB; allo scopo, il microcontrollore ESP32 utilizza il chip CP2102 per l’interfacciamento seriale USB al PC.
Collegate la scheda ESP32 al computer tramite un cavo USB-micro USB. Se il sistema operativo del computer non riconosce automaticamente il chip CP2102, occorre scaricare il driver dal sito web http://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers e decomprimilo. Su Windows, è sufficiente installarlo eseguendo “CP210xVCPInstaller_x86.exe” o “CP210xVCPInstaller_x64.exe”, a seconda del sistema operativo a 32 o 64 bit; per Mac, si installa il file DMG nell’archivio caricato. Per i sistemi operativi windows XP e Vista occorre installare il driver dal sito https://www.silabs.com/community/interface/knowledge-base.entry.html/2017/01/10/legacy_os_softwarea-bgvU .
Dopo aver scollegato e ricollegato la scheda ESP32, nell’elenco delle periferiche di comunicazione in Windows, dovrebbe apparire una porta COM identificabile come “Silicon Labs CP210x da USB a UART Bridge”.
Installazione della scheda ESP32 nell’IDE Arduino
Il prossimo step è l’installazione del software Arduino dal sito ufficiale www.arduino.cc (in questo articolo facciamo riferimento alla versione software Arduino 1.8.9). All’avvio del programma, dall’IDE di Arduino occorre installare la scheda ESP32. Da File > Impostazioni, alla voce “URL aggiuntive per il Gestore schede” inserire il link https://dl.espressif.com/dl/package_esp32_index.json.
Poi, con Strumenti > Scheda > Gestore Schede, digitare “esp32” nella barra di ricerca; selezionate e installate il firmware di gestione della scheda ESP32 “ESP 32 by Espressif Sistems“. Si visualizzerà un’immagine come quella proposta dalla Fig. 7. Completata l’installazione della scheda ESP32, da Strumenti > Scheda, selezionate la scheda “ ESP32 Dev Module” o equivalente, poi la velocità di upload di 115200, infine, selezionate la porta COM (su Windows) o ttyUSB (su Mac) corrispondente al driver CP210x USB to UART Bridge VCP. Al fine di verificare il funzionamento della scheda ESP32, la testeremo con uno sketch di esempio.
Test della connessione WiFi
Dall’IDE di Arduino, con File -> Esempi -> WiFi -> WiFiscan, si aprirà un nuovo sketch denominato WiFiscan. Caricate il codice nella scheda ESP32NodeMCU cliccando sul pulsante “->“ (Carica). Al termine della complilazione e del caricamento del codice, aprite il monitor seriale di Arduino e impostatelo alla velocità di trasmissione di 115200 sulla COM corrispondente: nella schermata vedrete qualcosa di simile a quel che è riportato nella Fig. 8.
Verificata con successo l’esecuzione del programma di esempio WiFiscan, abbiamo la certezza che la scheda ESP32 funziona correttamente, quindi si può procedere con il software del controllore relé. In questo progetto viene realizzato un web server che consente di controllare 5 relé mediante uno smartphone, tablet o un Personal Computer. Modificando alcune righe del codice del web server è possibile definire il numero di relé che si desidera controllare e l’assegnazione dei relativi pin di controllo.
Installazione del WebServer
Per realizzare il web server utilizziamo la libreria ESPAsyncWebServer che installeremo seguendo i seguenti step: prima di tutto, scarichiamo dal sito https://github.com/me-no-dev/ESPAsyncWebServer la libreria ESPAsyncWebServer.zip e copiamola in una cartella. Nell’IDE Arduino, con Sketch -> #include libreria -> Aggiungi libreria da file .ZIP, selezionate la libreria ESPAsyncWebServer.zip che avete scaricato e copiato in una cartella.
Installazione della libreria TCP Async per ESP32
La libreria ESPAsyncWebServer richiede la libreria AsyncTCP che installeremo seguendo i seguenti step: scarichiamo dal sito https://github.com/me-no-dev/AsyncTCP la libreria AsyncTCP.zip e copiamola in una cartella. Nell’IDE Arduino, con Sketch -> #include libreria -> Aggiungi libreria da file .ZIP, seleziona la libreria AsyncTCP.zip che avete scaricato e copiato in una cartella.
Nel Listato 1 viene riportato del codice del controllore relé.
Listato 1
/*********
Rui Santos
Complete
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*********/
// Import required libraries
#include "WiFi.h"
#include "ESPAsyncWebServer.h"
// Set to true to define Relay as Normally Open (NO)
#define RELAY_NO true
// Set number of relays
#define NUM_RELAYS 5
// Assign each GPIO to a relay
int relayGPIOs[NUM_RELAYS] = {2, 26, 27, 25, 33};
// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
const char* PARAM_INPUT_1 = "relay";
const char* PARAM_INPUT_2 = "state";
// Create AsyncWebServer object on port 80
AsyncWebServer server(80);
const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
html {font-family: Arial; display: inline-block; text-align: center;}
h2 {font-size: 3.0rem;}
p {font-size: 3.0rem;}
body {max-width: 600px; margin:0px auto; padding-bottom: 25px;}
.switch {position: relative; display: inline-block; width: 120px; height: 68px}
.switch input {display: none}
slider {position: absolute; top: 0; left: 0; right: 0; bottom: 0; background-color: #ccc; border-radius: 34px}
.slider:before {position: absolute; content: ""; height: 52px; width: 52px; left: 8px; bottom: 8px; background-color: #fff; -webkit-transition: .4s; transition: .4s; border-radius: 68px}
input:checked+.slider {background-color: #2196F3}
input:checked+.slider:before {-webkit-transform: translateX(52px); -ms-transform: translateX(52px); transform: translateX(52px)}
</style>
</head>
<body>
<h2>ESP Web Server</h2>
%BUTTONPLACEHOLDER%
<script>function toggleCheckbox(element) {
var xhr = new XMLHttpRequest();
if(element.checked){ xhr.open("GET", "/update?relay="+element.id+"&state=1", true); }
else { xhr.open("GET", "/update?relay="+element.id+"&state=0", true); }
xhr.send();
}</script>
</body>
</html>
)rawliteral";
// Replaces placeholder with button section in your web page
String processor(const String& var){
//Serial.println(var);
if(var == "BUTTONPLACEHOLDER"){
String buttons ="";
for(int i=1; i<=NUM_RELAYS; i++){
String relayStateValue = relayState(i);
buttons+= "<h4>Relay #" + String(i) + " - GPIO " + relayGPIOs[i-1] + "</h4><label class=\"switch\"><input type=\"checkbox\" onchange=\"toggleCheckbox(this)\" id=\"" + String(i) + "\" "+ relayStateValue +"><span class=\"slider\"></span></label>";
}
return buttons;
}
return String();
}
String relayState(int numRelay){
if(RELAY_NO){
if(digitalRead(relayGPIOs[numRelay-1])){
return "";
}
else {
return "checked";
}
}
else {
if(digitalRead(relayGPIOs[numRelay-1])){
return "checked";
}
else {
return "";
}
}
return "";
}
void setup(){
// Serial port for debugging purposes
Serial.begin(115200);
// Set all relays to off when the program starts - if set to Normally Open (NO), the relay is off when you set the relay to HIGH
for(int i=1; i<=NUM_RELAYS; i++){
pinMode(relayGPIOs[i-1], OUTPUT);
if(RELAY_NO){
digitalWrite(relayGPIOs[i-1], HIGH);
}
else{
digitalWrite(relayGPIOs[i-1], LOW);
}
}
// Connect to Wi-Fi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi..");
}
// Print ESP32 Local IP Address
Serial.println(WiFi.localIP());
// Route for root / web page
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/html", index_html, processor);
});
// Send a GET request to <ESP_IP>/update?relay=<inputMessage>&state=<inputMessage2>
server.on("/update", HTTP_GET, [] (AsyncWebServerRequest *request) {
String inputMessage;
String inputParam;
String inputMessage2;
String inputParam2;
// GET input1 value on <ESP_IP>/update?relay=<inputMessage>
if (request->hasParam(PARAM_INPUT_1) & request->hasParam(PARAM_INPUT_2)) {
inputMessage = request->getParam(PARAM_INPUT_1)->value();
inputParam = PARAM_INPUT_1;
inputMessage2 = request->getParam(PARAM_INPUT_2)->value();
inputParam2 = PARAM_INPUT_2;
if(RELAY_NO){
Serial.print("NO ");
digitalWrite(relayGPIOs[inputMessage.toInt()-1], !inputMessage2.toInt());
}
else{
Serial.print("NC ");
digitalWrite(relayGPIOs[inputMessage.toInt()-1], inputMessage2.toInt());
}
}
else {
inputMessage = "No message sent";
inputParam = "none";
}
Serial.println(inputMessage + inputMessage2);
request->send(200, "text/plain", "OK");
});
// Start server
server.begin();
}
void loop() {
}Personalizzazione del software
È possibile impostare la configurazione dei relé nella modalità normalmente aperto (NO) o normalmente chiuso (NC) mediante la modifica della variabile “#define RELAY_NO true“: true per NO, false per NC. Modificando la variabile “#define NUM_RELAYS 5”, si può definire il numero di relé che si vogliono inserire nel progetto.
Ovviamente, il numero di relé impostato dalla variabile NUM_RELAYS deve corrispondere al numero di GPIO assegnate nell’array relayGPIOs, infatti, con la variabile array “int relayGPIOs [NUM_RELAYS] = {2, 26, 27, 25, 33};” è possibile definire le porte digitali di controllo relé GPIO dell’ESP32. Infine, occorre inserire le credenziali della rete WiFi nelle seguenti variabili:
const char * ssid = "REPLACE_WITH_YOUR_SSID"; const char * password = "REPLACE_WITH_YOUR_PASSWORD";
Dopo aver installato le librerie richieste e inserite nel codice le modifiche software desiderate, copiate il codice in un nuovo sketch e caricatelo nella scheda ESP32.
Realizzazione pratica
A questo punto, installato tutto il software necessario, si può procedere con il montaggio dei componenti del prototipo del controllore relé, ossia, la scheda ESP32, cinque relé, alcuni jumper e una breadboard sperimentale, seguendo i collegamenti dello schema di cablaggio proposto nella Fig. 3.
Per l’alimentazione del circuito è consigliabile non utilizzare le porte USB del PC, quindi il prototipo può essere alimentato collegando al connettore micro USB della scheda un alimentatore esterno con tensione di 5V, oppure collegando un alimentatore esterno con tensione da 7 a 12 V ai pin 5V (Vin) e GND della scheda; in ambedue i casi, l’alimentatore esterno deve poter erogare una corrente di almeno 150 mA.
Attenzione che la scheda ESP32 deve essere alimentata da una sola delle tensioni succitate. L’utilizzo contemporaneo di più di un’alimentazione potrebbe danneggiare irreparabilmente la scheda e gli alimentatori corrispondenti.
Test del sistema
Aprite il monitor seriale impostato ad un baud rate di 115200 e premete il pulsante RESET. Sul monitor si potrà rilevare l’indirizzo IP della scheda ESP32 che annoterete.
Ora, aprite un browser in un dispositivo connesso alla rete locale WiFi e digitate l’indirizzo IP dell’ESP32 precedentemente annotato per accedere al web server.
Se tutto è stato eseguito correttamente, sul display del dispositivo mobile o sul monitor del PC dovrebbero apparire dei pulsanti in numero corrispondente al numero di relé definito nel codice (Fig. 9). Bene, con questo abbiamo terminato.
