In questa seconda ed ultima parte del progetto, continuerò a descrivere in modo dettagliato come procedere alla progettazione e implementazione di un sistema di automazione e monitoraggio domestico in maniera economica ma efficace. Nella prima parte del progetto, abbiamo esplorato come procedere in modo corretto al flusso di progettazione del sistema e la selezione dei componenti, come sensori di movimento PIR, sensori di temperatura e umidità, e moduli Wi-Fi. In questo finale di articolo, ci concentreremo sull'implementazione pratica, la configurazione hardware e software, e tratterò i principi base dell'integrazione con piattaforme di domotica come Home Assistant. L'obiettivo è automatizzare l'illuminazione, monitorare le condizioni ambientali e migliorare la sicurezza domestica, consentendo il controllo remoto e una gestione centralizzata. Questo articolo vuole offrire una guida pratica per affrontare la progettazione a costi contenuti di un sistema di smart home, migliorando il comfort e la sicurezza della casa. Seguendo queste indicazioni, avrete le basi per creare una soluzione di domotica personalizzata, sfruttando l'interoperabilità e l'adattabilità di componenti facilmente reperibili come Arduino e Raspberry Pi. Ciò rende qualsivoglia progetto adatto sia per uso professionale che per appassionati di fai-da-te. 

Implementazione

La fase di implementazione di un progetto di automazione domestica intelligente con hardware open source coinvolge la configurazione hardware e lo sviluppo software. In questo paragrafo, vedremo dettagliatamente i vari schemi necessari, ma li analizzeremo uno per uno come fossero singole unità. Lo scopo è quello di avere un prontuario di possibili configurazioni che, unite, possono formare un progetto completo. Come detto, l’articolo non si prefigge di creare un sistema completo, ma un modus operandi per collegare i componenti, scrivere, testare il codice, e integrare il sistema con un modulo Wi-Fi per la comunicazione remota, al fine di poter essere utilizzato come base di partenza per un progetto, il vostro.

Configurazione Hardware

1. II sensore PIR:
   • Sensore di movimento (PIR): posizionare il sensore assicurandosi che sia orientato correttamente per rilevare il movimento nell'area desiderata. Collegare i pin VCC, GND e OUT come descritto nello schema elettrico (Figura 1).

Figura 1: Schema elettrico e dei collegamenti sensore PIR

1. • Sensori di temperatura e umidità (DHT11/DHT22): montare il sensore DHT con i pin VCC, GND e DATA ai rispettivi pin di Arduino (si veda la Figura 2).

Figura 2: Schema elettrico e dei collegamenti sensore di temperatura e umidità

1. • Relè per il controllo delle luci: posizionare il modulo relè e collegare i pin di controllo e alimentazione ad Arduino. Assicurarsi che i contatti COM, NO e NC siano collegati correttamente al circuito delle luci facendo attenzione alla fase ed al neutro. Nell’esempio circuitale che segue (Figura 3 e Figura 4), è stato implementato anche un sensore luci (crepuscolare) ed il sensore PIR già visto. Il circuito è un semplice automatismo che permette di accendere le luci automaticamente, al passaggio nella zona del sensore PIR, quando non vi è la luce ambientale del giorno.

Figura 3: Schema elettrico e dei collegamenti Relè per il controllo delle luci e sensori

Figura 4: Schema elettrico del circuito di Figura 3

1. Collegamento dei componenti ad Arduino nella fase sperimentale:
   • Utilizzare i cavi jumper per collegare i pin dei sensori e degli attuatori ai pin digitali e analogici di Arduino come specificato negli schemi elettrici. Verificare ogni connessione per assicurarsi che i componenti siano collegati correttamente e ricevano l'alimentazione adeguata. Fare attenzione alla corrente alternata della rete, lavorando sempre in sicurezza.
2. Configurazione con un modulo Wi-Fi:
   • Modulo ESP32 NodeMCU: collegare il modulo Wi-Fi agli eventuali interruttori, alla scheda relè e questa ai vari carichi da controllare (luci, appliance in generale) secondo il diagramma dei collegamenti di Figura 5.

Figura 5: Diagramma dei collegamenti tipici di un modulo NodeMCU ESP32 per controllo smart home

1. • Configurazione iniziale: caricare uno sketch di esempio sul modulo ESP32 NodeMCU per configurare la connessione Wi-Fi. Questo passaggio garantisce che il modulo sia correttamente configurato per la comunicazione con la rete domestica.
   • Collegamento a piattaforma IoT: configurare gli automatismi e gli ON/OFF dei vari carichi attraverso una piattaforma IoT come ad esempio Blynk Home Automation.

Sviluppo Software

1. Scrittura del codice per la lettura dei sensori e il controllo degli attuatori:
   • Sensori PIR e relè: scrivere il codice per leggere i dati dai sensori PIR e attivare i relè per accendere o spegnere le luci in base alla presenza rilevata. Nell’esempio di Figura 3 un possibile codice sketch di esempio per Arduino, potrebbe essere il seguente:

float x,y ;
void setup()
{
  pinMode(8, INPUT);
  pinMode(5, OUTPUT);
  pinMode(A5, INPUT);
  Serial.begin(9600);
}

void loop()
{
  x= digitalRead(8);
  y= analogRead(A5);
  Serial.println(x);
  Serial.println(y);
  if((x>0) && (y<550))
  {
               digitalWrite(5, HIGH);
               delay(5000);// Wait for 1000 millisecond(s)
  }
  else
  {
    digitalWrite(5, 0);
  }
}
}

Questo sketch per Arduino legge l'input da due pin (uno digitale e uno analogico) e accende un LED (o un altro dispositivo collegato a un pin di uscita, in questo caso un relè) in base ai valori letti. Vengono utilizzate due variabili globali di tipo float, chiamate x e y, che verranno utilizzate per memorizzare i valori letti dai pin di input.

La funzione setup() viene eseguita una volta quando l'Arduino viene acceso o resettato. Ecco cosa fa il codice:

1. “pinMode(8, INPUT);”: configura il pin digitale 8 come input. Questo pin sarà utilizzato per leggere un valore digitale (0 o 1).
2. “pinMode(5, OUTPUT);”: configura il pin digitale 5 come output. Questo pin sarà utilizzato per controllare un LED o un altro dispositivo.

• “pinMode(A5, INPUT);”: configura il pin analogico A5 come input. Questo pin sarà utilizzato per leggere un valore analogico (compreso tra 0 e 1023).

1. ”Serial.begin(9600);”: inizializza la comunicazione seriale alla velocità di 9600 baud. Questo permette di inviare dati al computer tramite il monitor seriale.

La funzione loop() viene eseguita continuamente in un ciclo infinito dopo che setup() è stata eseguita.

1. “x = digitalRead(8);”: legge il valore dal pin digitale 8 e lo memorizza nella variabile x. Il valore sarà 0 (LOW) o 1 (HIGH).
2. “y = analogRead(A5);”: legge il valore dal pin analogico A5 e lo memorizza nella variabile y. Il valore sarà compreso tra 0 e 1023.

• “Serial.println(x);” e ”Serial.println(y);”: stampano i valori di x e y sulla porta seriale, in modo che possano essere visualizzati nel monitor seriale.

550. ”if ((x > 0) && (y < 550))”: controlla se x è maggiore di 0 (quindi è HIGH) e se y è minore di 550.

Se la condizione è vera:

• ”digitalWrite(5, HIGH);”: imposta il pin digitale 5 su HIGH (accende il LED o attiva il dispositivo collegato).
• ”delay(5000);”: Mantiene il pin 5 su HIGH per 5000 millisecondi (5 secondi).

Se la condizione è falsa:

• ”digitalWrite(5, 0);”: imposta il pin digitale 5 su LOW (spegne il LED o disattiva il dispositivo collegato).

Quindi, in definitiva, questo sketch legge un valore digitale dal pin 8 e un valore analogico dal pin A5. Se il valore digitale è HIGH e il valore analogico è inferiore a 550, accende un dispositivo collegato al pin 5 per 5 secondi. Altrimenti, spegne il dispositivo. Durante ogni ciclo del loop(), i valori letti vengono stampati sulla porta seriale per il monitoraggio.

1. • Sensori DHT: utilizzare la libreria “DHT.h” per leggere i dati di temperatura e umidità dai sensori e visualizzarli ad esempio sul monitor seriale (oppure su un display LCD) o trasmetterli alla piattaforma di domotica. Un semplice sketch di test per il circuito di Figura 2 potrebbe essere il seguente:

// Caricare la libreria DHT
#include "DHT.h"

// Definizione del pin a cui è collegato il sensore
#define DHTPIN A0

// Definizione del tipo di sensore DHT
#define DHTTYPE DHT11

// Inizializzazione dell'oggetto DHT
DHT dht(DHTPIN, DHTTYPE);

void setup() {

// Inizializza la comunicazione seriale
Serial.begin(9600);
  // Stampa sulla serial il messaggio "DHT11 test!" 
Serial.println(F("DHT11 test!"));
// Inizializza il sensore DHT 
 dht.begin();
}
void loop() {
  // Attesa di 1 secondo tra le letture
  delay(1000);
  // Lettura dell'umidità
  float h = dht.readHumidity();
  // Lettura della temperatura in gradi Celsius
  float t = dht.readTemperature();
// Lettura della temperatura in Fahrenheit
  float f = dht.readTemperature(true);
  // Controlla se c'è stato un errore nella lettura del sensore
  if (isnan(h) || isnan(t)) {
    Serial.println(F("Impossibile leggere dal sensore DHT!"));
    return;
  }

// Stampa dei valori letti sulla porta seriale
  Serial.print("Umidità: ");
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperatura: ");
  Serial.print(t);
  Serial.print(" *C ");
  Serial.print(f);
  Serial.print(" *F\t");
  Serial.print("Indice di calore: ");
  Serial.print(hic);
  Serial.print(" *C ");
  Serial.print(hif);
 Serial.println(" *F");
  }

1. Integrazione del modulo Wi-Fi per la comunicazione remota:
   • Connessione alla rete Wi-Fi: scrivere il codice per configurare il modulo ESP8266/ESP32 e connettersi alla rete Wi-Fi. Utilizzare la libreria ESP8266WiFi per gestire la connessione e la comunicazione con la rete.
   • Invio dati alla piattaforma di domotica: implementare il codice per trasmettere i dati raccolti dai sensori alla piattaforma di domotica come Home Assistant o Blynk. Questo include l'invio di notifiche e l'aggiornamento dello stato dei dispositivi in tempo reale.
2. Utilizzo delle librerie per semplificare il codice:
   • Librerie Arduino: utilizzare librerie specifiche come DHT, ESP8266WiFi, e altre necessarie per interfacciarsi con i sensori e moduli. Le librerie semplificano il processo di lettura dei sensori, gestione delle connessioni Wi-Fi e controllo degli attuatori, rendendo il codice più leggibile e manutenibile.
3. Test e debug del codice:
   • Test incrementali: testare il codice in fasi incrementali, verificando prima la lettura dei sensori, poi il controllo degli attuatori, e infine la comunicazione Wi-Fi. Questo approccio aiuta a identificare e risolvere problemi in modo sistematico.
   • Debugging: utilizzare il monitor seriale di Arduino IDE per il debugging. Stampare messaggi di log per monitorare il flusso del programma e identificare eventuali errori o anomalie. Apportare le necessarie correzioni al codice e ripetere i test fino ad ottenere un funzionamento stabile e affidabile del sistema.

Per lo schema di Figura 5 il circuito è molto semplice. Vengono utilizzati come pin di GPIO: D1, D2, D5 e D6 per controllare il modulo relè a 4 canali e i pin: SD3, D3, D7 e RX per collegare gli interruttori per il controllo manuale del modulo relè. Nel codice conviene usare la funzione INPUT_PULLUP nell'IDE di Arduino utile al posto di utilizzare le resistenze pull-up per ciascun interruttore. Quando i pin di controllo del modulo relè ricevono il segnale BASSO, il rispettivo relè si accenderà e viceversa, quando ricevono il segnale ALTO, il rispettivo relè si spegnerà. Una possibile implementazione software potrebbe essere quella implementata sul blog iotcircuithub.com e qui riadattata:

//Librerie utili            
#include <BlynkSimpleEsp8266.h>
#include <AceButton.h>
using namespace ace_button;

// Definizione dei vari pin GPIO per la connessione con la scheda relè e gli interruttori
#define RelayPin1 5  //Out D1 IN1
#define RelayPin2 4  //Out D2 IN2
#define RelayPin3 14 //Out D5 IN3
#define RelayPin4 12 //Out D6 IN4
//Definizione dei vari pin GPIO per la connessione con gli interruttori
#define SwitchPin1 10  //Out SD3 IN S1
#define SwitchPin2 D3   //Out D3 IN S2
#define SwitchPin3 13  //Out D7 IN S3
#define SwitchPin4 3   //Out RX IN S4
// Direttiva wifiLed per definire una costante simbolica che rappresenta il pin 16 corrispondente a // D0
#define wifiLed   16   //D0
// Modificare i pin virtuali in base alle stanze
#define VPIN_BUTTON_1    V5
#define VPIN_BUTTON_2    V6
#define VPIN_BUTTON_3    V7
#define VPIN_BUTTON_4    V8
int toggleState_1 = 1; // Definire un numero intero per ricordare lo stato di attivazione del relè 1
int toggleState_2 = 1; // Definire un numero intero per ricordare lo stato di attivazione del relè 2
int toggleState_3 = 1; // Definire un numero intero per ricordare lo stato di attivazione del relè 3
int toggleState_4 = 1; // Definire un numero intero per ricordare lo stato di attivazione del relè 4
// Flag per tenere conto dello stato della connessione WiFi
int wifiFlag = 0;
// Uso della libreria AceButton per configurare e gestire facilmente i pulsanti,
ButtonConfig config1;
AceButton button1(&config1);
ButtonConfig config2;
AceButton button2(&config2);
ButtonConfig config3;
AceButton button3(&config3);
ButtonConfig config4;
AceButton button4(&config4);
// Funzioni di gestione di eventi per i pulsanti
void handleEvent1(AceButton*, uint8_t, uint8_t);
void handleEvent2(AceButton*, uint8_t, uint8_t);
void handleEvent3(AceButton*, uint8_t, uint8_t);
void handleEvent4(AceButton*, uint8_t, uint8_t);
#define AUTH "AUTH TOKEN"                 // Inserire il token di autorizzazione nell'applicazione Blynk.  
#define WIFI_SSID "WIFI NAME"             //Inserire il Wifi Name
#define WIFI_PASS "WIFI PASSWORD"         //Inserire la Password Wifi
BlynkTimer timer;
// Commutazione dello stato, quando si preme il pulsante dell'app Blynk
BLYNK_WRITE(VPIN_BUTTON_1) {
  toggleState_1 = param.asInt();
  digitalWrite(RelayPin1, toggleState_1);
}
BLYNK_WRITE(VPIN_BUTTON_2) {
  toggleState_2 = param.asInt();
  digitalWrite(RelayPin2, toggleState_2);
}
BLYNK_WRITE(VPIN_BUTTON_3) {
  toggleState_3 = param.asInt();
  digitalWrite(RelayPin3, toggleState_3);
}
BLYNK_WRITE(VPIN_BUTTON_4) {
  toggleState_4 = param.asInt();
  digitalWrite(RelayPin4, toggleState_4);
}
void checkBlynkStatus() { // chiamata ogni 3 secondi da SimpleTimer
  bool isconnected = Blynk.connected();
  if (isconnected == false) {
    wifiFlag = 1;
    Serial.println("Blynk Not Connected");
  }
  if (isconnected == true) {
    wifiFlag = 0;
    Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
    Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
    Blynk.virtualWrite(VPIN_BUTTON_3, toggleState_3);
    Blynk.virtualWrite(VPIN_BUTTON_4, toggleState_4);
    Serial.println("Blynk Connected");
  }
}
void setup()
{
  Serial.begin(9600);
  pinMode(RelayPin1, OUTPUT);
  pinMode(RelayPin2, OUTPUT);
  pinMode(RelayPin3, OUTPUT);
  pinMode(RelayPin4, OUTPUT);
  pinMode(wifiLed, OUTPUT);
  pinMode(SwitchPin1, INPUT_PULLUP);
  pinMode(SwitchPin2, INPUT_PULLUP);
  pinMode(SwitchPin3, INPUT_PULLUP);
  pinMode(SwitchPin4, INPUT_PULLUP);
  //During Starting all Relays should TURN OFF
  digitalWrite(RelayPin1, toggleState_1);
  digitalWrite(RelayPin2, toggleState_2);
  digitalWrite(RelayPin3, toggleState_3);
  digitalWrite(RelayPin4, toggleState_4);
  digitalWrite(wifiLed, HIGH);
  config1.setEventHandler(button1Handler);
  config2.setEventHandler(button2Handler);
  config3.setEventHandler(button3Handler);
  config4.setEventHandler(button4Handler);

  button1.init(SwitchPin1);
  button2.init(SwitchPin2);
  button3.init(SwitchPin3);
  button4.init(SwitchPin4);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
// Controlla se il server Blynk è connesso ogni 3 secondi  
timer.setInterval(3000L, checkBlynkStatus);
  Blynk.config(AUTH);
  delay(1000);
  Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
  Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
  Blynk.virtualWrite(VPIN_BUTTON_3, toggleState_3);
  Blynk.virtualWrite(VPIN_BUTTON_4, toggleState_4);
}

void loop()
{  
  if (WiFi.status() != WL_CONNECTED)
  {
    //Serial.println("WiFi Non connesso");
    digitalWrite(wifiLed, HIGH);
  }
  else
  {
    //+Serial.println("WiFi Connesso");
    digitalWrite(wifiLed, LOW); //Accendi il LED WiFi
    Blynk.run();
  }
  timer.run(); // Avvia SimpleTimer
  button1.check();
  button2.check();
  button3.check();
  button4.check();
}
void button1Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT1");
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      toggleState_1 = 0;
     
// Widget del pulsante 1
Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
      digitalWrite(RelayPin1, LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      toggleState_1 = 1;
      Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
      digitalWrite(RelayPin1, HIGH);
      break;
  }
}
void button2Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT2");
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      toggleState_2 = 0;
      // Widget del pulsante 2
      Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
      digitalWrite(RelayPin2, LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      toggleState_2 = 1;
      Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
      digitalWrite(RelayPin2, HIGH);
      break;
  }
}
void button3Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT3");
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      toggleState_3 = 0;
      Blynk.virtualWrite(VPIN_BUTTON_3, toggleState_3);
      digitalWrite(RelayPin3, LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      toggleState_3 = 1;
      // Widget del pulsante 3
      Blynk.virtualWrite(VPIN_BUTTON_3, toggleState_3);
      digitalWrite(RelayPin3, HIGH);
      break;
  }
}
void button4Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) {
  Serial.println("EVENT4");
  switch (eventType) {
    case AceButton::kEventPressed:
      Serial.println("kEventPressed");
      toggleState_4 = 0;
      // Widget del pulsante 4
      Blynk.virtualWrite(VPIN_BUTTON_4, toggleState_4);
      digitalWrite(RelayPin4, LOW);
      break;
    case AceButton::kEventReleased:
      Serial.println("kEventReleased");
      toggleState_4 = 1;
      Blynk.virtualWrite(VPIN_BUTTON_4, toggleState_4);
      digitalWrite(RelayPin4, HIGH);
      break;
  }
}

ATTENZIONE: quello che hai appena letto è solo un estratto, l'Articolo Tecnico completo è composto da ben 6406 parole ed è riservato agli ABBONATI. Con l'Abbonamento avrai anche accesso a tutti gli altri Articoli Tecnici che potrai leggere in formato PDF per un anno. ABBONATI ORA, è semplice e sicuro.

Ti potrebbe interessare anche:

Codec audio/video: cosa c’è da sapere per usarli al meglio

Sensori per sistemi embedded – Parte 1

Progetto di un estensore wireless di posto interno citofonico

Le FPGA in virgola mobile nelle applicazioni radar

Intelligenza Artificiale con Arduino

Blockchain per l’Energy Industry