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.
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.
Candidato: Fancello Salvatore
Classe: 5^ Elettronica
Anno scolastico 2016/2017
Arduino e Stampa 3D
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.
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.
Materiali e componenti utilizzati
Componenti Utilizzati:
🧰 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
- 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.
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.
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.
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).
I modelli in formato .STL vengono infine caricati su un software che effettua la divisione in strati dell’oggetto da stampare (slicing).
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.
A quel punto si avranno tutti gli spazi della casa pronti.
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.
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.
|
|
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.
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.
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.
Schema del circuito completo
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.
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 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:
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.
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.
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.
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
Esempio di pagina Web Server con connessione 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.
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.
Ho seguito il tutorial su lucadentella.it che vi consiglio di visitare vi guiderà passo passo al collegamento di una webcam su 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:
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
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

