tesi mezzelani
TRANSCRIPT
1
ISIS OSIMO - CASTELFIDARDO
ITIS “A.MEUCCI”
(TESI DI MATURITÁ)
LA DOMOTICA
Indirizzo di Informatica e Telecomunicazioni
Anno Scolastico 2014 - 2015
Tesina a cura di:
Mezzelani Michelangelo
2
SOMMARIO
1. Introduzione alla domotica…………………………………. 3
2. La sua evoluzione……………………………………………. 4
3. I vantaggi e le possibili applicazioni………………………… 6
4. La tecnologia domotica……………………………………… 9
4.1. Protocolli………………………………………………… 11
4.2.Tecnologie di trasmissione……………………………… 12
5. Il progetto……………………………………………………. 13
5.1. Introduzione…………………………………………….. 13
5.2. Elementi essenziali……………………………………… 14
5.3. Il plastico………………………………………………… 15
5.4. Arduino…………………………………………………. 17
5.5.Il codice………………………………………………….. 19
5.6.Descrizione dei singoli impianti………………………… 28
5.6.1. Impianto di illuminazione…………………… 28
5.6.2. Sistema di allarme……………………………. 29
5.6.3. Automatizzazione infissi…………………….. 33
5.6.4. Sensori ambiente…………………………….. 35
5.6.5. Infrarossi……………………………………… 37
5.6.6. Bluetooth…………………………………….. 39
6. APP per Smartphone………………………………………... 40
7. Conclusioni e sviluppi futuri ……………………………….. 44
8. Bibliografia …………………………………………………... 45
3
1. INTRODUZIONE ALLA DOMOTICA
Già gli antichi romani ritenevano che non deve essere la
casa a dominare e possedere la persona, ma è il padrone che
deve possederla e governarla, con il loro motto, “Nec domo
dominus, sed domino domus honestanda est” (Cicerone,
Retorica, De Officiis Liber Primus v. 139).
Infatti in senso stretto la Domotica è quella disciplina che
nasce per automatizzare ed integrare le funzionalità di un
ambiente domestico, per apportare alla vita di tutti i giorni
comodità, sicurezza ed ottimizzazione di tempi e spazi.
Prima di parlare di domotica, bisognerebbe però spiegarne il
termine. La parola “domotica” deriva dal termine francese
“domotique”, espressione verbale, formata dalla parola
lat ina domus e dal finale di altri due termini informatique e
télématique. Inoltre la Domus, (dal latino), è la casa n o n
in senso popolare (chiamata Insulae) ma in senso padronale, di
maggior rilevanza. In Francia esiste anche il termine
“ immotique” (che sarebbe tradotto con Immotica) non
importato in Italia e che definisce in un unico termine un
edificio domotico o un insieme di edifici domotici; in
Inghilterra utilizzano anche un’altra terminologia ovvero
“ smart house”, per i sistemi -home automation-, sistemi
“intelligenti”.
4
2. LA SUA EVOLUZIONE
La domotica nasce intorno agli anni '70 con lo studio e la
realizzazione dei primi progetti che consentivano la
connessione di alcuni sistemi: impianto di illuminazione,
impianto di sicurezza, climatizzazione e condizionamento;
q u e s t ’ u l t i m i davano p e r ò all'utente la possibilità di
automatizzarne s o l o alcune funzionalità.
Inizialmente si realizzavano modelli di domotica di ogni
genere e per ogni apparecchio, molto spesso però a causa di
una non universalità di protocolli e sistemi utilizzati, i
dispositivi non erano in grado di collegarsi tra loro o di avere
un’unico master, cioè un dispositivo che li potesse controllare
tutti uniformemente.
Superata una prima fase, dove si realizzavano più prototipi che
veri e propri prodotti, ormai si è raggiunto un nuovo concetto
della domotica: una serie di prodotti standard con
caratteristiche di interfacciabilità e flessibilità, concepiti per
l'automazione, la comunicazione e l'entertainment che
possono essere connessi tra loro per comunicare e possono
dialogare con l'esterno grazie ai protocolli internet per poter
usufruire di vantaggiosi servizi; utilizzando tra l’altro un unico
protocollo standard per tutto il mondo, il KNX, che spiegherò
più avanti.
Domotica, quindi, come interazione tra la casa e i suoi abitanti
è finalizzata a migliorare l'accessibilità e la vivibilità
dell'abitazione.
5
La casa “smart” (ovvero intelligente) non deve essere vista
come lusso per pochi ma deve rispondere alle differenti
esigenze di tutte le fasce di popolazione, in particolare può
risolvere molti problemi di anziani e disabili. Oggi le nostre
case sono ricche di apparecchi dotati di unità di elaborazione
sempre più evolute. La tendenza negli ultimi anni è di
dotare per tali dispositivi anche della capacità di comunicare
tra di loro e con il mondo esterno, grazie a efficaci sistemi di
comunicazione, cablati e non, disponibili a basso costo.
L’evoluzione della capacità di elaborazione e comunicazione
dei dispositivi presenti in una casa ha permesso la
progettazione e la realizzazione di sistemi integrati di
automazione domestica sempre più complessi e utili alla vita
dell’uomo nella propria abitazione.
6
3. I VANTAGGI E LE POSSIBILI APPLICAZIONI
Gli ambiti applicativi della domotica sono principalmente
quattro:
rispario energetico, comfort e sicurezza: intesa come safety ma
anche come security.
La safety si occupa di sicurezza della salute dell’individuo,
come prevenzione dei danni, infortuni , incendi, malattie e
altro; La security invece si occupa della sicurezza fisica e del
monitoraggio, perciò ha anche il compito di difendere la
nostra casa e renderla sicura, proteggendola dalle intrusioni
fisiche esterne con i sistemi antifurto e con sistemi per il
controllo degli accessi e con dei firewall e controlli degli
accessi con codici di identificazione per quanto riguarda la
rete collegata a Internet da cui possono arrivare minacce
digitali.
Con un sistema domotico è possibile controllare direttamente
tutti gli apparecchi collegati al sistema elettrico, perciò si
possono gestire direttamente tutti i
dispositivi e gli interruttori come ad esempio quelli del
sistema d’illuminazione, che talvolta capita di dimenticare
accesi. In questo modo non si può che avere un risparmio di
corrente elettrica e di conseguenza un risparmio energetico.
Sicuramente a n c h e il comfort è importante e la domotica
i n f a t t i risponde anche a questa esigenza permettendo una
maggiore vivibilità all’interno della propria casa, perciò si ha la
possibilità di vivere la propria casa nella maniera migliore
potendo controllare tutto anche a distanza tramite la rete
Internet o la rete radiocellulare.
7
I vantaggi per la gestione della casa sono molteplici e
coprono una vasta gamma di settori. Uno dei principali
vantaggi della domotica è quello di poter costruire la propria
casa a misura d’uomo. Il mondo della domotica si avvicina
perciò tantissimo al mondo dei disabili che a causa dei loro
handicap si trovano spesso b loccat i in casa loro e non
possono vivere la loro casa come potrebbe fare ognuno di
noi. La domotica vuole permettere a chiunque di poter
interagire con tutte le apparecchiature presenti nelle nostre
case, inoltre con il passare del tempo e un invecchiamento
progressivo degli individui e un innalzamento quindi dell’età
media della popolazione, ha sicuramente portato anziani e
domotica ad un avvicinamento sempre più repentino nel corso
degli anni.
Alcuni dispositivi domotici che rendono più semplice ad
anziani e disabili l’esecuzione di azioni che per noi sono
banali, sono ad esempio:
- le tapparelle automatiche: l’applicazione di un motorino alle
tapparelle delle finestre consente di alzarle e abbassarle senza
alzarsi;
- il montascale elettrico: è una pedana o una poltrona fissata alla
rampa delle scale che permette di salire e di scendere stando
seduti;
- il sollevatore per la vasca da bagno: è un seggiolino posto
all’interno della vasca che con un telecomando si alza e si
abbassa;
- il letto elettrico: è un letto con le sponde a scomparsa, senza gli
spigoli e dotato di un motore che permette di regolarne
l’altezza con un pulsante;
- il videocitofono: consente di rispondere al citofono e di vedere
con chi si sta parlando ovunque ci si trovi.
8
E questi non sono che alcuni esempi che possono aiutare a
vivere meglio all’interno delle proprie case coloro che hanno
più difficoltà in condizioni normali.
L’installazione di prodotti domotici può rientrare nelle
agevolazioni fiscali previste per la ristrutturazione della casa,
qualora consenta una maggiore autonomia della persona
anziana e/o con disabilità.
La domotica, ossia la gestione elettronica degli
elettrodomestici e degli impianti, consente con un solo
dispositivo, magari mobile, di gestire tutti gli altri
apparecchi presenti: l’impianto di illuminazione, di
sicurezza, delle telecomunicazioni, del riscaldamento, dell’aria
condizionata e più in generale, di qualsiasi altro dispositivo
elettrico presente in casa. È necessario realizzare un sistema
in cui le interazioni utente-macchina siano più semplici
possibile, intuitive, senza la necessita di dover andare ad
imparare complicate nozioni per l’utilizzo finale.
9
4. LA TECNOLOGIA DOMOTICA
Quando si parla di mercato della domotica si intende un
mercato altamente tecnologico, dato che l ’utilizzo
dell’innovazione tecnologica all’interno delle abitazioni ai
giorni nostri è sempre più elevato.
Le soluzioni tecnologiche offerte dagli operatori del settore
devono avere le stesse caratteristiche dei normali oggetti
casalinghi:
- affidabilità: il sistema non ha bisogno di particolari
attenzioni per funzionare, e deve segnalare il
malfunzionamento;
- semplicità: deve essere accessibile a tutti, anche a utenti
non specializzati. Inoltre non deve essere pericoloso da
utilizzare;
- continuità di funzionamento: il sistema deve essere
progettato in maniera tale da essere immune da guasti, o
comunque deve essere semplice da riparare ed in tempi brevi,
senza richiedere l’intervento di un esperto.
Un impianto domotico è quindi essenzialmente costituito da
una serie di elementi presenti comunemente nelle nostre
abitazioni (impianto di riscaldamento, forno, frigorifero,
lavatrice, ecc) che comunicano tra loro per creare dei vantaggi
che l’utente non potrebbe avere prendendo in considerazione
i vari elementi singolarmente. La chiave di tutto questo è
l’integrazione, maggiore è il numero degli elementi
integrati, e maggiori saranno i vantaggi per l’utente finale.
Il controllo dei vari componenti della casa è caratterizzato da:
l’unità centrale di controllo, i mezzi trasmissivi e le
caratteristiche delle varie periferiche.
Si ritiene vincente la scelta di un impianto nel quale l’unità
centrale di controllo sia facile da programmare a da gestire,
attraverso semplici interfacce utente.
10
Ci sono due diverse soluzioni per costruire un sistema
domotico:
- realizzare da zero un sistema progettato per essere integrato;
- trasformare gradualmente le varie apparecchiature
presenti nella casa in un sistema integrato introducendo la
“comunicazione” tra essi.
Quest’ultima tendenza è quella più realizzabile, dato che si
hanno molte strutture già esistenti e che il mercato edile è
fermo già da tempo. Quindi con una graduale evoluzione di
apparecchi tra loro incompatibili verso un sistema integrato
multifunzionale e modulare, ci si troverà ad avere una casa
completamente automatizzata senza la necessità di andarne a
costruire una da zero.
11
4.1. PROTOCOLLI
I protocolli di comunicazione sono i linguaggi che permettono
ai vari dispositivi di comunicare tra loro.
Inizialmente erano stati creati una vastissima gamma di
protocolli per l’ambito domotico. Ma il problema sussisteva
nell’integrazione di differenti dispositivi. Viste le specifiche
del protocollo KNX, iniziò ad esere il più diffuso tanto da
diventare lo standard europeo (EN 50090 - EN 13321-1) e
mondiale (ISO/IEC 14543). Lo standard è stato sviluppato sulla
base dell'esperienza dei suoi predecessori BatiBUS, EIB ed
EHS.
Esistono tre modalità di KNX:
- Automatic-Mode : riprende le specifiche di EHS.
- Easy-Mode : riprende le specifiche di BatiBUS.
- System-Mode : riprende le specifiche di EIB.
Uno dei punti di forza del sistema KNX, è che qualsiasi
prodotto si basa su prove di conformità effettuate dai laboratori
di KNX. Durante questi test, si verifica non solo che il
dispositivo supporta il protocollo KNX, ma che i suoi dati utili
sono codificati secondo i tipi di dati standardizzati KNX. Ciò
permette di realizzare impianti con una notevole capacità di
integrazione, funzionanti anche mediante la combinazione di
dispositivi di produttori diversi.
Inoltre è possibile accedere al sistema tramite rete LAN, reti
telefoniche analogiche o cellulari per avere un controllo
centrale o distribuito del sistema tramite PC, display tousch-
screen e smartphone.
12
4.2. TECNOLOGIE DI TRASMISSIONE
Lo standard KNX prevede diversi mezzi trasmissivi che
possono essere utilizzati in combinazione con uno o più modi
di configurazione in funzione della particolare applicazione. I
mezzi fisici sono:
- Twisted Pair
- Power Line
- Ethernet
A volte però per controllare i dispositivi, si utilizzano mezzi
che non necessitano cavi e collegamenti che potrebbero
risulatre scomodi, ad esempio esistono:
- Bluetooth
- WiFi Direct
- NFC
- Radio Frequency
- Internet
Questi consentono anche l’utilizzo del telefono per il controllo
di interi sistemi domotici, grazie all’universaità di questi mezzi
di comunicazione, presenti nella maggior parte dei dispositivi
mobili e non.
13
5. PROGETTO
5.1. INTRODUZIONE
Il progetto che presento è il prototipo di un sistema domotico,
un plastico in scala 1:20 di una casa, con installati apparecchi
integrati che ne migliorano la vivibilità.
Il mio scopo per questo progetto è di realizzare una casa
interamente controllabile da uno smartphone in modo tale da
agevolare le condizioni di vivibilità dell’appartamento.
Ora vedremo in maniera dettagliata i procedementi che ho
svolto al fine di realizzare l’intero impianto domotico.
Ecco la casa inizialmente progettata con un simulatore di gioco
3D, per poter decidere l’estetica della casa e in modo da poter
apportare facilmente modifiche strutturali:
14
5.2. ELEMENTI ESSENZIALI
Gli elementi essenziali del sistema Domotico realizzato
includono:
# Sensori:
- Sensori di Temperatura
- Sensori Fotocellule
- Sensori di Movimento (PIR)
- Sensori di Pressione
# Controllori:
- Arduino
- Unità centralizzata di calcolo (PC)
# Attuatori:
- Interruttori
- Motori
- Relè
- Attuatori lineari
# Interfacce:
- Radiocomandi / Telecomandi.
- Interfaccia Smartphone / Web.
15
5.3. IL PLASTICO
Il plastico che sono andato a realizzare è interamente costruito
in legno (compensato di pioppo), la base è di compegnsato
spesso circa 1cm così da poter reggere l’intera struttura che
verrà poi montata sopra, le pareti invece sono composte di due
strati di spessore 4mm tra le quali c’è uno spazio vuoto di 5mm
così da agevolare il passaggio dei fili. Inizialmente è stato
necessario realizzare la piantina della “casa ideale” in modo da
avere una base su cui lavorare. La piantina realizzata
all’AutoCAD è stata poi ricalcata sul basamento in legno, così
da avere i contorni dell’appartamento ben definiti e già pronti
per effettuare le misurazioni.
Il secondo “step” è stato quello di andare a realizzare gli scorci
di muro che compongono ogni singola stanza, ritagliandoli, con
un seghetto da traforo a mano, da tavole di compensato da
4mm. I pezzi di legno tagliati ovviamente sono stati rifiniti con
una lima o con della carta vetrata così da avere pareti
perfettamente lisce su tutti i lati. Una volta ultimato questo
lavoro le pareti sono state incollate in modo da formare tutte le
stanze presenti nella piantina, utilizzando una speciale colla per
il legno. A quel punto si avranno tutte le stanze della casa
pronte, ma allo stesso tempo separate tra loro.
Ho scelto di operare in stanze separate così da agevolare
l’implemento dei circuiti di illuminazione e sorveglianza che
sono elementi che necessitano di essere montati direttamente
alle pareti.
Il passaggio successivo della realizzazione delle singole stanze è
l’inserimento dell’impianto di illuminazione, ovvero sono stati
forati i muri in modo da lasciare i LED d’illuminazione visibili
e i fili con le saldutare nascosti alla vista che si trovano
dall’altra parte della parete. Su una parete è stato anche inserito
16
il sensore di movimento (PIR), il quale è stato montato con la
stessa logica con cui sono stati messi i LED, ovvero il sensore a
vista e il circuito con i collegamenti nascosti dietro.
Per concludere la realizzazione del plastico ho incollato le
stanze al basamento aggiuengendo anche, all’esterno, due
cabine predisposte per contenere LCD e la pulsantiera. A
questo punto il plastico è pronto, non rimane che mettere sotto
la base due quadrati di rame che saranno i punti di raccordo di
tutte le alimentazioni e le masse che saranno necessarie per
saldare i fili. Adesso si passa al circuito con l’Arduino, al quale
poi verranno collegati anche altri sensori, ovvero il sensore di
gas, quello di umidità e anche quello di temperatura con
annesso circuito stampato.
Schema
approsimativo
delle stanze e
della posizione
dei LED e dei
sensori
all’interno
dell’abitazione
17
5.4. ARDUINO
“Arduino is an open-source electronics prototyping
platform based on flexible, easy to use hardware and
software. It's intended for artists, designers, hobbyists
and anyone interested in creating interactive objects or
environments.” – Arduino.cc
Arduino, è una piattaforma di prototipazione open source,
facile da usare. Realizzata per designer, artisti, hobbisti e
chiunque interessato a creare ambienti e oggetti interattivi.
Arduino interagisce con l’ambiente ricevendo input dai
sensori. E’ capace di controllare luci, motori e attuatori di ogni
genere. E’ facilmente programmabile, con un linguaggio simile
al C, da un ambiente di sviluppo (IDE) progettato
appositamente per arduino. Dall’IDE si scrive codice per il
microcontrollore di Arduino, lo si testa e lo si carica sulla
board. Arduino è un marchio registrato, la board tuttavia è
open source, sono disponibili online gli schemi elettrici, è
possibile comprarla assemblata o costruirsela da soli, con pochi
pezzi di elettronica. I modelli di Arduino disponibili sono
molti, ognuno con le proprie caratteristiche e particolari
specifiche che li rendono più o meno adatti a varie tipologie di
progetto.
18
Per realizzare il circuito sono state utilizzate due board di
Arduino: Arduino Mega, fornita di molti PIN di I/O, e
Arduino Nano, molto più piccola e compatta.
La prima e più semplice da programmare è stata la shield di
Arduino Nano, dato che quest’ultima ha solo il compito di
controllare il tastierino numerico per l’attivazione dell’allarme.
Ovvero controlla la password inserita nel tastierino e, come i
veri allarmi antifurto, se è corretta l’allarme viene attivato o
disattivato a seconda della situazione, altrimenti si ha un
tempo limitato per reimpostarla prima che l’allarme scatti.
Il successivo passo è stato quello di programmare l’Arduino
Mega, un procedimento al quanto complesso, dato che gestirà
l’intero impianto domotico.
-Segue codice programma-
19
#include <LiquidCrystal.h>
#include <Servo.h>
#include <Keypad.h>
#include <dht.h>
#include <IRremote.h>
#define dht_dpin A7
dht DHT;
LiquidCrystal lcd(8, 9, 5, 4, 3, 2);
Servo myservo1;
Servo myservo2;
Servo myservo3;
Servo myservo4;
int FotoPin = A0; //Ingresso analogico della fotoresistenza
int FotoValue;
int ledPinluce = 52; //LED del sensore di luminosità
#define LM35_TEMP 8 // Pin analogico 0
#define LM35_REF 9 // Pin analogico 1
float temperatura; // variabile in cui viene salvata la temperatura in gradi centigradi
float prev_temperatura = 0; // temperatura precendente
int ref; // valore della tensione di riferimento dei due diodi
int ref_medio = 0; // valore della tensione di riferimento medio
int sensoreTemperatura; // valore di tensione letto dal pin OUT del sensore
int sensoreTemperatura_medio = 0; // valore sensoreTemperatura medio
int cont; //contatore usato per ottenere un valore medio
int ledPintemp = 53; //LED rosso della temperatura
int TermoTrim = A5;
int umidita = 55; //Umidità
byte termometro[8] = //icona di un termometro
B00100,
B01010,
B01010,
B01110,
B01110,
B11111,
B11111,
B01110,
;
byte goccia[8] = //icona di una goccia d'acqua
B00100,
B00100,
B01010,
B01010,
B10001,
B10001,
B10001,
B01110,
;
byte lampadina1[8] = //icona di una goccia d'acqua
B01001,
B00010,
B10100,
B00100,
20
B10010,
B00001,
B00001,
B00000,
;
byte lampadina2[8] = //icona di una goccia d'acqua
B10010,
B01000,
B00101,
B00100,
B01001,
B10000,
B10000,
B00000,
;
int buzzer = 6; //buzzer connesso al pin 6
const int Puls1 = 22;
const int LEDallarme = 48;
int pirPin = 7; //il PIN di Arduino a cui è collegato il sensore
int ALLARME;
int val1 = 0;
int vecchio_val1 = 0;
int stato1 = 0;
int RECV_PIN = 51;
const long CHM = 0xFFA25D; //Motore porta 1
const long CH = 0xFF629D; //Luce stanza 1 ON
const long CHP = 0xFFE21D; //Luce stanza 1 OFF
const long PREV = 0xFF22DD; //Motore porta 2
const long NEXT = 0xFF02FD; //Luce stanza 2 ON
const long PLAY = 0xFFC23D; //Luce stanza 2 OFF
const long VOLM = 0xFFE01F; //Motore porta 3
const long VOLP = 0xFFA857; //Luce stanza 3 ON
const long EQ = 0xFF906F; //Luce stanza 3 OFF
const long ZERO = 0xFF6897; //Motore porta 4
const long CENTO = 0x9867; //Luce stanza 4 ON
const long DUECENTO = 0xFFB04F; //Luce stanza 4 OFF
const long UNO = 0xFF30CF;
const long DUE = 0xFF18E7; //Luce stanza 5 ON
const long TRE = 0xFF7A85; //Luce stanza 5 OFF
const long QUATTRO = 0xFF10EF;
const long CINQUE = 0xFF38C7; //Luce stanza 6 ON
const long SEI = 0xFF5AA5; //Luce stanza 6 OFF
const long SETTE = 0xFF42BD;
const long OTTO = 0xFF4AB5; //Luce stanza 7 ON
const long NOVE = 0xFF52AD; //Luce stanza 7 OFF
IRrecv irrecv(RECV_PIN);
decode_results results;
int bluerx = 0;
int flag = 0;
int sensorefumo = A15;
int sensorValue = 0;
void setup()
Serial.begin(9600);
21
irrecv.enableIRIn(); // Start the receiver
myservo1.attach(10); // Imposta il servo al pin 10
myservo2.attach(11);
myservo3.attach(13);
myservo4.attach(14);
pinMode(ledPinluce, OUTPUT);
pinMode(23, OUTPUT);
pinMode(24, OUTPUT);
pinMode(25, OUTPUT);
pinMode(26, OUTPUT);
pinMode(27, OUTPUT);
pinMode(28, OUTPUT);
pinMode(29, OUTPUT);
pinMode(30, OUTPUT);
pinMode(31, OUTPUT);
pinMode(32, OUTPUT);
pinMode(33, OUTPUT);
pinMode(34, OUTPUT);
pinMode(35, OUTPUT);
pinMode(36, OUTPUT);
pinMode(37, OUTPUT);
pinMode(49, OUTPUT);
pinMode(50, OUTPUT);
pinMode(LEDallarme,OUTPUT);
pinMode(ledPintemp, OUTPUT);
pinMode(pirPin, INPUT);
digitalWrite(pirPin, LOW);
digitalWrite(49, HIGH);
lcd.begin(20, 4);
lcd.createChar(1,termometro);
lcd.createChar(2,goccia);
lcd.createChar(3,lampadina1);
lcd.createChar(4,lampadina2);
pinMode(buzzer,OUTPUT);
pinMode(LEDallarme, OUTPUT);
pinMode(22, INPUT);
lcd.setCursor(0, 0);
lcd.print("Temperatura:");
lcd.write(1);
lcd.print(" ");
lcd.setCursor(19, 0);
lcd.print("C");
lcd.setCursor(0, 1);
lcd.print("Luce: ");
lcd.write(3);
lcd.write(4);
lcd.print(" ");
lcd.setCursor(0, 2);
lcd.print("Umidita': ");
lcd.write(2);
lcd.print(" ");
lcd.setCursor(0, 3);
lcd.print("Allarme:");
22
void loop()
//--------BLUETOOTH------
if(Serial.available() > 0)
bluerx = Serial.read();
flag=0;
//-------INFRAROSSI-------
if (irrecv.decode(&results))
Serial.println(results.value,HEX);
irrecv.resume(); // Receive the next value
//---------PORTE AUTOMATICHE---------
//---------PORTA 1---------
myservo1.write(90);
float sensorValue1 = analogRead(A1)*(5.0/1023);
// Serial.println("1");
// Serial.println(sensorValue1);
if ((sensorValue1 < 0.5) || (results.value == CHM) || (bluerx == 'A'))
myservo1.write(5);
if(flag == 0)
Serial.println("PORTA 1: aperta");
flag = 1;
else
if (bluerx == 'a')
myservo1.write(90);
if(flag == 0)
Serial.println("PORTA 1: chiusa");
flag = 1;
//---------PORTA 2---------
myservo2.write(15);
float sensorValue2 = analogRead(A2)*(5.0/1023);
//Serial.println("2");
// Serial.println(sensorValue2);
if ((sensorValue2 < 0.5) || (results.value == PREV) || (bluerx == 'B'))
myservo2.write(90);
if(flag == 0)
Serial.println("PORTA 2: aperta");
flag = 1;
else
if (bluerx == 'b')
myservo2.write(15);
23
if(flag == 0)
Serial.println("PORTA 2: chiusa");
flag = 1;
//---------PORTA 3---------
myservo3.write(90);
float sensorValue3 = analogRead(A3)*(5.0/1023);
// Serial.println("3");
// Serial.println(sensorValue3);
if ((sensorValue3 < 0.5) || (results.value == VOLM) || (bluerx == 'C'))
myservo3.write(5);
if(flag == 0)
Serial.println("PORTA 3: aperta");
flag = 1;
else
if (bluerx == 'c')
myservo3.write(90);
if(flag == 0)
Serial.println("PORTA 3: chiusa");
flag = 1;
//---------PORTA 4---------
myservo4.write(90);
// float sensorValue4 = analogRead(A4)*(5.0/1023);
// Serial.println("4");
// Serial.println(sensorValue4);
if ((results.value == ZERO) || (bluerx == 'D'))
myservo4.write(10);
if(flag == 0)
Serial.println("PORTA 4: aperta");
flag = 1;
else
if (bluerx == 'd')
myservo4.write(90);
if(flag == 0)
Serial.println("PORTA 4: chiusa");
flag = 1;
;
//---------LUCE---------
//---------ESTERNO---------
FotoValue = analogRead(FotoPin);
if ((FotoValue < 30) || (bluerx == 'E'))
digitalWrite(ledPinluce, HIGH);
24
digitalWrite(23,HIGH);
digitalWrite(24,HIGH);
digitalWrite(25,HIGH);
digitalWrite(26,HIGH);
if ((FotoValue > 30) || (bluerx == 'e'))
digitalWrite(ledPinluce, LOW);
digitalWrite(23,LOW);
digitalWrite(24,LOW);
digitalWrite(25,LOW);
digitalWrite(26,LOW);
//---------INTERNO---------
//STANZA 1
if ((results.value == CH) ||(bluerx == 'F'))
digitalWrite(27,HIGH);
digitalWrite(28,HIGH);
digitalWrite(29,HIGH);
if ((results.value == CHP)||(bluerx == 'f'))
digitalWrite(27,LOW);
digitalWrite(28,LOW);
digitalWrite(29,LOW);
//STANZA 2
if ((results.value == NEXT)||(bluerx == 'G'))
digitalWrite(30,HIGH);
digitalWrite(31,HIGH);
if ((results.value == PLAY)||(bluerx == 'g'))
digitalWrite(30,LOW);
digitalWrite(31,LOW);
//STANZA 3
if ((results.value == VOLP)||(bluerx == 'H'))
digitalWrite(32,HIGH);
if ((results.value == EQ)||(bluerx == 'h'))
digitalWrite(32,LOW);
//STANZA 4
if ((results.value == CENTO)||(bluerx == 'I'))
digitalWrite(33,HIGH);
if ((results.value == DUECENTO)||(bluerx == 'i'))
digitalWrite(33,LOW);
//STANZA 5
if ((results.value == DUE)||(bluerx == 'J'))
digitalWrite(34,HIGH);
if ((results.value == TRE)||(bluerx == 'j'))
digitalWrite(34,LOW);
25
//STANZA 6
if ((results.value == CINQUE)||(bluerx == 'K'))
digitalWrite(35,HIGH);
if ((results.value == SEI)||(bluerx == 'k'))
digitalWrite(35,LOW);
//STANZA 7
if ((results.value == OTTO)||(bluerx == 'L'))
digitalWrite(36,HIGH);
digitalWrite(37,HIGH);
if ((results.value == NOVE)||(bluerx == 'l'))
digitalWrite(36,LOW);
digitalWrite(37,LOW);
//------TEMPERATURA------
int soiatemp = map (analogRead (TermoTrim),0,1023,0,40);
if (bluerx == 'R')
Serial.print("Il riscaldamento si accende a ");
Serial.print(soiatemp);
Serial.println("°C");
bluerx = 'r';
for( cont = 0; cont < 10; cont++)
sensoreTemperatura = analogRead(LM35_TEMP); // lettura della tensione del pin OUT LM35
sensoreTemperatura_medio += sensoreTemperatura; //sommatoria dei valori
ref = analogRead(LM35_REF); // lettura della tensione di riferimento
ref_medio += ref; // sommatoria dei valori
delay(50); // intervallo di campionamento
//la lettura durera' 10 (numero di campioni) x 50ms (intervallo tra due campioni) = 500ms
if(cont == 10) // quando ho sommato i dieci valori campionati si esegue:
cont = 0; // azzeramento contatore, per far ripartire il successivo campionamento
// media della sommatoria dei dieci valori campionati di ref e sensoreTemperatura
sensoreTemperatura_medio = sensoreTemperatura_medio / 10;
ref_medio = ref_medio / 10;
// conversione dei valori medi misurati in una temperatura in gradi centigradi
temperatura = (sensoreTemperatura_medio - ref_medio) * 100/2.56;
temperatura = temperatura * 5/1024;
// valore di temperatura che verra' mostrato quando si e' in fase di campionamento
//e non c'e' una temperatura disponibile
prev_temperatura = temperatura;
// prima di un successiva acquisizione e media questi valori vanno azzerati
sensoreTemperatura_medio = 0;
ref_medio = 0;
else
temperatura = prev_temperatura;
temperatura = temperatura - 7;
26
if (temperatura < soiatemp)
// if (temperatura < 20)
digitalWrite(ledPintemp, HIGH);
else
digitalWrite(ledPintemp, LOW);
if (bluerx == 'T')
Serial.print("La temperatura è di ");
Serial.print(temperatura);
Serial.println("°C");
bluerx = 't';
//----------UMIDITA--------------
DHT.read11(dht_dpin);
if (bluerx == 'U')
Serial.print("L'umidità è al ");
Serial.print(DHT.humidity);
Serial.println("%");
bluerx = 'u';
//----------ALLARME---------------
if (digitalRead(Puls1)==HIGH)
if (ALLARME == LOW)
ALLARME = HIGH;
digitalWrite(LEDallarme, HIGH); //Accende il LED dell'accensione dell'allarme
digitalWrite(49, LOW);
lcd.setCursor(12, 3);
lcd.print(" ATTIVO ");
if(digitalRead(pirPin) == HIGH)
Serial.println("ALLARME");
lcd.setCursor(0, 3);
lcd.print("-------ALLARME------");
digitalWrite(buzzer,HIGH);
delay(100);
digitalWrite(buzzer,LOW);
delay(500);
digitalWrite(buzzer,HIGH);
delay(100);
digitalWrite(buzzer,LOW);
delay(100);
else
lcd.setCursor(0, 3);
lcd.print("Allarme: ATTIVO ");
if (digitalRead(Puls1)==LOW)
lcd.setCursor(0, 3);
27
lcd.print("Allarme: INATTIVO ");
if (ALLARME == HIGH)
ALLARME = LOW;
digitalWrite(LEDallarme, LOW); //Spegne il LED dell'allarme
digitalWrite(49, HIGH);
lcd.setCursor(0, 3);
lcd.print("Allarme:");
lcd.setCursor(12, 3);
lcd.print("INATTIVO");
if(bluerx == 'S')
if (digitalRead(Puls1)==HIGH)
Serial.println("Sistema di allarme: ATTIVO");
else
Serial.println("Sistema di allarme: INATTIVO");
bluerx='s';
//----------GAS---------------
sensorValue = analogRead(sensorefumo);
//Serial.println(sensorValue, DEC);
if (sensorValue > 700)
digitalWrite(50, HIGH);
else
digitalWrite(50, LOW);
if(bluerx == 'V')
if (sensorValue > 700)
Serial.println("Perdita di GAS probabilmente nociva");
else
Serial.println("GAS a livelli normali");
bluerx='v';
//-------DISPLAY-------
//DTMP
lcd.setCursor(14, 0);
lcd.print(temperatura);
lcd.setCursor(18, 0);
lcd.print((char)223);
//DLUCE
lcd.setCursor(15, 1);
if (FotoValue < 30)
lcd.print("ON ");
else
lcd.print("OFF");
//DUMI
if (DHT.humidity > 0)
lcd.setCursor(15, 2);
lcd.print(DHT.humidity);
lcd.setCursor(17, 2);
lcd.print("% ");
28
5.6. DESCRIZIONE DEI SINGOLI IMPIANTI
5.6.1. IMPIANTO DI ILLUMINAZIONE
Limpianto di illuminazione è composto da 18 LED bianchi,
collegati per stanze, ad esempio la camera matrimoniale
contiene 2 LED collegati in parallelo con gli anodi collegati ad
una resistenza da 150Ω e un LED che ha in serie una resistenza
da 220Ω.
[Esempio di lampadina
a LED per la casa]
Con lo stesso criterio con il quale sono stati collegati i LED
della camera matrimoniale, sono stati messi tutti gli altri LED
della casa, cioè quando necessitavano 2 LED veniva saldata la
resistenza da 150Ω invece se il LED era uno solo la resistenza
che veniva messa era da 220Ω.
L’intero impianto è azionabile da cellulare tramite l’apposita
APP via bluetooh, oppure tramite telecomando a infrarossi.
29
5.6.2. SISTEMA DI ALLARME
Per il sistema di allarme è stato utilizzato un sensore di
movimento PIR a infrarossi con un raggio di azione di circa 7
metri.
Questo componente ha 3 uscite:
una è massa, un’altra alimentazione
e l’altra uscita è stata collegata al
PIN digitale 7 dell’Arduino Mega.
Questo sensore all’uscita da un
singolo bit, alto quando viene
rilevato un movimento e basso in mancanza di
rilevamento. Quindi basterà far fare ad Arduino un controllo
del piedino per vedere se una volta attivato l’allarme c’è o no
movimento. Per l’attivazione dell’allarme invece ho utilizzato
un tastierino numerico controllato da un Arduino Nano.
30
Quest’ultimo controlla il corretto inserimento della password
nel corretto ordine, nel caso di inserimento corretto se
l’allarme è disattivato lo attiva, al contratio se è già attivato lo
disattiva. I PIN del tastierino sono collegati ai PIN dal 6 al 12
dell’Arduino Nano il quale ha poi un’uscita, ovvero il piedino
13, che manda il segnale di attivare o disattivare l’allarme
all’altro Arduino.
Ovviamente anche l’allarme è controllabile da smartphone,
grazie all’apposita APP che consente con un click di controllare
se l’allarme è attivo o disattivo.
31
#include <Keypad.h>
const byte ROWS = 4; //quattro righe
const byte COLS = 3; //tre colonne
char keyInsert[6];
// Queste variabili servono come verifica del corretto inserimento del codice
int i = 0;
int j = 0;
int s = 0;
int x = 0;
// Codice segreto
char code[7]= "0696";
char keys[ROWS][COLS] =
'1','2','3',
'4','5','6',
'7','8','9',
'*','0','#'
;
byte rowPins[ROWS] = 7,12,11,9; //i Pin a cui sono connesse le righe del KeyPad
byte colPins[COLS] = 8,6,10; // i Pin a cui sono connesse le colonne del
KeyPad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
int redPin = 5;
int greenPin = 4;
int stato = 0;
void setup()
Serial.begin(9600);
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
digitalWrite(redPin, LOW);
digitalWrite(greenPin, HIGH);
pinMode(13, OUTPUT);
void loop()
if(stato==0)
char key = keypad.getKey();
if (i==0)
i++;
if (key != NO_KEY && j<4) //4 sono i numeri da inserire
keyInsert[j]=key;
j++;
if(key == '*') //l'asterisco sarebbe il tasto invio che verifica il codice
for(s=0; s<4;s++)
if(keyInsert[s]==code[s])
x++;
if(x==4) //Quando tutti e quattro i numeri sono corretti accende il LED verde
digitalWrite(redPin, HIGH);
digitalWrite(greenPin, LOW);
Serial.println("ALLARME INSERITO");
digitalWrite(13,HIGH);
32
stato=1;
x=0;
i=0;
j=0;
else
x=0;
i=0;
j=0;
s=0;
if(stato==1)
char key = keypad.getKey();
if (i==0)
i++;
//4 sono i numeri da inserire
if (key != NO_KEY && j<4)
keyInsert[j]=key;
j++;
if(key == '*') //l'asterisco sarebbe il tasto invio che verifica il codice
for(s=0; s<4;s++)
if(keyInsert[s]==code[s])
x++;
if(x==4) //Quando tutti e quattro i numeri sono corretti accende il LED verde
digitalWrite(redPin, LOW);
digitalWrite(greenPin, HIGH);
Serial.println("ALLARME DISINSERITO");
digitalWrite(13,LOW);
stato=0;
x=0;
i=0;
j=0;
else
x=0;
i=0;
j=0;
s=0;
33
5.6.3. AUTOMATIZZAZIONE INFISSI
Gli infissi, più nello specifico le porte, sono automatizzati
grazie a dei sensori di passaggio che quando rilevano una
presenza fanno si che le porte si aprano.
I sensori posizionati nei pressi delle porte sono composti di un
trasmettitore infrarosso (TIL31B) e ovviamente anche un
ricevitore ( TIL81).
Il trasmettitore basta semplicemente alimentarlo, mettendo il +
all’alimentazione e al piedino negativo ha collegate due
resistenze in parallelo da 68Ω.
34
Il ricevitore invee ha bisogno del transistor BC547B, infatti
l’anodo del ricevitore va messo al piedino centrale del
transistor, il quale avrà un pin all’alimentazione e l’altro che
con una resistenza da 1kΩ andrà collegato a massa e
contemporaneamente sarà anche collegato al PIN analogico di
Arduino. Le porte sono collegate ai PIN analogici A1, A2, A3 e
A4. Poi il programma farà si che ogni qual volta il sensore
infrarossi rilevi una presenza aprirà la relativa porta,
controllata da dei servo motori collegati ai PIN digitali 10, 11,
12 e 13. Per far funzionare i servi Arduino ha bisogna della
relativa libreria “Servo.h” che con il comando myservo.write
farà aprire o chiudere la porta fino al punto desiderato. I servi
sono di piccole dimensioni (90g) e permettono di spostare pesi
molto leggeri, quindi per porte di dimensioni reali andrebbero
usati un altro tipo di servi.
35
5.6.4. SENSORI AMBIENTE
Per i sensori d’ambiente ho utilizzato un DHT11 per l’umidità e
LM35DZ con un particolare circuito per la temperatura. In
realtà anche il sensore DHT11 oltre che all’umidità è anche un
sensore di temperatura ma non misura le temperature sotto lo
0, quindi per realizzare un sensore più reale e utilizzabile
ovunque ho dovuto aggiungere due diodi e una resistenza, così
da spostare il punto di massa dell’integrato e poter raggiungere
temperature fino a -10 C° :
Una volta collegato
l’integrato LM358N con il sensore, i diodi e le resistenze come
in figura ho programmato Arduino per far si che faccia una
media tra i due valori in uscita dal circuito e li converta in C°.
sensoreTemperatura_medio = sensoreTemperatura_medio / 10;
ref_medio = ref_medio / 10;
temperatura = (sensoreTemperatura_medio - ref_medio) * 100/2.56;
temperatura = temperatura * 5/1024;
prev_temperatura = temperatura;
sensoreTemperatura_medio = 0;
ref_medio = 0;
Questo è il codice per un singolo
campionamento, poi basta inserire
queste linee di codice all’interno di un
ciclo for per effettuare un
campionamento ogni 500ms.
36
Per l’umidità è bastato collegare il
DHT11 come nello schema e utilizzare
la libreria <dht.h> dell’Arduino così da
riderre le linee di codice ad un semplice:
DHT.read11(dht_dpin);
Serial.print(DHT.humidity);
Così visualizziamo sul monitor seriale l’umidità esatta senza
fare altri calcoli.
Come ulteriore controllo per l’ambiente ho infine inserito un
QM5 un sensore di gas, che rileva la presenza di gas
possibilmente nocivi come propano, gpl, fumo, ecc. Per
controllare questo sensore ho scritto questo codice:
sensorValue = analogRead(sensorefumo);
Serial.println(sensorValue, DEC);
if (sensorValue > 700)
digitalWrite(50, HIGH);
else
digitalWrite(50, LOW);
Ovvero basta una semplice lettura
analogica e un controllo che verifichi
che il valore che ne esce sia inferiore a
700 che è il limite nel quale la perdita
potrebbe diventare nociva dato che
supera il 50%.
37
5.6.5. INFRAROSSI
Per il controllo dell’intero impianto, come spiegato in
precendenza, ci sono differenti modi di trasmissione dati. Per lo
sviluppo di questo Prototipo ne ho utilizzati come esempi due.
Il primo di questi e il meno recente in fatto di utilizzo sul
campo, è il sistema infrarossi.
Per l’hardware di questo sistema ho utilizzato il telecomando
con apposito ricevitore. Questi collegando il ricevitore al pin 51
e assegnado all’interno del codice il medesimo pin alla variabile
“RECV_PIN”(contenuta poi nella libreria <IRemote.h>),
consente al telecomando di inviare segnali. Questi segnali
vanno poi interpretati, dato che ogni marca di telecomando
invia codici diversi. La tabella del telecomando che ho
utilizzato è:
CHM = 0xFFA25D; //Motore porta 1
CH = 0xFF629D; //Luce stanza 1 ON
CHP = 0xFFE21D; //Luce stanza 1 OFF
PREV = 0xFF22DD; //Motore porta 2
NEXT = 0xFF02FD; //Luce stanza 2 ON
PLAY = 0xFFC23D; //Luce stanza 2 OFF
VOLM = 0xFFE01F; //Motore porta 3
VOLP = 0xFFA857; //Luce stanza 3 ON
EQ = 0xFF906F; //Luce stanza 3 OFF
ZERO = 0xFF6897; //Motore porta 4
CENTO = 0x9867; //Luce stanza 4 ON
DUECENTO = 0xFFB04F; //Luce stanza 4 OFF
UNO = 0xFF30CF;
DUE = 0xFF18E7; //Luce stanza 5 ON
TRE = 0xFF7A85; //Luce stanza 5 OFF
QUATTRO = 0xFF10EF;
CINQUE = 0xFF38C7; //Luce stanza 6 ON
SEI = 0xFF5AA5; //Luce stanza 6 OFF
SETTE = 0xFF42BD;
OTTO = 0xFF4AB5; //Luce stanza 7 ON
NOVE = 0xFF52AD; //Luce stanza 7 OFF
38
Quindi dalla tabella che ho creato provando tutti i pulsanti e
segnandomi il valore ricevuto di volta in volta, si può vedere
che a ogni tasto corrisponde uno specifico codice, facendo però
attenzione che il telecomando a volte invia dei codici errati
probabilmente causati dal non perfetto antirimbalzo dei
pulsanti, quindi bisogna vedere il codice che arriva più spesso
premendo lo stesso pulsante.
Successivamente è bastato assegnare ad ogni codice ricevuto
un nome (per esempio CHM) e far eseguire una specifica
azione quando RECV_PIN riceve un determinato codice.
39
5.6.6. BLUETOOTH
Un altro sistema di trasmissione dati, per le
funzioni domotiche all’interno della casa è
il bluetooth. Il dispositivo che permette
questa funzione è l’HC06 un modulo
bluetooth per arduino.
Questo funge da monitor seriale ricevendo e
inviando testi tramite bluetooth. Quindi il
modo più semplice di utilizzarlo inizialmente è
quello di scaricare un app (BlueTerm) che
vusualizza il monitor seriale sul telefono, con
possibilità di inserire anche un testo.
Quindi sul programma basta leggere il monor seriale con il
comando Serial.read() e scrivere con il comando Serial.print() o
Serial.println(). Una volta impostati i diversi valori assegnando
una funzione a ciscuno di essi, ho verificato con l’app
BlueTerm il funzionamento. Ora per migliorare la grafica
mobile è necessario realizzare un app dal principio.
40
6. APP PER SMARTPHONE
Per la realizzazione dell’app ho utilizzato l’ambiente di
sviluppo free online, MIT App Inventor, che consente la
creazione di una applicazione utilizzando il sistema di
programmazione a blocchi.
L’app consente di accendere le luci e aprire le porte di tutta la
casa, in più permette anche di controllare la temperatura,
l’umidità e anche il sistema di allarme.
Ecco alcuni schemi della programmazione:
41
E la grafica:
42
L’applicazione è strutturata in modo da avere una schermata di
intro con il logo, poi una volta entrati nel corpo dell’app si ha
inizialmente due pulsanti che permettono l’associazione e la
disconnessione dal bluetooth dell’impianto domotico.
Successivamente come si può vedere si hanno le luci dove per
attivarle bisogna cliccare sulle rispettive icone, con un tocco
breve si accendono invece con un tocco lungo si spengono; con
la stessa logica funzionano le quattro porte della casa.
Poi si possono trovare i sensori ambiente, ovvero: temperatura,
riscaldamento, umidità e gas. Questi sensori funzionano
cliccando sul nome del sensore e una volta fatto viene
visualizzato subito sotto il vaolre in un label a sfondo bianco.
L’allarme funziona come i sensori ambiente ovvero quando si
clicca sulla parola “Verifica Allarme” viene visualizzata sotto la
situazione attuale dell’allarme.
Alla fine del corpo dell’applicazione c’è il pulsante
“impostazioni” questo permette di vedere con quale logica sono
settati i comandi per l’invio al seriale di Arduino.
Per il momento visualizza solo i valori attuali che in futuro
potrebbero essere sostituiti con delle variabili presonalizzabili a
piacimento dall’utente, in modo da essere più versatile e
utilizzabile in ogni situazione e/o impianto.
43
All’interno dell’app, ultimo in ordine di creazione, come si può
vedere dall’ultima schermata è situato il pulsante per i comandi
vocali. Sotto di questo pulsante c’è una spunta “Feedback
Vocale”; questa spunta quando è disatttivata basterà premere
sul pulsante subito sopra e pronunciare l’azione desiderata e
Arduino eseguirà. Invece diventa molto più complessa
l’operazione quando la spunta è attiva, dato che il database di
domanda-risposta è molto più ampio e permette anche
domande al di fuori della propria abitazione, ad esempio le
condizioni meteo delle giornate future o i luoghi di interesse
più vicini, tutto questo lo fa appoggiandosi a dei siti online.
Questo assistente volcale l’ho implementato con una serie di
risposte random ogni domanda fatta, cioè quando gli si pone un
quesito l’app sceglierà una tra tre o più risposte preinserite in
maniera casuale gestendo molte variabili locali che definiscono
le singole risposte.
L’app è disponibile già da qualche settimana sull’APP STORE
GOOGLE quindi su tutti gli smartphone Android,
indifferentemente dalla versione del OS utilizzato, dalla 2.2 alla
5.0.
44
7. CONCLUSIONI E SVILUPPI FUTURI
Il progetto è completamente funzionanate e permette anche
miglioramenti e sviluppi futuri che possono essere:
- Autenticazione migliorata tramite tecnologia RFID.
- Aggiunta di nuove funzionalità al sistema domotico.
- Aggiunta di nuovi sensori.
- Miglioramento del sistema di riscaldamento della casa in
modo da poter prevedere l’accensione anticipata di
termosifoni o climatizzatori.
- Miglioramento del sistema dei comandi vocali.
- Applicazioni in scala 1:1 per impianti reali.
Tutti questi miglioramenti sono applicabili senza enormi
difficoltà, avendo un budget economico consistente, dato che
per far muovere una porta vera o aprire una serranda
automaticamente si necessita di motori potenti e di costo
abbastanza sostenuto.
Le nuove funzionalità da poter inserire al sistema sono
l’automatizzazione di serrande a scorrimento e serrande a
bascula, che per ovvi problemi di dimensioni non ho potuto
inserire nel mio impianto. Come sensori invece si potrebbe
aggiungere ad esempio un sensore atmosferico che permetta
alla casa di sapere in tempo reale se sta piovendo o se c’è il
sole, così da poter agire di conseguenza su serrande porte ecc.
Il miglioramento dei comandi vocali consiste nel ingrandire il
database di frasi che l’app conosce.
Questi sono solo alcuni esempi di come si potrebbe ampliare il
progetto, in realtà le effettive migliorie sono pressocchè
infinite!
45
8. BIBLIOGRAFIA
www.michelangelomezzelani.altervista.org
www.domotica.it
www.domotica.ch
www.intrage.it
www.bticino.it
www.came.com
www.arduino.cc