TESINA • ARDUINO • DOMOTICA • STAMPA 3D

Casa domotica stampata in 3D con Arduino

Progetto realizzato per l’Esame di Stato 2017: una casa in scala 1:24 controllabile via rete, con sistema di allarme, sensori, RFID, display LCD, web server e streaming video.

⚙️ Livello: avanzato🧠 Arduino, Ethernet, RFID e sensori🖨️ Struttura stampata in 3D

Cosa troverai in questa guida

Casa domotica completaStruttura 3D, illuminazione, sensori e attuatori.
Tre sistemi ArduinoAntifurto RFID, web server Ethernet e streaming con Arduino Yún.
Codice e fileSketch, librerie ZIP, schemi e fotografie originali.
Matrice0
 
Candidato: Fancello Salvatore
Classe: 5^ Elettronica 
Anno scolastico 2016/2017

​

Arduino e Stampa 3D

20170615 111356

​La Casa Domotica in miniatura è nata nei tre anni di corso di studio all’istituto d’istruzione superiore ITI A. Monaco di Cosenza, dove si sono susseguiti vari progetti di domotica utilizzando la programmazione su Arduino Uno.
 
Lo scopo del progetto è di realizzare un Casa controllabile interamente da smartphone, PC, o qualunque dispositivo che abbia un browser e sia collegato nella stessa rete in modo tale da agevolare e migliorare le condizioni di vivibilità dell’appartamento.
 
Il progetto che ho portato per l’Esame di Maturità è un prototipo di sistema domotico stampato in 3D di una Casa in scala 1:24.
20170615 112033

Funzioni
Oltre al controllo remoto dei dispositivi tramite Web Server è integrato un sistema di allarme domestico che si attiva/disattiva tramite la lettura di una tessera con codice tag e visualizzazione su un display LCD dello stato dei vari sensori, tra cui:
  • Sensore PIR per rilevare la presenza di movimento in casa se l’allarme è attivo
  • Sensore Gas MQ-02 per rilevare la fuoriuscita involontaria di gas combustibile, metano, propano o fumo.
  • Sensore di Fiamma per rilevare la presenza di fuoco in caso di incendio.
Infine con il controllo remoto della casa tramite streaming video possiamo vedere in tempo reale cosa avviene dentro la casa.

Materiali e componenti utilizzati
Componenti Utilizzati:
​
  • 2x Filamento per Stampa 3D 1Kg
  • Pannello Multistrato di pioppo 18mm 70×60
  • Tappetino verde prato 100x50cm
  • Servomotore Parallax Rotazione Continua
  • Arduino YUN Orig
  • Webcam Logitech E3500
  • MicroSD 8Gb Samsung
  • Router Digicom 150 
  • Arduino Mega 2560
  • Ethernet Shield W5100
  • Arduino UNO
  • Display LCD 16×2 I2C
  • Lettore di tessere tag RFID RC522
  • Sensore Fiamma
  • Sensore Gas ​MQ-02
  • Sensore PIR
  • Buzzer
  • Ventola 
  • 7x Diodi LED Bianchi 5mm
  • 2x Diodi LED Gialli 5mm
  • Diodi LED Rossi 5mm
  • 10x Resistenze da 220Ω
  • Breadboard
  • Kit cavetti di collegamento 
  • Cavo ethernet
  • PowerBank AUKEY 20000mAh

🧰 Non hai ancora i componenti?
Molti dei progetti presenti su progettiarduino.com utilizzano componenti elettronici di base come LED, resistenze, sensori e breadboard.
Se stai iniziando con Arduino, il modo più semplice è utilizzare un kit completo per principianti, che include quasi tutti i componenti necessari per realizzare molti dei progetti presenti sul sito.

👉 Kit Arduino consigliato:
ℹ️ Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
https://amzn.to/4b3dxjW

📘 Vuoi imparare Arduino passo dopo passo?
Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino.
All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.

👉 Scopri i miei libri su Arduino:
ℹ️ Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
https://amzn.to/4rfzjXE

Creazione della struttura in 3D
Il plastico è interamente realizzato con stampante 3D, la base è di multistrato di pioppo largo 70×60 cm e con spessore di 18mm così da rendere l’intera struttura leggera ma allo stesso tempo resistente.
Inizialmente è stato necessario realizzare la piantina della casa su AutoCAD per poi prendere le misure, riportarle alle dimensioni reali e suddividerle in più parti in quanto il piatto di stampa riesce a riprodurre oggetti con dimensioni max 200x200mm.
 
Tutti i componenti della Casa Domotica sono stati realizzati in 3D tramite il software gratuito Tinkercad che è il punto di partenza per chi vuole iniziare a creare oggetti semplici da stampare in 3D ed esportarli nel formato di file .STL compatibili con tutti i software di stampa.

Tinkercad
Inoltre tutti i file di stampa .STL li ho resi pubblici sul sito Thingiverse all’indirizzo: https://www.thingiverse.com/thing:2364628
​

Thingiverse è un sito gratuito dove vengono condivisi tutti i progetti di stampa 3D.
Rendendolo pubblico chiunque può riprodurre facilmente il progetto, apportare delle modifiche e crearsi il proprio prototipo di casa domotica.

Stampa 3D
Successivamente alla creazione dei modelli 3D si passa alla stampa dove ho trascorso la maggior parte del tempo dedicato al progetto.
 
I modelli in formato .STL vengono infine caricati su un software che effettua la divisione in strati dell’oggetto da stampare (slicing).
Repetier Host

Il software Repetier-Host gestisce la stampante collegata tramite la porta USB del PC permettendo di regolare autonomamente il riempimento interno dell’oggetto, la temperatura dell’estrusore di stampa, la velocità, lo spostamento degli assi e molto altro.
​
La stampante che ho utilizzato è la GEEETech I3 ProB, economica ma con a bordo una scheda Arduino Mega 2560 anch’essa con software Open-Source, il che mi permetteranno in futuro di effettuare alcune modifiche per migliorare la qualità di stampa complessiva. ​
Nota: il video originale era incorporato tramite il vecchio player Weebly e non è più disponibile come embed. Le immagini e le istruzioni del progetto restano consultabili.

Assemblaggio
Le pareti sono larghe 8mm con ai lati degli incastri per facilitare l’assemblaggio e l’incollaggio con colla ciano-acrilica in modo da formare tutte le stanze presenti nella piantina.
A quel punto si avranno tutti gli spazi della casa pronti.
20170505 151201 Ritagliata

Una volta assemblati i vari componenti della casa domotica si procede con il passo successivo, cioè inserire i supporti a T e ad L in modo da rendere le pareti più stabili, dove andremo successivamente ad inserire i circuiti d’illuminazione e installare i dispositivi di controllo.
20170504 152944

Il passaggio successivo è l’inserimento dell’impianto di illuminazione, ho forato i muri in modo da inserire i diodi LED e lasciarli ben visibili, nascondendo i fili che fuoriuscivano dal retro della parete con una canalina creata con la stampante 3D.
20170511 133258
20170511 134139

​Il cancello posto sul lato anteriore della casa è fatto muovere grazie ad un servomotore a rotazione continua. L’ingranaggio sul servo è tenuto saldamente da una vite, ed è fatto ruotare su un asta a cremagliera.
20170508 075300

​Il display LCD e il lettore di card sono inseriti in due appositi alloggiamenti posti uno sull’altro per consentire una facile lettura quando si passa la card o il portachiavi sul lettore.

Il display consente di monitorare lo stato dei sensori di Gas, Fiamma e si rende necessario per visualizzare lo stato del Sistema Anti-intrusione.
20170601 150132

Per finire ho portato tutti i cavi sul retro della casa dove ho alloggiato le schede Arduino il router e una breadbord.
​I fili sono nascosti sotto un tappetino verde che simula l’erba del giardino 
e per renderli facilmente individuabili li ho etichettati in modo da agevolare un prossimo upgrade del progetto.
20170615 112341

Schema del circuito completo
Schema Del Circuito

Prima Parte del programma: Sistema di Allarme Domestico
La prima parte dello sketch (programma) è installato sulla scheda Arduino UNO. Questo sistema elettronico rappresenta un allarme domestico economico ma funzionale.
Sistema Di Allarme Tesina Bb
E’ una semplice centrale a una zona nel mio caso perché ho un solo PIR a disposizione, ma ovviamente espandibile, che si attiva o disattiva tramite un tag RFID, essa può memorizzare fino a tre tag più una chiave master.
Il sensore di Fiamma e il sensore MQ-02 non dipendono dall’attivazione o meno dell’allarme e sono lasciati sempre attivi.
Se attivati dalla presenza di una fuoriuscita di gas oppure di una fiamma faranno suonare il buzzer e indicheranno sul display quale sensore (o pericolo) ha fatto attivare la sirena.
 
La prima configurazione consiste di inserire manualmente il codice decimale della propria card che si vuole utilizzare come master. La chiave master serve altresì per memorizzare gli altri gruppi di chiavi fino ad un massimo di tre tag.
 
Al posto del display LCD classico 16×2 HD44780 ho inserito un display LCD 16×2 con comunicazione seriale I2C per liberarci di un po di pin che altrimenti andrebbero occupati dal display stesso.
​
Sulla breadboard ho inserito tre diodi Led e un pulsante
  • Il Led rosso indica lo stato di attivazione della centrale d’allarme, se acceso l’allarme è attivo.
  • Il Led giallo indica lo stato del sensore PIR, se acceso indica la presenza di movimento nell’abitazione.
  • Il Led verde lampeggiante indica che la sirena è attiva e quindi è scattato l’allarme.
  • Il pulsante ha la funzione di resettare le chiavi salvate fino a quel momento ma lascerà memorizzata la chiave master.

Sketch Prima Parte: Sistema di Allarme
 Una volta costruito il circuito del sistema anti-intrusione è possibile caricare lo sketch sulla scheda Arduino UNO tramite il software di programmazione Arduino IDE. 
Prima di procedere però è necessario includere la libreria del sensore RFID e del display LCD I2C seguendo queste semplici istruzioni:
  • Scaricare le librerie rfid-master e newliquidcrystal_1.3.4 in formato .ZIP;
  • Aprire Arduino IDE e fare clic su Sketch >> #include libreria >> aggiungi libreria da file .ZIP.
  • Selezionare la libreria da installare e il gioco è fatto!
/*
* Casa Domotica 2016/17
* Centrale antifurto costruita con Arduino uno. 
 Esame di maturità di Fancello Salvatore
 ITI A. Monaco Cosenza
*/
// Includiamo le librerie
#include <SPI.h>       // Libreria SPI
#include <RFID.h>      // Libreria RFID
#include <EEPROM.h>    // Libreria EEPROM
#include <Wire.h>      // Libreria Wire             
#include <LiquidCrystal_I2C.h>      // Libreria display lcd I2C
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);   // I2C pin display
#define SS_PIN 10            // SS pin RFID
#define RST_PIN 9            // Reset pin RFID

// Codice della chiave master in decimale
#define masnum0 252 
#define masnum1 162
#define masnum2 51
#define masnum3 59
#define masnum4 86

#define fiamma 1            // Sensore fiamma al pin 1 
#define gas 2               // Sensore gas al pin 2
#define pir 8               // Sensore pir al pin 8
#define ledGreen 4          // Led verde al pin 4
#define ledRed 3            // Led rosso al pin 3
#define ledgial 5           // Led giallo al pin 5
#define resetkey 6          // Pulsante reset al pin 6
#define pausa 5000 // Costante che definisce il tempo di ingresso e uscita, in questo caso 5 secondi

RFID rfid(SS_PIN, RST_PIN);      // inizializzo comunicazione RFID

boolean antiON = 0;              // Variabile antifurto attivo
boolean allarm = 0;              // Variabile centrale in allarme
boolean cardmas = 0;             // Variabile chiave master
int ledState = 0;                // Variabiile Stato Led
int slave;                       // Contatore di chiavi salvate
int fiamma1 = 1;                 // Imput fiamma pin 1
int allarmFiamma = 0;            // Variabile allarme fiamma
int gas2 = 2;                    // Imput gas pin 2
int allarmGas = 0;               // Variabile allarme gas
unsigned long previousMillis = 0;      // Contatore millis 
unsigned long interval = 500;          // Intervallo
int sernum0;                           // Primo gruppo decimale
int sernum1;                           // Secondo gruppo decimale
int sernum2;                           // Terzo gruppo decimale
int sernum3;                           // Quarto gruppo decimale
int sernum4;                           // Quinto gruppo decimale

void setup()
{ 
  lcd.begin(16, 2);            // Inizializza display 16 colonne 2 righe
  SPI.begin();                 // Inizializza Comunicazione SPI
  rfid.init();                 // Inizializza rfid
  pinMode(fiamma1, INPUT);     // Sensore fiamma sul pin 1 in entrata
  pinMode(gas2, INPUT);        // Sensore gas sul pin 2 in entrata
  pinMode(ledRed, OUTPUT);     // Led rosso sul pin 3 in uscita
  pinMode(ledGreen, OUTPUT);   // Led verde sul pin 4 in uscita
  pinMode(7, OUTPUT);          // Buzzer sul pin 7 in uscita
  pinMode(ledgial, OUTPUT);    // Led giallo sul pin 5 in uscita
  pinMode(resetkey, INPUT);    // Pulsante reset chiavi sul pin 6 in entrata
  digitalWrite(ledRed, LOW);   // Inizializza il led rosso allo stato basso
  digitalWrite(ledgial, LOW);  // Inizializza il led rosso allo stato basso
  lcd.print(" Casa Domotica ");       // Scrivi sul display "Casa Domotica"
  lcd.setCursor(0,1);                 // Scrivi sulla seconda riga
  lcd.print ("Progetti Arduino");     // Scrivi "Progetti Arduino"
}
/* Ciclo del programma */
void loop() {
 allarmFiamma = digitalRead(fiamma1);     // Leggi il sensore fiamma e imposta il valore in allarmFiamma
 allarmGas = digitalRead(gas2);           // Leggi il sensore gas e imposta il valore in allarmGas
 slave = EEPROM.read(0);                  // Imposta slave con il valore letto sulla EEprom              
 
 if(allarmFiamma == LOW) {                // Se allarmFiamma è allo stato basso
  lcd.clear();                            // Pulisci schermo
  lcd.print("ALLARME FUOCO!!");           // Scrivi sul display "ALLARME FUOCO!!"
  digitalWrite (ledRed,HIGH);             // Accendi il led rosso
  buzz(7, 4186, 100);                     // Fai suonare il buzzer
  standby();                              // Porta in standby tramite la funzione void standby
 }
 
 if(allarmGas == HIGH) {                  // Se allarmGas è allo stato alto
  lcd.clear();                            // Pulisci schermo
  lcd.print("ALLARME GAS!!");             // Scrivi sul display "ALLARME GAS!!"
  digitalWrite (ledRed,HIGH);             // Accendi il led rosso         
  buzz(7, 4186, 100);                     // Fai suonare il buzzer
  standby();                              // Porta in standby
 }
  
  // Rileva un tag...
  if (rfid.isCard()) {
      // Legge il seriale...
      if (rfid.readCardSerial()) {
        sernum0 = rfid.serNum[0];
        sernum1 = rfid.serNum[1];
        sernum2 = rfid.serNum[2];
        sernum3 = rfid.serNum[3];
        sernum4 = rfid.serNum[4];
                /* Se il seriale letto corrisponde con il seriale Master attiva o disattiva la modalita Memorizzazione chiavi
                 e in più visualizza l'elenco della chiavi salvate... */
                if (sernum0 == masnum0
                && sernum1 == masnum1
                && sernum2 == masnum2
                && sernum3 == masnum3
                && sernum4 == masnum4) {
                if (cardmas==0) {                     
                  lcd.clear();                        // Pulisci schermo
                  lcd.print("CARD MASTER");           // Scrivi sul display "CARD MASTER"
                  delay(1500);                        // Attendi 1500 ms
                  lcd.clear();                        // Pulisci schermo
                  lcd.print("GESTIONE CHIAVI");       // Scrivi sul display "GESTIONE CHIAVI"
                cardmas = 1;
                lcd.setCursor(0, 1);                  // Sposta il cursore sulla Seconda riga
                lcd.print("Chiavi slave: ");          // Scrivi sul display "Chiavi Slave"       
                lcd.setCursor(15, 1);                 // Sposta il cursore sulla 16 colonna seconda riga
                lcd.print(slave);                     // Scrivi quale slave è salvata
                delay(2000);                          // Attendi 2 secondi
                }  else { cardmas = 0;                
                  lcd.setCursor(0, 1);                // Sposta il cursore sulla Seconda riga
                  lcd.print("Annullata       ");      // Scrivi sul display "Annullata       "
                delay(3000);                          // Attendi 3 secondi
                standby();                            // Porta in standby
                }
                } 
                /* Se invece il seriale letto corrisponde con uno dei tre gruppi di chiavi memorizzate allora attiva o disattiva l'allarme.*/
                else if ((sernum0 == EEPROM.read(1) && sernum1 == EEPROM.read(2) && sernum2 == EEPROM.read(3) && sernum3 == EEPROM.read(4) && sernum4 == EEPROM.read(5))
                        || (sernum0 == EEPROM.read(6) && sernum1 == EEPROM.read(7) && sernum2 == EEPROM.read(8) && sernum3 == EEPROM.read(9) && sernum4 == EEPROM.read(10))
                        || (sernum0 == EEPROM.read(11) && sernum1 == EEPROM.read(12) && sernum2 == EEPROM.read(13) && sernum3 == EEPROM.read(14) && sernum4 == EEPROM.read(15))) {
                              
                             if (antiON == 0) {                       // Se antifurto è disattivato
                             antiON = 1;                              // Attivo l'antifurto
                             lcd.clear();                             // Pulisci schermo
                             lcd.print("CHIAVE VALIDA");              // Scrivi sul display "CHIAVE VALIDA"
                             delay(1500);                             // Attendi 1,5 Secondi
                             lcd.clear();                             // Pulisci schermo
                             lcd.print("ANTIFURTO");                  // Scrivi sul display "ANTIFURTO"
                             lcd.setCursor(0, 1);                     // Sposta il cursore sulla Seconda riga
                             lcd.print("INSERITO...");                // Scrivi sul display "INSERITO..."
                             delay(pausa);                            // Aspetto per il tempo definito sulla costante pausa
                             digitalWrite(ledRed, HIGH);              // Accendi il led Rosso
                             lcd.clear();                             // Pulisci schermo
                             lcd.print("ANTIFURTO");                  // Scrivi sul display "ANTIFURTO"
                             lcd.setCursor(0, 1);                     // Sposta il cursore sulla Seconda riga
                             lcd.print("ATTIVO");                     // Scrivi sul display "ATTIVO"
                             } 
                              else {                                  // altrimenti 
                                   antiON = 0;                        // se l'antifuto è disattivato
                                   allarm = 0;                        // e l' allarme è disattivata
                                   digitalWrite(ledRed, LOW);         // Spegni il led rosso
                                   digitalWrite(ledGreen, LOW);       // Spegni il led verde
                                   lcd.clear();                       // Pulisci schermo
                                   lcd.print("CHIAVE VALIDA");        // Scrivi sul display "CHIAVE VALIDA"
                                   delay(1500);                       // Attendi 1,5 Secondi
                                   lcd.clear();                       // Pulisci schermo
                                   lcd.print("ANTIFURTO");            // Scrivi sul display "ANTIFURTO"
                                   lcd.setCursor(0, 1);               // Sposta il cursore sulla Seconda riga
                                   lcd.print("DISATTIVO");            // Scrivi sul display "DISATTIVO"
                                   delay(3000);                       // Attendi 3 secondi
                                   standby();                         // Porta in standby
                    } 
                } 
                /* Se il seriale letto è diverso dal master e non è presente in memoria, e se è attiva la modalita Memorizzazione chiavi, salva il seriale in memoria
                 come slave1, slave2 o slave3.*/
                else if (cardmas == 1 && slave == 0) {           // Se invece si passa la card master e non sono presenti chiavi slave
                    lcd.clear();                                 // Pulisci schermo
                    lcd.print("Chiave rilevata!");               // Scrivi sul display "Chiave rilevata!"
                    EEPROM.write(0, 1);                          // Memorizza sulla EEPROM indirizzo valore
                    EEPROM.write(1, sernum0);                    // Memorizza sulla EEPROM all'indirizzo 1 il numero seriale 0
                    EEPROM.write(2, sernum1);                    // Memorizza sulla EEPROM all'indirizzo 2 il numero seriale 1
                    EEPROM.write(3, sernum2);                    // Memorizza sulla EEPROM all'indirizzo 3 il numero seriale 2
                    EEPROM.write(4, sernum3);                    // Memorizza sulla EEPROM all'indirizzo 4 il numero seriale 3
                    EEPROM.write(5, sernum4);                    // Memorizza sulla EEPROM all'indirizzo 5 il numero seriale 4
                    cardmas = 0;                                 // Non leggere la card master
                    delay(1000);                                 // Attendi un secondo
                    lcd.setCursor(0, 1);                         // Sposta il cursore sulla Seconda riga
                    lcd.print("Slave 1 salvata!");               // Scrivi sul display "Slave 1 salvata!"
                    delay(3000);                                 // Attendi 3 secondi
                    standby();                                   // Porta in standby
                                        
                }
                    else if (cardmas == 1 && slave == 1) {                 // Se invece si passa la card master ed è presente la chiave slave 1 salvata
                              lcd.clear();                                 // Pulisci schermo
                              lcd.print("Chiave rilevata!");               // Scrivi sul display "Chiave rilevata!"
                              EEPROM.write(0, 2);                          // Memorizza sulla EEPROM indirizzo valore
                              EEPROM.write(6, sernum0);                    // Memorizza sulla EEPROM all'indirizzo 6 il numero seriale 0
                              EEPROM.write(7, sernum1);                    // Memorizza sulla EEPROM all'indirizzo 7 il numero seriale 1
                              EEPROM.write(8, sernum2);                    // Memorizza sulla EEPROM all'indirizzo 8 il numero seriale 2
                              EEPROM.write(9, sernum3);                    // Memorizza sulla EEPROM all'indirizzo 9 il numero seriale 3
                              EEPROM.write(10, sernum4);                   // Memorizza sulla EEPROM all'indirizzo 10 il numero seriale 4
                              cardmas = 0;                                 // Non leggere la card master
                              delay(1000);                                 // Attendi un secondo
                              lcd.setCursor(0, 1);                         // Sposta il cursore sulla Seconda riga
                              lcd.print("Slave 2 salvata!");               // Scrivi sul display "Slave 2 salvata!"
                              delay(3000);                                 // Attendi 3 secondi
                              standby();                                   // Porta in standby
                    }
                              else if (cardmas == 1 && slave == 2) {                // Se invece si passa la card master ed è presente la chiave slave 2 salvata
                                       lcd.clear();                                 // Pulisci schermo 
                                       lcd.print("Chiave rilevata!");               // Scrivi sul display "Chiave rilevata!"
                                       EEPROM.write(0, 3);                          // Memorizza sulla EEPROM indirizzo valore
                                       EEPROM.write(11, sernum0);                   // Memorizza sulla EEPROM all'indirizzo 11 il numero seriale 0
                                       EEPROM.write(12, sernum1);                   // Memorizza sulla EEPROM all'indirizzo 12 il numero seriale 1
                                       EEPROM.write(13, sernum2);                   // Memorizza sulla EEPROM all'indirizzo 13 il numero seriale 2
                                       EEPROM.write(14, sernum3);                   // Memorizza sulla EEPROM all'indirizzo 14 il numero seriale 3
                                       EEPROM.write(15, sernum4);                   // Memorizza sulla EEPROM all'indirizzo 15 il numero seriale 4
                                       cardmas = 0;                                 // Non leggere la card master
                                       lcd.setCursor(0, 1);                         // Sposta il cursore sulla Seconda riga
                                       lcd.print("Slave 3 salvata!");               // Scrivi sul display "Slave 3 salvata!"
                                       delay(3000);                                 // Attendi 3 secondi
                                       standby();                                   // Porta in standby
                              }
                }
                }
         
  
 // Se l'infrarosso rileva un movimento accende il led giallo
  if (digitalRead(pir) == HIGH) {                     // Se il pir è allo stato alto              
          digitalWrite(ledgial, HIGH);                // Accendi il led giallo
     }
     else {                                           // Altrimenti
           digitalWrite(ledgial, LOW);                // Spegni il led giallo
          }
          
  // Se l'infrarosso rileva un movimento e l'antifurto e attivo 
  // e quindi non in allarme, attiva l'allarme facendo lampeggiare 
  // il led verde e facendo suonare il buzzer     
  if (digitalRead(pir) == HIGH && antiON == 1 && allarm == 0){
          delay(pausa);                 // attendi pausa
          allarm = 1;                   // Porta l'allarme attivo
          lcd.clear();                  // Pulisci schermo
          lcd.print("ALLARME!!");       // Scrivi sullo schermo "ALLARME"
     }
  if (antiON == 1 && allarm == 1) {     // Se l'antifurto è attivo e l'allarme è attivo
          lamp();                       // Funzione void lamp
          buzz(7, 4186, 100);           // Attiva buzzer
          delay(10);                    // Attesa
     }
     
 // Se è stata attivata con la card Master la modalità "Memorizzazione chiavi",
 // premendo il pulsante di reset si azzera il database 
 // delle chiavi salvate fino a quel momento. 
 if (digitalRead(resetkey) == HIGH && cardmas == 1) {         
         cardmas = 0;
         for (int i=0; i<16; i++){
           EEPROM.write(i, 0);                               // Cancella slave memorizzate sulla EEPROM
             } 
         lcd.clear();                                        // Pulisci schermo
         lcd.print("Reset chiavi...");                       // Scrivi sullo schermo "Reset chiavi..."
         delay(3000);                                        // Attendi 3 secondi
         standby();                                          // Porta in standby
     }        
                
 rfid.halt();           // RFID in modalità sleep
}
/*Funzione void lamp*/
void lamp() {
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis; 
    ledState ^= 1;
    digitalWrite(ledGreen, ledState);
  }
}
  /* Funzione void buzz */
void buzz(int targetPin, long frequency, long length) {
 long delayValue = 1000000/frequency/2;
 long numCycles = frequency * length/ 1000;
 for (long i=0; i < numCycles; i++)
 {
 digitalWrite(targetPin,HIGH);
 delayMicroseconds(delayValue);
 digitalWrite(targetPin,LOW);
 delayMicroseconds(delayValue);
 }
  }
  /* Funzione void standby */
void standby() {
 lcd.clear();                              // Pulisci schermo 
 lcd.print(" Casa Domotica ");             // Scrivi sullo schermo " Casa Domotica "
 lcd.setCursor(0,1);                       // Sposta il cursore sulla Seconda riga
 lcd.print ("Progetti Arduino");           // Scrivi sullo schermo "Progetti Arduino"
}


Seconda Parte del Programma: Controllo dispositivi ​tramite pagina Web-server
La seconda parte del progetto riguarda il controllo dei dispositivi tramite pagina web con Arduino Mega 2560 e la ethernet shield.
La ethernet shield è provvista di un connettore RJ45 per la connessione diretta al modem di casa così da controllare i dispositivi via rete locale o via Internet.
Arduino Mega Ethernet Shield Tesina Bb
Nel nostro caso utilizzeremo la ethernet shield in rete locale collegata ad un modem router Digicom 150, impostiamo sullo sketch l’indirizzo IP fisso della board 192.168.10.89 in modo da rendere subito raggiungibile la pagina web tramite protocollo HTTP che ci consentirà di controllare i vari dispositivi.
 
Se si utilizza la ethernet shield in locale senza connessione internet dobbiamo fare a meno della grafica personalizzata perché caricata sulla pagina web: /ethernet.html in formato style.css , questo mi è stato di grande aiuto in quanto la memoria limitata di Arduino Mega 2560 non mi permetteva di caricare grandi formati di testo HTML.
 
Se la Ethernet Shield non è connessa in rete non può raggiungere l’editor grafico .css salvato sulla pagina web e quindi si avrà una pagina con grafica limitata ma pur sempre utilizzabile.

Esempio di pagina Web Server senza connessione internet
Webserver Senza Internet

​Esempio di pagina Web Server con connessione internet
Webserver Con Internet

Sketch Seconda Parte: Controllo dispositivi tramite Web server
Una volta realizzato il circuito per il controllo dei dispositivi possiamo procedere con caricare lo sketch su Arduino Mega 2560 + Ethernet Shield.
​In questo caso non è necessario includere altre librerie in quanto sono già presenti su Arduino IDE.
/*
 * Casa Domotica 2016/17
 Arduino Webserver con Ethernet Shield Su Arduino Mega 2560
 Esame di maturità di Fancello Salvatore
 ITI A. Monaco Cosenza
 */
// Includiamo le librerie
#include <SPI.h>          // Libreria SPI
#include <Ethernet.h>     // Libreria Ethernet
#include <Servo.h>        // Libreria Servo
Servo myservo;            // Diamo un nome al servomotore
 
//Html page refresh
int refreshPage = 15;     // Default 15sec. 
int fiamma = 4;           // Input sensore fiamma al pin 4
int gas = 5;              // Input sensore GAS al pin 5
int pir = 6;              // Input sensore pir al pin 6
int allarmFiamma = 0;     // Intero allarme fiamma a 0
int allarmGas = 0;        // Intero allarme gas a 0
int allarmPir = 0;        // Intero allarme pir a 0
int Pin8 = 8;   // non utilizzato         
int Pin9 = 9;   // non utilizzato
int Pin11 = 11; // non utilizzato
int Pin12 = 12; // non utilizzato
int Pin22 = 22; // Camera sul pin 22
int Pin23 = 23; // Cameretta sul pin 23
int Pin24 = 24; // Bagno sul pin 24
int Pin25 = 25; // Soggiorno sul pin 25
int Pin26 = 26; // Cucina sul pin 26
int Pin27 = 27; // Luci Esterne sul pin 27
int Pin29 = 29; // Lampeggiante sul pin 29
int Pin30 = 30; // Ventola sul pin 30
 
 
// Indico le variabili stufa
int Tempo = 140;      // Tempo in ms
int TmpRandom = 150;  // Tempo Random in ms
int Giallo1 = 31;     // Giallo 1 sul pin 31
int Rosso = 32;       // Rosso sul pin 32
int Giallo2 = 33;     // Giallo 2 sul pin 33
 
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };   // Mac address
byte ip[] = { 192, 168, 10, 89 };                      // Configurare IP con uno a vostra scelta("192.168.1.89")
byte gateway[] = { 192, 168, 10, 1 };                  // Internet access router
byte subnet[] = { 255, 255, 255, 0 };                  // Subnet mask
EthernetServer server(80);                                 // Porta Server     
String readString;                                                 // Leggi stringa
 
void setup() {
 // Apro la comunicazione seriale:
  Serial.begin(9600);
   while (!Serial) {
    ; // Attendere la connessione sulla porta. Solo per Arduino Leonardo
  }
  //Imposto i pin come INPUT o OUTPUT
  pinMode(fiamma, INPUT);  //ingresso fiamma sul pin 4
  pinMode(gas, INPUT);     //ingresso gas sul pin 5
  pinMode(pir, INPUT);     //ingresso allarme sul pin 6
  pinMode(Pin8, OUTPUT);   //non utilizzato
  pinMode(Pin9, OUTPUT);   //non utilizzato
  pinMode(Pin11, OUTPUT);  //non utilizzato
  pinMode(Pin12, OUTPUT);  //non utilizzato
  pinMode(Pin22, OUTPUT);  // Uscita CAMERA sul pin 22 
  pinMode(Pin23, OUTPUT);  // Uscita CAMERETTA sul pin 23
  pinMode(Pin24, OUTPUT);  // Uscita BAGNO sul pin 24
  pinMode(Pin25, OUTPUT);  // Uscita SOGGIORNO sul pin 25
  pinMode(Pin26, OUTPUT);  // Uscita CUCINA sul pin 26
  pinMode(Pin27, OUTPUT);  // Uscita LUCI ESTERNE sul pin 27
  myservo.attach(28);      // Uscita Servo CANCELLO sul pin 28
  pinMode(Pin29, OUTPUT);  // Uscita LAMPEGGIANTE sul pin 29
  pinMode(Pin30, OUTPUT);  // Uscita VENTOLA sul pin 30
  pinMode(Giallo1, OUTPUT); // Uscita giallo 1 stufa sul pin 31
  pinMode(Rosso, OUTPUT);   // Uscita rosso stufa sul pin 32
  pinMode(Giallo2, OUTPUT); // Uscita giallo 2 stufa sul pin 33
  
  myservo.write(90); // Inizia con il cancello fermo
  // Inizio la comunicazione Ethernet con il server:
  Ethernet.begin(mac, ip, gateway, subnet);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}
 
 
void loop() {
  
  // Creo una connessione al client
  EthernetClient client = server.available();
  if (client) {
    while (client.connected()) {   
      if (client.available()) {
        char c = client.read();
     
        //Leggo i caratteri da HTTP
        if (readString.length() < 100) {
          //Inserisco i caratteri nella stringa 
          readString += c;
          //Serial.print(c);
         }
 
         //Se la richiesta HTTP è andata a buon fine
         if (c == '\n') {          
           Serial.println(readString); //scrivi sul monitor seriale per debugging
     
           client.println("HTTP/1.1 200 OK"); //Invio nuova pagina
           client.println("Content-Type: text/html");
           client.println();     
           client.println("<HTML>");
           client.println("<HEAD>");  // Inizio Intestazione
           client.println("<meta name='apple-mobile-web-app-capable' content='yes' />");
           client.println("<meta name='apple-mobile-web-app-status-bar-style' content='black-translucent' />");
           //Stile pulsanti caratteri e sfondo memorizzati all'indirizzo: http://www.progettiarduino.com/uploads/8/1/0/8/81088074/style3.css
           client.println("<link rel='stylesheet' type='text/css' href='http://www.progettiarduino.com/uploads/8/1/0/8/81088074/style3.css' />");
           client.println("<TITLE>Controllo Dispositivi da Remoto</TITLE>"); //Titolo Controllo Dispositivi da Remoto
           client.println("</HEAD>"); // Fine intestazione
           client.println("<BODY>");  // Corpo pagina
           client.println("<H1>Controllo Dispositivi da Remoto</H1>"); // Scrivi altezza carattere H1  
           client.println("<hr />");
           client.println("<br />");  // Vai a capo
           client.println("<H2>Casa Domotica</H2>");  // Scrivi altezza carattere H2
           client.println("<br />");  
           client.println("<a href=\"/?button1on\"\">Luce Camera ON</a>");  //Scrivi sul pulsante1on "Luce Camera ON"
           client.println("<a href=\"/?button1off\"\">Luce Camera OFF</a><br />");  //Scrivi sul pulsante1off "Luce Camera OFF" 
           client.println("<br />");  
           client.println("<br />");
           client.println("<a href=\"/?button2on\"\">Luce Cameretta ON</a>");  //Scrivi sul pulsante2on "Luce Cameretta ON"
           client.println("<a href=\"/?button2off\"\">Luce Cameretta OFF</a><br />"); //Scrivi sul pulsante2off "Luce Cam OFF"
           client.println("<br />");   
           client.println("<br />");
           client.println("<a href=\"/?button3on\"\">Luce Bagno ON</a>");  //Scrivi sul pulsante3on "Luce Bagno ON"
           client.println("<a href=\"/?button3off\"\">Luce Bagno OFF</a><br />");  //Scrivi sul pulsante3off "Luce Bagno OFF"
           client.println("<br />");   
           client.println("<br />");
           client.println("<a href=\"/?button4on\"\">Luce Soggiorno ON</a>");  //Scrivi sul pulsante4on "Luce Soggiorno ON"
           client.println("<a href=\"/?button4off\"\">Luce Soggiorno OFF</a><br />"); //Scrivi sul pulsante4off "Luce Soggi OFF"
           client.println("<br />");
           client.println("<br />");
           client.println("<a href=\"/?button5on\"\">Luce Cucina ON</a>");  //Scrivi sul pulsante5on "Luce Cucina ON"
           client.println("<a href=\"/?button5off\"\">Luce Cucina OFF</a><br />");  //Scrivi sul pulsante5off "Luce Cucina OFF"
           client.println("<br />");
           client.println("<br />");
           client.println("<a href=\"/?button6on\"\">Luci Giardino ON</a>");   //Scrivi sul pulsante6on "Luci Giardino ON" 
           client.println("<a href=\"/?button6off\"\">Luci Giardino OFF</a><br />"); //Scrivi sul pulsante6off "Luci Giardino OFF"
           client.println("<br />");
           client.println("<br />");
           client.println("<a href=\"/?button7on\"\">Apri Cancello</a>");   //Scrivi sul pulsante7on "Apri Cancello"
           client.println("<a href=\"/?button7off\"\">Chiudi Cancello</a><br />"); //Scrivi sul pulsante7off "Chiudi Cancello"
           client.println("<br />");
           client.println("<br />");
           client.println("<a href=\"/?button8on\"\">Condizionatore ON</a>");  //Scrivi sul pulsante8on "Condizionatore ON"
           client.println("<a href=\"/?button8off\"\">CondizionatoreOFF</a><br />"); //Scrivi sul pulsante8off "Condizionat OFF"
           client.println("<br />");
           client.println("<br />");
           client.println("<a href=\"/?button9on\"\">Stufa a Pellets ON</a>");  //Scrivi sul pulsante9on "Stufa a Pellets ON"
           client.println("<a href=\"/?button9off\"\">Stufa aPellets OFF</a><br />");//Scrivi sul pulsante9off "Stufa a Pellet OFF"
           client.println("<br />");
           client.println("<br />");
           client.println("<a href=\"/?button10on\"\">Tutto Acceso</a>");   //Scrivi sul pulsante10on "Tutto Accceso"
           client.println("<a href=\"/?button10off\"\">Tutto Spento</a><br />"); //Scrivi sul pulsante10off "Tutto Spento"
           client.println("<br />"); //Spazio 
           client.println("");
           // Inserimento Paragrafo
           client.println("<p>Creato da Salvatore Fancello. Visita http://progettiarduino.com per altri progetti!</p>");  
           client.println("<br />"); 
           client.println("</BODY>"); // Fine pagina
           client.println("</HTML>"); // Fine HTML
     
           delay(1);
           client.stop();
           //Controlli su Arduino: Se è stato premuto il pulsante sul webserver
           if (readString.indexOf("?button1on") >0){       // Se è premuto il pulsante1on 
               digitalWrite(Pin22, HIGH);                  // Accendi Luce Camera
           }
           if (readString.indexOf("?button1off") >0){      // Se è premuto il pulsante1off 
               digitalWrite(Pin22, LOW);                   // Spegni Luce Camera
           }
           if (readString.indexOf("?button2on") >0){       // Se è premuto il pulsante2on
               digitalWrite(Pin23, HIGH);                  // Accendi Luce Cameretta
           }
           if (readString.indexOf("?button2off") >0){      // Se è premuto il pulsante2off
               digitalWrite(Pin23, LOW);                   // Spegni Luce Camera       
           }
           if (readString.indexOf("?button3on") >0){       // Se è premuto il pulsante3on
               digitalWrite(Pin24, HIGH);                  // Accendi Luce Bagno
           }
           if (readString.indexOf("?button3off") >0){      // Se è premuto il pulsante3off
               digitalWrite(Pin24, LOW);                   // Spegni Luce Bagno
           }
           if (readString.indexOf("?button4on") >0){       // Se è premuto il pulsante4on
               digitalWrite(Pin25, HIGH);                  // Accendi Luce Soggiorno
           }
           if (readString.indexOf("?button4off") >0){      // Se è premuto il pulsante4off
               digitalWrite(Pin25, LOW);                   // Spegni Luce Soggiorno
           }
           if (readString.indexOf("?button5on") >0){       // Se è premuto il pulsante5on
               digitalWrite(Pin26, HIGH);                  // Accendi Luce Cucina
           }
           if (readString.indexOf("?button5off") >0){      // Se è premuto il pulsante5off
               digitalWrite(Pin26, LOW);                   // Spegni Luce Cucina
           }
           if (readString.indexOf("?button6on") >0){       // Se è premuto il pulsante6on
               digitalWrite(Pin27, HIGH);                  // Accendi Luci Giardino
           }
           if (readString.indexOf("?button6off") >0){      // Se è premuto il pulsante6off
               digitalWrite(Pin27, LOW);                   // Spegni Luci Giardino
           }
           if (readString.indexOf("?button7on") >0){       // Se è premuto il pulsante7on
               digitalWrite (Pin29, HIGH);                 // Accendi LED Cancello
               delay (500);                                // Attendi mezzo secondo
               digitalWrite (Pin29, LOW);                  // Spegni LED Cancello
               delay (500);                                // Attendi mezzo secondo
               digitalWrite (Pin29, HIGH);                 // Accendi LED Cancello
               delay (500);                                // Attendi mezzo secondo
               digitalWrite (Pin29, LOW);                  // Spegni LED Cancello
               delay (500);                                // Attendi mezzo secondo
               myservo.write(0);                           // Fai girare il servo in senso antiorario
               delay(4000);                                // Per 4 secondi
               myservo.write(90);                          // Ferma servo
               delay(6000);                                // Per 6 secondi
               myservo.write(180);                         // Fai girare il servo in senso orario
               delay(4000);                                // Per 4 secondi
               myservo.write(90);                          // Ferma il servo
               digitalWrite (Pin29, HIGH);                 // Accendi LED Cancello
               delay (500);                                // Attendi mezzo secondo
               digitalWrite (Pin29, LOW);                  // Spegni LED Cancello   
           }
           if (readString.indexOf("?button7off") >0){      // Se è premuto il pulsante7off
               myservo.write(180);                         // Fai girare il servo in senso orario
               delay(4000);                                // Per 4 secondi
               myservo.write(90);                          // Ferma il servo
               digitalWrite (Pin29, HIGH);                 // Accendi lED Cancello
               delay (500);                                // Attendi mezzo secondo
               digitalWrite (Pin29, LOW);                  // Spegni LED Cancello  
               delay (500);                                // Attendi mezzo secondo
               digitalWrite (Pin29, HIGH);                 // Accendi LED Cancello
               delay (500);                                // Attendi mezzo secondo
               digitalWrite (Pin29, LOW);                  // Spegni LED Cancello   
           }
           if (readString.indexOf("?button8on") >0){       // Se è premuto il pulsante8on
               digitalWrite(Pin30, HIGH);                  // Accendi Condizionatore
           }
           if (readString.indexOf("?button8off") >0){      // Se è premuto il pulsante8off
               digitalWrite(Pin30, LOW);                   // Spegni Condizionatore
           }
           if (readString.indexOf("?button9on") >0){            // Se è premuto il pulsante9on
               analogWrite(Giallo1, random(TmpRandom)+Tempo);   // Tempo Random Giallo1 
               analogWrite(Rosso, random(TmpRandom)+Tempo);     // Tempo Random Rosso
               analogWrite(Giallo2, random(TmpRandom)+Tempo);   // Tempo Random Giallo2 
               delay(random(100));  
           }
           if (readString.indexOf("?button9off") >0){      // Se è premuto il pulsante9off    
               digitalWrite (Giallo1,LOW);                 // Spegni Giallo1
               digitalWrite (Rosso,LOW);                   // Spegni Rosso
               digitalWrite (Giallo2,LOW);                 // Spegni Giallo2
           }
           if (readString.indexOf("?button10on") >0){      // Se è premuto pulsante10on
              digitalWrite(Pin22, HIGH);                   // Accendi Luce Camera
              digitalWrite(Pin23, HIGH);                   // Accendi luce Cameretta
              digitalWrite(Pin24, HIGH);                   // Accendi Luce Bagno
              digitalWrite(Pin25, HIGH);                   // Accendi Luce Soggiorno
              digitalWrite(Pin26, HIGH);                   // Accendi Luce Cucina
              digitalWrite(Pin27, HIGH);                   // Accendi Luci Giardino
           }
           if (readString.indexOf("?button10off") >0){     // Se è premuto pulsante10off
              digitalWrite(Pin22, LOW);                    // Spegni Luce Camera
              digitalWrite(Pin23, LOW);                    // Spegni Luce Cameretta
              digitalWrite(Pin24, LOW);                    // Spegni Luce Bagno
              digitalWrite(Pin25, LOW);                    // Spegni Luce Soggiorno
              digitalWrite(Pin26, LOW);                    // Spegni Luce Cucina
              digitalWrite(Pin27, LOW);                    // Spegni Luci Giardino
              digitalWrite(Pin29, LOW);                    // Spegni lED Cancello 
              digitalWrite(Pin30, LOW);                    // Spegni Condizionatore
              digitalWrite (Giallo1,LOW);                  // Spegni Giallo1
              digitalWrite (Rosso,LOW);                    // Spegni Rosso
              digitalWrite (Giallo2,LOW);                  // Spegni Giallo2
           }
           
            //Cancella la stringa una volta letta
            readString="";  
           
         }
       }
    }
    
}
}

Terza Parte del Programma: Controllo Webcam in Streaming
La terza parte del programma richiede un po di conoscenze sul sistema operativo Linux per poter programmare Arduino YUN e utilizzare la webcam per effettuare lo streaming video.
Ho seguito il tutorial su lucadentella.it che vi consiglio di visitare vi guiderà passo passo al collegamento di una webcam su Arduino YUN.
Streaming Webcam Con Arduino Yun

​Arduino YUN monta una distribuzione Linux (Linino) ed è in grado di gestire webcam che supportano i driver UVC.
 
Ho utilizzato una webcam Logitech E-3500 e installato i driver kmod-video-uvc tramite il software integrato nella YUN.
 
Per trasmettere in rete lo streaming ho scelto di utilizzare mjpg-streamer,  un applicativo in grado di catturare il video della webcam e renderlo disponibile tramite interfaccia web.
 
Per installarlo sulla Arduino YUN è stato necessario collegarla tramite il software gratuito Putty e protocollo SSH, spostarci nella cartella /tmp e scaricare il pacchetto tramite wget:
wget http://www.custommobileapps.com.au/downloads/mjpg-streamer.ipk
installare il pacchetto con opkg:
opkg install mjpg-streamer.ipk
ed infine ho eseguire il programma con:
/etc/init.d/mjpg-streamer start
 
Collegandoci con il browser all’indirizzo della YUN e alla porta 8080 (http://192.168.10.100:8080) possiamo visualizzare l’interfaccia di mjpg-streamer:

Stream
Desidero rivolgere un ringraziamento a tutti i professori dell’ITI A. Monaco di Cosenza in particolare ai professori 
​Porto Aldo
e De Luca Carmelo per l’aiuto e il supporto dimostrato in questi anni, per avermi portato a conoscenza della scheda Arduino. Devo a loro la nascita del blog ProgettiArduino.com