realització i d'una -...
TRANSCRIPT
Tutor: Jordi Sellarès Gonzàlez
Disseny, realització i posada a punt d'una alarma domèstica Albert Montsant Fernàndez 10/01/2012
2
Agraïments Vull aprofitar per agrair a Jordi Sellarès Gonzàlez tant per donar‐me l’oportunitat de fer aquest projecte, com per la seva inestimable guia i ajuda. Sense la cual, crec que hagués sigut impossible completar‐lo. Tanmateix, el seu compromís per resoldre dubtes i la seva sempre disponibilitat per quedar i seguir avançant.
També vull donar les gràcies a Juan Sala del departament de Física per ajudar a fer el primer prototip de caixa.
I per últim, a Maximilian Salich di Francesca i l’empresa Dic‐Inox per la creació de la caixa definitiva.
3
Índex 1. Introducció
1.1. Justificació del projecte.............................................................................................5 1.2. Antecedents..............................................................................................................5 1.3. Objectius....................................................................................................................6 1.4. Descripció del general...............................................................................................6
2. Disseny
2.1. Metodologia emprada................................................. .............................................7 2.2. Hardware...................................................................................................................8
3. Software
3.1. Descodificació instruccions......................................................................................22 3.2. Sensor de presencia................................................. ...............................................26 3.3. Recepció SMS................................................. .........................................................27 3.4. Emissió SMS................................................. ...........................................................29 3.5. Presencia instruccions.............................................................................................31 3.6. Teclat prova.............................................................................................................36 3.7. Teclat bàsic................................................. ............................................................38 3.8. Teclat pin.................................................................................................................41 3.9. Presencia instruccions SMS.....................................................................................46 3.10. Presencia instruccions teclat pin.......................................................................56 3.11. Presencia instruccions SMS teclat pin...............................................................65 3.12. Presencia instruccions SMS teclat pin LCD........................................................79
4. Resultats
4.1. Àmbit d’utilització....................................................................................................96 4.2. Validació dels dissenys.............................................................................................96 4.3. Descripció del funcionament.................................................................................103 4.4. Aplicacions del projecte.........................................................................................103 4.5. Estudi de mercat....................................................................................................104
5. Comentaris
5.1. Plà de treball..........................................................................................................106 5.2. Llista de material....................................................................................................107 5.3. Pressupost..............................................................................................................109 5.4. Fites aconseguides.................................................................................................110 5.5. Conclusions............................................................................................................111 5.6. Millores Futures.....................................................................................................111
4
6. Bibliografia
A. Bibliografia.............................................................................................................113 B. Llenguatge dels programes....................................................................................114 C. “Datasheets” dels components.............................................................................116
5
1. Introducció
1.1. Justificació del projecte
Els últims anys han augmentat molt la quantitat de furts i robatoris. Cada cop sent més negatiu degut a la gran quantitat i l’augment que es produeixen. Per això, la seguretat s’ha convertit en un dels aspectes que més apareixen en les enquestes socials. La dada més significativa és l'augment dels oficialment denominats delictes contra el patrimoni. Les xifres obtingudes a partir de la Fiscalia General de l'Estat són eloqüents en aquest cas ja que s'observa un augment del 9,7% en un any, o el que és el mateix, es passa de les 16.270 causes de 2009 als 17.841 sumaris del passat any. D’aquesta manera, degut a la crisis econòmica i la por actual que té la humanitat en molts aspectes, degut a l’ informació pessimista que donen ja sigui via televisió, internet, premsa... sobre desastres, guerres o pobresa. Fa que la gent, cada cop estigui més insegura. Com a conseqüència, empreses com Prosegur [1] han obtingut grans beneficis i cada cop van a augmentant més. En el primer semestre d’aquest any, només amb sistemes de seguretat a fet unes ganàncies netes de 69 milions d’euros. La qual cosa ha suposat un augment del 7% respecte el mateix període de l’any anterior. Això ve donat com a resultat, de que la gent cada cop és sent més insegura. En conclusió, el sector de seguretat, no és un sector que corri perill. Contra més crisis i problemes hi hagin a aquest li anirà millor. Per això, avui en dia la majoria d’empreses que tenen com a mínim uns ingressos mitjos i tenen els productes emmagatzemats. Acostumen a tenir, un sistema de seguretat.
1.2. Antecedents
Els antecedents que s’han utilitzat en aquest projecte han estat projectes pfc d’antics alumnes del tutor Jordi Sellarés, com són “Disseny i realització d'un robot seguidor basat en Arduino” per Sergio Rico Vicente. Tenint com a objectiu la creació de robots per ajudar a fer diverses tasques humanes, sobretot ancians. També s’ha tingut en compte, el projecte pfc de Jaume Castañe Campany “Sistema d'adquisició AD/DA amb connexió USB basat en el microcontrolador Atmel AVR” ja que volia solucionar l’il∙luminació auxiliar d’un local a partir de la plataforma Arduino. I per últim, un sistema d’alarma basada amb Arduino Mega, creat per Oscar Gonzàlez. Puguen ser engegada en funció de la programació horària emmagatzemada en una memòria EEPROM. Sent capaç d’activar fins a 4 sirenes amb una seqüència preprogramada i té dos zones amb sensors de moviment PIR.
6
1.3. Objectius
El model d’alarma domèstica construida ha de constituir un prototip de les funcions que faria una, adquirida per una empresa. En la seva estructura tenen que funcionar, per una part, els components individualment i, per altre part, que funcionin conjuntament com si fos un. El model estarà programat per Wire incluït com a programa base en el Arduino Uno. Fent funciona tots els dispositius de la forma desitjada. En el present projecte es van plantejar els següents objectius:
‐ Fer una alarma domèstica amb les mateixes funcionalitats que una alarma adquirida
per una empresa.
‐ Fer un prototip amb un cost bastant inferior al que ens ha costat.
‐ Programar cada component perque actui de la forma desitjada.
‐ Un cop es van adquirint els següents components. Programar‐los perque actuin de forma optimitzada conjuntament.
‐ Analitzar que tots els elements poden treballar conjuntament.
‐ Amb un petit estudi de mercat, verificar si l’alarma domèstica pugués ser viable.
1.4. Descripció general/ Dissenys preliminars
L’alarma domèstica funciona de la següent manera:
‐ Mentre que l’alarma està engegada el sensor moviment va enregistrant senyals.
‐ Un cop detectat un moviment, envia una senyal a través del GSM enviant un SMS, al destinatari indicant‐li que algú ha entrat al teu domicili.
‐ El mateix text que serà enviat al destinatari es mostrarà per la pantalla LCD.
‐ L’alarma es pot controlar via SMS a partir del GSM. Posant: Alarma.on o alarma.on: Per engegar l’alarma Alarma.off o alarma.off: Per apagar l’alarma Alarma.info o alarma.info: Per donar informació sobre l’alarma
‐ Per últim, l’alarma també es pot controlar a partir del teclat matricial a partir del codi “1234” per engegar o apagar l’alarma. Apretant la tecla “#” dóna informació sobre l’estat de l’alarma i apretant la tecla “*” es borra el pin que estiguis introduint i es pot tornar a començar desde 0. La quantitat màxima d’oportunitats que hi ha per escriure correctament el pin son 3.
7
2. Dissenys
2.1. Metodologia Emprada La manera emprada de fer aquest projecte ha estat la següent: 1‐ Estudi sobre la creació d’una alarma domèstica, observant la gamma de
possibilitats que hi han.
2‐ Un cop fet l’estudi, s’ha tingut en compte que la millor manera es a partir d’un Arduino Uno.
3‐ S’han tingut en compte quins elements es necessitarien per realitzar correctament l’alarma domèstica.
4‐ S’ha dimensionat un circuit d’alimentació per regular la tensió d’entrada.
5‐ Partint de l’Arduino s’han anat connectant els diversos elements. S’ha
començat amb el GSM, que és el més específic.
6‐ El segon component apart del Arduino i el GSM va ser el sensor de moviment. Que un cop programat amb wire, funcionava correctament.
7‐ Després de que el sensor de moviment, detectés de forma òptima. Es va adquirir la Targeta SIM de Orange. La cual es va configurar, perquè revés missatges i actués de la forma que es volia a partir del codi del SMS. I enviés missatges en cas de qualsevol intrusió detectada a partir del sensor de moviment.
8‐ Comprovat el cas anterior, es va optar per complementar‐ho amb el teclat matricial. Per començar, es va programar perquè al polsar les tecles sortissin pel port sèrie adequadament. I després es va configurar de manera que segons el codi inscrit exerceixi de un mode o un altre.
9‐ Quan tot en conjunt funciona correctament, es va afegir la pantalla LCD. I amb Java, es va preparar perquè mostres per la pantalla els casos anteriors necessaris.
8
2.2. Hardware
Arduino Uno
Tracta d’una placa amb un microcontrolador Atmet AVR amb unes bases de hardware extern lliure, les quals es poden connectar a partir dels ports d’entrada i sortida. El software que utilitza consisteix en un entorn de desenvolupament que implementa el llenguatge de programació i un cop programat, efectua l’acció per les diferents sortides. Es pot alimentar exteriorment i per això es pot utilitzar per desenvolupar objectes interactius autònoms o pot ser connectat a programari de l'ordinador (Com per exemple: Macromedia Flash, Processing, Max/MSP, Pure Data). Les plaques es poden muntar a mà o adquirir‐se. L'entorn de desenvolupament integrat lliure es pot descarregar gratuïtament.
Descripció del Hardware:
‐ Pin de referència analògica (taronja) ‐ Senyal de terra digital (verd clar) ‐ Pines digitals 2‐13 (verd) ‐ Pines digitals 0‐1 / entrada i sortida del port sèrie: TX/RX (blau) (estàndard de comunicació sèrie IC2) ‐ Botó de reset (negre) ‐ Entrada del circuit del programador sèrie (marró) ‐ Pines d'entrada analògica 0‐5 (blava fosc) ‐ Pines d'alimentació i terra (taronja i taronja clar) ‐ Entrada de la font d'alimentació externa (9‐12V DC) – X1 (gris) Commutació entre font d'alimentació externa o alimentació a través del port USB – SV1 Port USB (vermell).
9
GSM SM5100B
El GSM5100B és un quad‐GSM de banda 850/EGSM 900/DCS 1800/PCS 1900 mòdul, permet una infinitat de possibilitats. La shield inclou tot el necessari tal com regulador de tensió, socket per a la targeta SIM i el connector d'antena. També s'inclou un botó de reset. El qual pot ser integrat a un número gran de projectes sense fil. Permet enviar missatges de text SMS i connectar‐lo mitjançant GSM/GPRS amb funcionalitats de xarxa TCP/IP mitjançant la placa Arduino, connectant una targeta SIM i una antena GSM. També té dos jumper que permeten seleccionar quins pins es volen utilitzar per a la comunicació del mòdul GSM‐SoftSerial (D2,D3) o per maquinari (D0,D1). Inclou connexions per micròfon i altaveu per si es vol utilitzar com a telèfon mòbil. Per últim, la placa GSM té un consum molt alt. Per això ha d’anar alimentat exteriorment.
Característiques:
∙ Gamma de temperatura: ‐10/55°C (operatiu), ‐40/85°C (emmagatzematge). ∙ Subministrament de Tensió: Entre 3.3V i 4.2V, de consum 3,6V.
∙ SIM Suportat targeta: 3V/1.8V targeta de SIM.
10
Pin(nombre) Pin “nom” Descripció 33 Lcd_data SPI* Dades 38 Lcd_clk SPI Rellotge 39 Lcd_rst SPI Resetejar 41 Lcd_rs Seleccionar Dades 54 Lcd_cs Activar SPI 29 Sim_da Sim* Dades 27 Sim_clk Sim Rellotge 21 Sim_rst Sim Resetejar 51 Sim_vcc Vsuplementaria SIM 19 TXD0 Transmitir dades 20 RSD0 Rebre dades 10 U0_CTS Netejar per enviar 22 U0_RTS Solicitar per enviar 52 U0_DTR Terminal de dades preparades 45 U0_DSR Conjunt de dades preparades 46 TX1 Transmitir dades 43 RX1 Rebre dades 6 ADCIN1 Convertidor A/C 8 ADCIN2 Convertidor A/C 34 Reset Resetejar 59 Power_on Mòdul Tensió engegada
11
Pin(nombre) Vmínima(V) Vnominal(V) Vmàxima(V) VBAT (Tensió bateries) 1,3,5,7 3,3 3,6 4,2
GND (Terra) 9,11,13,15,17
VCC Output (Tensió sortida) 47,6
Teclat matricial de 12 pulsadors
Teclat matricial amb 12 botons muntat en matriu, per la qual cosa és ideal per usar amb qualsevol microcontrolador interpretant els pins per esbrinar quin botó es troba apretat.
Encara que no és més que un conjunt de polsadors en files i columnes compartint alguns dels seus pins per aconseguir una notable reducció d'aquests. El teclat té 4 files i 3 columnes (4×3) però posseeix només 7 pins de connexió i 12 tecles. Com la possibilitat de posar una tecla per botó es inviable, es va optar per fer‐ho de la següent manera:
12
Esquema de configuració
Escaneja totes les tecles, si troba alguna pressionada guarda un valor numèric en la variable “botó” i després trasllada el contingut d'aquesta variable directament al port de sortida.
13
Circuit d’alimentació
Circuit senzill que pot repartir 12V no regulats i 5V regulats a DC. El transformador T1 regula la tensió principal a 12V AC . Quan el subministrament principal és disponible la bateria serà cargada via díode D3 i el regulador IC aconsegueix subministrament via díode D5. 12V i 5V DC serà disponible a les terminals de sortida. Quan el subministrament principal no és disponible la bateria subministra corrent al regulador Ic i als 12V DC a través del díode D4.També, el díode D3 bloqueja el corrent de flux invers mentes actua com a bateria. Capacitador C2 i C3 actuen com filtres.
Característiques importants:
∙ El transformador T1 pot ser un 230V AC primari, 12V secundari i poden passar fins a 3A. ∙ La capacitat C1 ha de ser valorat com a mínim 25V.
14
Pantalla LCD
Pantalla LCD de 20 caràcters i 4 línees. Utilitza el chip HD44780 d'interfície paral∙lela de 8bits. Les lletres són negres sobre fons verd. E inclou retroiluminació.
Dimensions: 9.90 x 6.05 x 1.40cm
Principals funcions dels pins en la pantalla LCD:
Pin(nombre) Simbol Funció 1 Vss Terra per LCM(GND) 2 VDD Tensió subministrada +5V 3 Vo Ajustar contrast 4 RS Registrar la selecció de señal 5 R/W Llegir/Escriure la selecció de señal 6 E Permitir señal
7‐10 DB0‐DB3 Transferir dades entre el CPU i LCD 11‐14 DB4‐DB7 Transferir dades a la CPU 15 LED+ Subministrar tensió per BKL (Ànode) 16 Led‐ Subministrar tensió per BKL (Terra)
15
Sensor de moviment
El sensor de moviment detecta a partir d’infrarojos qualsevol objecte en tota una habitació. Quan detecta algun moviment, el pin de “alarma” passa a nivell baix.
El connexionat, és el següent:
‐ Cable vermell: VCC (5 a 12V) ‐ Cable Negre: Pin “Alarma” en col∙lector obert ‐ Cable Marró: GND
16
Connexionat de tots els dispositius
17
Connexionat real de tots els dispositius
18
Caixa mecanitzada
19
Caixa mecanitzada real
20
Arduino (Acotacions necessàries)
21
GSM (Acotacions necessàries)
22
3. Software
3.1. Descodificació instruccions
Primer es fa un programa per anar agafant una per una les lletres introduïdes que entren pel
port sèrie. Ja que utilitzant el switch, o sigui introduint la paraula completa. Donava problemes
en tot moment.
Els tres components bàsics que es fan servir a l'alarma:
alarma.on: Engegar l'alarma
alarma.off: Apagar l'alarma
alarma.info: Donar informació sobre l'alarma
int inchar = 0; //Inicialitzat el caràcter a 0
void setup() {
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
}
void loop()
{
if (Serial.available() > 0) { // Si s’agafen un byte vàlid, es llegeixen anàlogues instruccions
inchar = Serial.read(); //Llegeix els caràcters pel port sèrie
//Desde aquest punt, va comparant caràcter per caràcter, així comprovant que coincideix
// els conjunts de caràcters o paraules abans mencionats: alarma.on – alarma.off –
// alarma.info
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10); //Els delays s’han anat col·locant a conseqüencia de que donava errors.
inchar = Serial.read();
if (inchar=='l') //Compara si és la lletra “l”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
23
inchar = Serial.read();
if (inchar=='r') //Compara si és la lletra “r”
{
delay(10);
inchar = Serial.read();
if (inchar=='m') //Compara si és la lletra “m”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='.') //Compara si és un punt “.”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
Serial.println(“La alarma esta engegada”); // Mostra pel monitor o pantalla del
//ordenador el escrit que està entre cometes “...”
}
else if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
Serial.println(“La alarma esta apagada”);
}
else
{
Serial.println(“Incorrecte”); // En el cas que hi hagi un error, mostrarà per
// pantalla. “Incorrecte”
}
24
}
else
{
Serial.println(“Incorrecte”);
}
}
else if (inchar=='i') //Compara si és la lletra “i”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
Serial.print(“Informacio sobre l'alarma:”);
}
else
{
Serial.print(“Incorrecte”);
}
}
else
{
Serial.print(“Incorrecte”);
}
}
else
{
Serial.print(“Incorrecte”);
}
}
else
{
25
Serial.print(“Incorrecte”);
}
}
else
{
Serial.print(“Falta un punt”); // En el cas, que al escriure les 3 definicions. Si hi ha
// un error de deixar-se un punt, aquest t’avisarà
}
}
}
}
}
}
}
}
}
26
3.2. Sensor de presencia
El programa sensor de presencia serveix per manipular correctament el sensor de moviment.
I que funcioni de forma óptima de la manera més simple possible.
Promitja les dades per evitar falsos positius i et mostra en cas de que detecti algun moviment
el sensor. Mostrarà per pantalla del monitor “Algú ha entrat”
int sensorValue = analogRead(A0); // Llegeix una entrada analògica en el pin 0
int i, value; // i: Valor que serveix per contador
// value: Valor que serveix per anar evaluant i comparant
void setup() {
// El port sèrie, comença a 9600 bps:
Serial.begin(9600);
}
void loop() {
value=0; //S’inicialitza value a 0
for (i=0; i<50; i++) { // Recerca entre 0 i 49
sensorValue = analogRead(A0); //Es promitgen les dades
value = value + sensorValue; //El valor= valor + valor promitjat
}
if(value<1){ // Si el valor es 0, significa que algu ha entrat. En el cas de que el sensor de
//moviment no detecti res. Anirà mostrant nombres més grans que 0 fins a 50.
Serial.println(“Algu ha entrat”); // Mostra per pantalla si algú ha entrat
}else{
}
}
27
3.3. Recepció SMS
Es el model de recepció de SMS. Captura els SMS que arriben al mòbil i els redirigeix a la
sortida sèrie, de manera que es puguin visualitzar des del terminal. El programa ha servit per
evaluar la correcte compatibilitat entre el GSM, el programa i el telèfon mòbil.
#define BL 1000 // S’ha definit un bloc de com a màxim 1000 caràcters. Més que suficients per
// les aplicacions que s’efectuaran
#include <NewSoftSerial.h> // És la llibreria que necessaria per efectuar les accions del telèfon
// mòbil. Aquesta llibreria no anava incluida, o sigui que es va tindre que incluir apart
NewSoftSerial cell(2,3); // Els pins d’entrada que faràn servir la llibreria serien el “2” i “3”
char mobilenumber[] = “649745610”; // En cas d’enviar un missatge, s’enviarà el nombre de
// telefon determinat. En aquest cas el meu: Albert Montsant Fernàndez
char buffer_sms[BL]; // Bloc que llegeix els caràcters en el pin del telefon mòbil
signed int last_in2 = -1; // Llegeix els caràcters d’entrada, inicialitza a “-1”
signed int last_out2 = -1; // Llegeix els caràcters de sortida, inicialitza a “-1”
int i; // i: Nombre que serveix com a comptador
char inchar2; // inchar2: Agafa els caràcters del port sèrie del telèfon mòbil
void setup()
{
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
// El port sèrie del telèfon mòbil, comença a 9600 bps
cell.begin(9600);
for(i=0;i<1750;i++){ //Recerca entre 0 i 1749
delay(20); //Espera de temps de 20ms
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
inchar2=cell.read(); //Agafa els caràctes del port del telèfon movil
Serial.print(inchar2); //Mostra per pantalla els caràcters
}
}
cell.println(“AT+CMGF=1”); // S’utilitza per donar l’ordre al GSM modem per operar el SMS
28
// en mode text
delay(200); // Espera de temps de 0,2 s
for(i=0;i<10;i++){ //Cerca entre 0 i 9
delay(20); // Espera de temps de 0,02 s
if(cell.available() >0)
{
inchar2=cell.read();
Serial.print(inchar2);
}
}
cell.println(“AT+CNMI=3,3,0,0”); // Mòdul per enviar missatges
delay(200);
for(i=0;i<10;i++){
delay(20);
if(cell.available() >0)
{
inchar2=cell.read();
Serial.print(inchar2);
}
}
Serial.println(“Inicialitzacio completada”);
cell.println(“AT+CMGD=1,4”); // Mòdul per esborrar els missatges de la bustia
Serial.println(“S’han esborrat els missatges de la bustia”);
}
void loop(){
// Recepcio d'instruccions per SMS
while (cell.available() > 0) { // Mentres el port sèrie del móvil sigui més gran que 0. Anirà fent
// el següent bucle
last_in2 = (last_in2 + 1)%BL; // Va llegint els nombres d’entrada i col·locant-los a al bloc BL
buffer_sms[last_in2]=cell.read(); // Els caràcters son guardat pel port sèrie del telèfon mòbil
}
while(last_out2!=last_in2){ // Mentres els d’entrada i els de sortida no siguin iguals. El bucle
// segueix en la següent acció.
last_out2 = (last_out2 + 1)%BL; // Va llegint els nombres de sortida i col·locant-los a al bloc BL
Serial.print(buffer_sms[last_out2]); // Mostra per pantalla els caràcters del port sèrie del
// telèfon mòbil
}
}
29
3.4. Emissió SMS
Es el model d’emissió de SMS. Envia un SMS a partir del port del telèfon mòbil per
evaluar la correcte compatibilitat entre el GSM, el programa i el telèfon mòbil.
El text SMS que arriba al telèfon mòbil és el següent: “ T’han entrat a casa”.
El destinatari del SMS, es pot canviar en qualsevol moment. Només s’hauria de cambiar
on posa “649745610” per el nou nómbre de telèfon.
#include <NewSoftSerial.h> // És la llibreria que necessaria per efectuar les accions del telèfon
// mòbil. Aquesta llibreria no anava incluida, o sigui que es va tindre que incluir apart
NewSoftSerial cell(2,3); // Els pins d’entrada que faràn servir la llibreria serien el “2” i “3”
char mobilenumber[] = “649745610”; // En cas d’enviar un missatge, s’enviarà el nombre de
// telefon determinat. En aquest cas el meu: Albert Montsant Fernàndez
int i; // i: Nombre que serveix com a comptador
char inchar2; // inchar2: Agafa els caràcters del port sèrie del telèfon mòbil
void setup()
{
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
// El port sèrie del telèfon mòbil, comença a 9600 bps
cell.begin(9600);
for(i=0;i<1750;i++){ //Recerca entre 0 i 1749
delay(20); //Espera de temps de 20ms
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
inchar2=cell.read(); //Agafa els caràctes del port sèrie
Serial.print(inchar2); //Mostra per pantalla els caràcters
}
}
cell.println(“AT+CMGF=1”); // S’utilitza per donar l’ordre al GSM modem per operar en
// mode text els SMS
delay(200); // Espera de temps de 0,2 s
for(i=0;i<10;i++){ //Cerca entre 0 i 9
delay(20); // Espera de temps de 0,02 s
30
if(cell.available() >0)
{
inchar2=cell.read();
Serial.print(inchar2);
}
}
cell.println(“AT+CNMI=3,3,0,0”); // Mòdul per enviar missatges
delay(200);
for(i=0;i<10;i++){
delay(20);
if(cell.available() >0)
{
inchar2=cell.read();
Serial.print(inchar2);
}
}
Serial.println(“Inicialitzacio completada”);
// S'esborren els missatges pendents per sortir d'un estat conegut
cell.println(“AT+CMGD=1,4”);
Serial.println(“Hem esborrat els missatges de la bustia”);
}
void loop(){
cell.print(“AT+CMGS=“); //Comanda per enviar desde el port sèrie del telèfon mòbil un SMS
cell.print(34,BYTE); // El pin 34, es el que llegeix a partir del port sèrie del mòbil
cell.print(mobilenumber); // El nombre de telèfon al qual se li enviarà el missatge
cell.println(34,BYTE); // El mateix pin 34, es el que efectua l’acció d’enviar el SMS
delay(500); // Espera de temps de 0,5 s
cell.print(“T'han entrat a casa”); // Missatge de text o SMS
// que arriba al destinatari
cell.println(26,BYTE); // El mateix pin 34, es el que efectua l’acció d’enviar el SMS
delay(15000); // Espera de temps de 15 s
Serial.println(“Acabem d'enviar un SMS”);
while(1); // Per no efectuar un nombre infinit de missatges i quan detecti el sensor de
// moviment. Només envii un missatge
}
31
3.5. Presencia instruccions
Es la combinació millorada de dos programes: Descodificació instruccions i Sensor de
Presencia.
Es fa un programa que vagi detectant pel sensor de moviment. Si l’alarma està engegada i no
detecti si l’alarma estigués parada.
Per engegara l’alarma, s’ha d’escriure a partir del port sèrie: alarma.on
Per apagar l’alarma, s’ha d’escriure a partir del port sèrie: alarma.off
I per agafar informacio sobre l’alarma en cas de intrusió: alarma.info
La informació que dónara es el temps que passarà desde l’última intrusió en milisegons
int i, value; // i: Valor que serveix per contador
// value: Valor que serveix per anar evaluant i comparant
long int ms = 0; // ms: Valor que calcula el temps que ha passat desde la última intrusió en (ms)
int sensorValue = analogRead(A0); // Llegeix una entrada analògica en el pin 0
int inchar = 0; // Caràcters que es llegeixen pel port sèrie
boolean flag=false; //Si l’alarma està apagada o engegada
boolean intrusio=false;//Si intrusió = false (el sensor de moviment no ha detectat res)
//Si intrusio = true (el sensor de moviment ha detectat moviment)
boolean intacte=true; // Si intacte = true (el sensor de moviment podrà detectar)
// si intacte = false (el sensor de moviment ja no podrà detectar)
void setup()
{
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
}
void loop(){
//Promitja les dades per evitar falsos positius.
if(flag){ // Si l’alarma està engegada, es fà la següent acció
value=0; //S’inicialitza value a 0
for (i=0; i<50; i++) { // Recerca entre 0 i 49
sensorValue = analogRead(A0); //Es promitgen les dades
32
value = value + sensorValue; //El valor= valor + valor promitjat
}
if(value<1){ // Si el valor és 0, el sensor de moviment ha detectat
if(intacte){ // Si el sensor de moviment està en funcionament
Serial.println(“Algu ha entrat”);
intacte=false; // Sensor de moviment apagat
}
intrusio=true; //El sensor de moviment ha detectat
ms = millis(); // Temps que ha passat desde la última intrusió
}else{
intrusio=false; // El sensor de moviment no ha detectat res
}
}
if (Serial.available() > 0) { //Si és més gran que 0, es retornen el nombre de bytes (caràcters)
// Disponibles per ser llegits pel port sèrie
inchar = Serial.read(); //Llegeix els caràcters pel port sèrie
//Desde aquest punt, va comparant caràcter per caràcter, així comprovant que coincideix
// els conjunts de caràcters o paraules abans mencionats: alarma.on – alarma.off –
// alarma.info
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10); //Els delays s’han anat col·locant a conseqüencia de que donava errors.
inchar = Serial.read();
if (inchar=='l') //Compara si és la lletra “l”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='r') //Compara si és la lletra “r”
{
delay(10);
inchar = Serial.read();
if (inchar=='m') //Compara si és la lletra “m”
33
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='.') //Compara si és un punt “.”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
Serial.println(“La alarma esta engegada”); // Mostra pel monitor o pantalla del
//ordenador el escrit que està entre cometes “...”
}
else if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
Serial.println(“La alarma esta apagada”);
}
else
{
Serial.println(“Incorrecte”); // En el cas que hi hagi un error, mostrarà per
// pantalla. “Incorrecte”
}
}
else
{
Serial.println(“Incorrecte”);
}
}
34
else if (inchar=='i') //Compara si és la lletra “i”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
Serial.println(“Informacio:”); // Mostra per pantalla “Informació”
if(flag){ // Si l’alarma està engada
if (ms>0){ // Si el temps que ha passat abans de la última intrusió és més de
// 0ms
Serial.print(“La darrera intrusio va tenir lloc fa “);
Serial.print(millis()-ms); // Milisegons que han passat desde la última
// intrusió
Serial.print(“ milisegons \n”); // El “\n” es el mateix que el “println” que
// vol dir que mostra per pantalla una línea a sota
}else{
Serial.print(“No ha entrat ningu \n”);
}
}else{
Serial.print(“Potser que engeguis la alarma \n”);
}
}
else
{
Serial.println(“Incorrecte”);
}
}
else
{
Serial.println(“Incorrecte”);
}
}
35
else
{
Serial.println(“Incorrecte”);
}
}
else
{
Serial.println(“Incorrecte”);
}
}
else
{
Serial.println(“Falta un punt”);
}
}
}
}
}
}
}
}
36
3.6. Teclat prova
Aquest programa ha servit per comprovar que les dades mostrades pel monitor. Corresponen
a les tecles apretades del teclat a partir del port sèrie.
El problema principal, es que un cop apretada una tecla. Mostra per pantalla desmesuradament
una gran quantitat de nombres repetits.
void setup() {
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
delay(1000); // Espera de temps de 1 s
pinMode(4, OUTPUT); // Envia el pin digital “4”com a sortida
pinMode(5, OUTPUT); // Envia el pin digital “5”com a sortida
pinMode(6, OUTPUT); // Envia el pin digital “6”com a sortida
pinMode(7, OUTPUT); // Envia el pin digital “7”com a sortida
pinMode(8, INPUT); // Envia el pin digital “8”com a entrada
pinMode(9, INPUT); // Envia el pin digital “9”com a entrada
pinMode(10, INPUT); // Envia el pin digital “10”com a entrada
}
void loop(){
digitalWrite(4, HIGH); // Escriu el pin digital “4” en funcionament
if (digitalRead(8) == HIGH) { // Si es retorna el valor “8” del pin dígital “4”
Serial.print (“1”); // Es mostra per pantalla “1”
}
if (digitalRead(9) == HIGH) { // Si es retorna el valor “9” del pin dígital “4”
Serial.print (“2”); // Es mostra per pantalla “2”
}
if (digitalRead(10) == HIGH) { // Si es retorna el valor “10” del pin dígital “4”
Serial.print (“3”); // Es mostra per pantalla “3”
}
digitalWrite(4, LOW); // Escriu el pin digital “4” com ha apagat
digitalWrite(5, HIGH); // Escriu el pin digital “5” en funcionament
if (digitalRead(8) == HIGH) { // Si es retorna el valor “8” del pin dígital “5”
37
Serial.print (“4”); // Es mostra per pantalla “4”
}
if (digitalRead(9) == HIGH) { // Si es retorna el valor “9” del pin dígital “5”
Serial.print (“5”); // Es mostra per pantalla “5”
}
if (digitalRead(10) == HIGH) { // Si es retorna el valor “10” del pin dígital “5”
Serial.print (“6”); // Es mostra per pantalla “6”
}
digitalWrite(5, LOW); // Escriu el pin digital “5” com ha apagat
digitalWrite(6, HIGH); // Escriu el pin digital “6” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “6”
Serial.print (“7”); // Es mostra per pantalla “7”
}
if (digitalRead(9) == HIGH) { // Si es retorna el valor “9” del pin dígital “6”
Serial.print (“8”); // Es mostra per pantalla “8”
}
if (digitalRead(10) == HIGH) { // Si es retorna el valor “10” del pin dígital “6”
Serial.print (“9”); // Es mostra per pantalla “9”
}
digitalWrite(6, LOW); // Escriu el pin digital “6” com ha apagat
digitalWrite(7, HIGH); // Escriu el pin digital “7” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “7”
Serial.print (“*”); // Es mostra per pantalla “*”
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
Serial.print (“0”); // Es mostra per pantalla “0”
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “7”
Serial.print (“#”); // Es mostra per pantalla “#”
delay(1000);
}
digitalWrite(7, LOW); // Escriu el pin digital “7” com ha apagat
}
38
3.7. Teclat bàsic
Aquest programa ha servit per comprovar que les dades mostrades pel monitor. Corresponen
a les tecles apretades del teclat a partir del port sèrie.
S’ha solucionat el problema del programa anterior, teclat prova. Que mostrava una gran
quantitat de repeticions seguides. La manera ha estat col·locant un delay després d’entrar el
nombre o el caràcter a partir del port sèrie.
Creant una espera de 1 segons, que ha servit per evitar errors.
void setup() {
Serial.begin(9600);
delay(1000); // Espera de temps de 1 s
pinMode(4, OUTPUT); // Envia el pin digital “4”com a sortida
pinMode(5, OUTPUT); // Envia el pin digital “5”com a sortida
pinMode(6, OUTPUT); // Envia el pin digital “6”com a sortida
pinMode(7, OUTPUT); // Envia el pin digital “7”com a sortida
pinMode(8, INPUT); // Envia el pin digital “8”com a entrada
pinMode(9, INPUT); // Envia el pin digital “9”com a entrada
pinMode(10, INPUT); // Envia el pin digital “10”com a entrada
}
void loop(){
digitalWrite(4, HIGH); // Escriu el pin digital “4” en funcionament
if (digitalRead(8) == HIGH) { // Si es retorna el valor “8” del pin dígital “4”
Serial.print (“1”); // Es mostra per pantalla “1”
delay(1000);
}
if (digitalRead(9) == HIGH) { // Si es retorna el valor “9” del pin dígital “4”
Serial.print (“2”); // Es mostra per pantalla “2”
delay(1000);
}
if (digitalRead(10) == HIGH) { // Si es retorna el valor “10” del pin dígital “4”
Serial.print (“3”); // Es mostra per pantalla “3”
delay(1000);
}
39
digitalWrite(4, LOW); // Escriu el pin digital “4” com ha apagat
digitalWrite(5, HIGH); // Escriu el pin digital “5” en funcionament
if (digitalRead(8) == HIGH) { // Si es retorna el valor “8” del pin dígital “5”
Serial.print (“4”); // Es mostra per pantalla “4”
delay(1000);
}
if (digitalRead(9) == HIGH) { // Si es retorna el valor “9” del pin dígital “5”
Serial.print (“5”); // Es mostra per pantalla “5”
delay(1000);
}
if (digitalRead(10) == HIGH) { // Si es retorna el valor “10” del pin dígital “5”
Serial.print (“6”); // Es mostra per pantalla “6”
delay(1000);
}
digitalWrite(5, LOW); // Escriu el pin digital “5” com ha apagat
digitalWrite(6, HIGH); // Escriu el pin digital “6” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “6”
Serial.print (“7”); // Es mostra per pantalla “7”
delay(1000);
}
if (digitalRead(9) == HIGH) { // Si es retorna el valor “9” del pin dígital “6”
Serial.print (“8”); // Es mostra per pantalla “8”
delay(1000);
}
if (digitalRead(10) == HIGH) { // Si es retorna el valor “10” del pin dígital “6”
Serial.print (“9”); // Es mostra per pantalla “9”
delay(1000);
}
digitalWrite(6, LOW); // Escriu el pin digital “6” com ha apagat
digitalWrite(7, HIGH); // Escriu el pin digital “7” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “7”
Serial.print (“*”); // Es mostra per pantalla “*”
delay(1000);
}
40
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
Serial.print (“0”); // Es mostra per pantalla “0”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “7”
Serial.print (“#”); // Es mostra per pantalla “#”
delay(1000);
}
digitalWrite(7, LOW); // Escriu el pin digital “7” com ha apagat
}
41
3.8. Teclat pin
Aquest programa ha servit per comprovar que les dades mostrades pel monitor. Corresponen
a les tecles apretades del teclat a partir del port sèrie.
Llavors s’ha volgut aconseguir que segons el codi teclejat, l’alarma fes una acció o altre.
Perquè es pogués manipular de la manera desitja.
Els codis utilitzats són els següents:
Per engegar o apagar l’alarma, s’ha de polsar: “1234”
Per informació s’ha de polsar: “#”
Donarà informació encara que en un primer moment s’hagi començat a escriure el pin.
Per exemple: “12#” no comptant com a nombre d’intents
Per borrar el pin, abans d’introduir-lo: “*”
El nombre d’intents màxim per posar el codi correcte és de 3 vegades. En cas, d’equivocar-se
més cops. El sistema quedarà tancat i no es podrà manipular, encara que s’escrigui després el
codi correcte
#define KBL 100 // Bloc de 100 caselles pels caràcters del teclat
char buffer_teclat[KBL]; // Bloc que llegeix els caràcters en els pins del teclat
signed int last_in2 = -1; // Llegeix els caràcters d’entrada, inicialitza a “-1”
signed int last_out2 = -1; // Llegeix els caràcters de sortida, inicialitza a “-1”
char inkey; // Llegeix els caràcters coneguts introduïts
char pin[4]; //Pin de confirmació, compte 4 caselles
char code[4] = {'1', '2', '3', '4'}; //Pin de confirmació “1234”, compte 4 caselles
int intents=0; // Nombre d’intents, inicialitza a 0
int pin_index=-1; //Nombre d’intents, per escriure el pin correcte
boolean flag = false; // Indica si l’alarma està engegada o apagada
void setup()
{
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
delay(1000); // Espera de temps de 1 s
42
pinMode(4, OUTPUT); // Envia el pin digital “4”com a sortida
pinMode(5, OUTPUT); // Envia el pin digital “5”com a sortida
pinMode(6, OUTPUT); // Envia el pin digital “6”com a sortida
pinMode(7, OUTPUT); // Envia el pin digital “7”com a sortida
pinMode(8, INPUT); // Envia el pin digital “8”com a entrada
pinMode(9, INPUT); // Envia el pin digital “9”com a entrada
pinMode(10, INPUT); // Envia el pin digital “10”com a entrada
Serial.println(“Ok, teclat inicialitzat”);
}
void loop(){
digitalWrite(4, HIGH); // Escriu el pin digital “7” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL; // Es va guardant d’un a un els caràcters o nombres
// teclejats pel teclat
buffer_teclat[last_k_in]='1'; // Es guarda el nombre “1” al bloc KBL
Serial.println(“1”); // Es mostra per pantalla “1”
delay(1000); // Espera de temps de 1s
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='2'; // Es guarda el nombre “2” al bloc KBL
Serial.println(“2”); // Es mostra per pantalla “2”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='3'; // Es guarda el nombre “3” al bloc KBL
Serial.println(“3”); // Es mostra per pantalla “3”
delay(1000);
}
digitalWrite(4, LOW); // Escriu el pin digital “4” com ha apagat
digitalWrite(5, HIGH); // Escriu el pin digital “5” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='4'; // Es guarda el nombre “4” al bloc KBL
43
Serial.println(“4”); // Es mostra per pantalla “4”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='5'; // Es guarda el nombre “5” al bloc KBL
Serial.println(“5”); // Es mostra per pantalla “5”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='6'; // Es guarda el nombre “6” al bloc KBL
Serial.println(“6”); // Es mostra per pantalla “6”
delay(1000);
}
digitalWrite(5, LOW); // Escriu el pin digital “5” com ha apagat
digitalWrite(6, HIGH); // Escriu el pin digital “6” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='7'; // Es guarda el nombre “7” al bloc KBL
Serial.println(“7”); // Es mostra per pantalla “7”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='8'; // Es guarda el nombre “8” al bloc KBL
Serial.println(“8”); // Es mostra per pantalla “8”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='9'; // Es guarda el nombre “9” al bloc KBL
Serial.println(“9”); // Es mostra per pantalla “8”
delay(1000);
}
digitalWrite(6, LOW); // Escriu el pin digital “6” com ha apagat
44
digitalWrite(7, HIGH); // Escriu el pin digital “7” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='*'; // Es guarda el caràcter “*” al bloc KBL
Serial.println(“*”); // Es mostra per pantalla “*”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='0'; // Es guarda el nombre “0” al bloc KBL
Serial.println(“0”); // Es mostra per pantalla “0”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='#'; // Es guarda el nombre “#” al bloc KBL
Serial.println(“#”);// Es mostra per pantalla “#”
delay(1000);
}
digitalWrite(7, LOW); // Escriu el pin digital “6” com ha apagat
if (last_k_in != last_k_out) { // Si el caràcter o nombre d’entrada no és igual al de sortida
last_k_out=(last_k_out + 1)%KBL; // Es van añadint un a un al bloc KBL
inkey= buffer_teclat[last_k_out]; // inkey: Els caràcters o nombre introduïts al bloc KBL
if (inkey=='#'){ // Si el caràcter és “#”
Serial.println(“Alarma informant, torna a escriure el pin”);
pin_index = -1; // Els intents per posar el pin correcte, no compten
}
else if (inkey=='*'){ // Si es posa el caràcter “*”, s’elimina tot el pin escrit en anterioritat
Serial.println(“Pin esborrat”);
pin_index = -1; // Els intents per posar el pin correcte, no compten
}
else{
pin_index = pin_index++; // Si no es posa el pin correcte, es van afegint el nombre d’intents
pin[pin_index]=inkey; // El pin es va afegint a un bloc de 4 casellas
if (pin_index==3){ // Si al escriure el pin, no s’han equivocat més de 3 vegades
pin_index = -1; // S’inicialitza amb pin_index=-1
intents++; // Es suma un intent
45
// Mostra per pantalla el nombre d’intents fins el moment
Serial.print(“Aquest es el teu intent “);
Serial.print(intents);
if(intents<=3){ // Si no s’han superat la quantitat d’intents
if(pin[0]==code[0]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “1”
if(pin[1]==code[1]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “2”
if(pin[2]==code[2]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “3”
if(pin[3]==code[3]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “4”
Serial.println(“El pin és correcte”); // Mostra per pantalla
intents=0; // El nombre d’intents, en cas d’equivocació torna a 0
}
}
}
}
if(intents!=0){ // Si hi ha un primer error, en escriure el pin
Serial.println(“Error, torna a escriure el pin”);
}
if(intents==2){ // Si hi ha un segon error, en escriure el pin
Serial.println(“Error , al escriure el pin. Tens una última oportunitat”);
}
if(intents==3){ // Si hi ha un últim error, en escriure el pin
Serial.println(“El sistema està tancat”);
}
}
else {
Serial.println(“Has fet 3 errors, posat amb contacte amb el teu distribuidor”);
}
}
}
}
}
46
3.9. Presencia instruccions SMS
Aquest programa ha servit, perque un cop el sensor de moviment detecti. Envii un SMS al
destinatari per avisar-lo de que hi ha una intrusió.
El missatge que enviarà és: “T’han entrat a casa”
Per altre banda, es pot manipular l’alarma igual que amb el port sèrie. A partir d’un SMS al
número de telèfon: “615754990” que és el número de la targeta SIM, que es va adquirir de
Orange i que està insertada al GSM a partir dels ports del telèfon mòbil.
Els codis via SMS per manipular l’alarma, són els següents:
Alarma.on o alarma.on: Per engegar l’alarma
Alarma.off o alarma.off: Per apagar l’alarma
Alarma.info o alarma.info: Per obtenir informació sobre el temps que ha passat desde l’última
intrussió en (ms). En cas de produir-se.
#define BL 100 // Bloc de 100 pels caràcters introduits
#include <NewSoftSerial.h> // És la llibreria que necessaria per efectuar les accions del telèfon
// mòbil. Aquesta llibreria no anava incluida, o sigui que es va tindre que incluir apart
NewSoftSerial cell(2,3); // Els pins d’entrada que faràn servir la llibreria serien el “2” i “3”
char mobilenumber[] = “649745610”; // En cas d’enviar un missatge, s’enviarà el nombre de
// telefon determinat. En aquest cas el meu: Albert Montsant Fernàndez
char buffer_sms[BL]; // Bloc que llegeix els caràcters en el pin del telefon mòbil
signed int last_in2 = -1; // Llegeix els caràcters d’entrada, inicialitza a “-1”
signed int last_out2 = -1; // Llegeix els caràcters de sortida, inicialitza a “-1”
int i; // Nombre que actua com a comptador
char inchar2; // Agafa els caràcters del port del teclat
int sensorValue = analogRead(A0); // Llegeix una entrada analògica en el pin 0
int value; // value: Valor que serveix per anar evaluant i comparant
long int ms = 0; // Temps que tarda desde l’última intrusió
int inchar = 0; // Agafa els caràcters del port sèrie
boolean flag=false; // Si l’alarma està engegada o apagada
boolean intrusio=false; // Si el sensor de moviment a detectat o no
boolean intacte=true; // Si el sensor de moviment dóna señal o no
void setup()
47
{
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
// El port sèrie del telèfon mòbil, comença a 9600 bps
cell.begin(9600);
// Inicialitzacio “muda”
/*
delay(3500); // Espera de temps de 3,5 s
cell.println(“AT+CMGF=1”); // S’utilitza per donar l’ordre al GSM modem per operar els SMS
// en mode text
delay(200);
cell.println(“AT+CNMI=3,3,0,0”); // Mòdul per enviar missatges
delay(200);
// Inicialitzacio “verbosa”
*/
for(i=0;i<1750;i++){ //Recerca entre 0 i 1749
delay(20); //Espera de temps de 20ms
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
inchar2=cell.read(); //Agafa els caràctes del port sèrie
Serial.print(inchar2); //Mostra per pantalla els caràcters
}
}
cell.println(“AT+CMGF=1”); // S’utilitza per donar l’ordre al GSM modem per operar els SMS
// en mode text
for(i=0;i<10;i++){ //Cerca entre 0 i 9
delay(20); // Espera de temps de 0,02 s
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
inchar2=cell.read(); //Agafa els caràctes del port sèrie
Serial.print(inchar2); //Mostra per pantalla els caràcters
}
}
cell.println(“AT+CNMI=3,3,0,0”); // Mòdul per enviar missatges
for(i=0;i<10;i++){ //Cerca entre 0 i 9
48
delay(20); // Espera de temps de 0,02 s
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
inchar2=cell.read(); //Agafa els caràctes del port sèrie
Serial.print(inchar2); //Mostra per pantalla els caràcters }
}
Serial.println(“Inicialitzacio completada”);
// S’esborren els missatges pendents per sortir d'un estat conegut
cell.println(“AT+CMGD=1,4”);
Serial.println(“Hem esborrat els missatges de la bustia”);
}
void loop(){
//Promitja les dades per evitar falsos positius
if(flag){ // Si l’alarma està engegada, es fà la següent acció
value=0; //S’inicialitza value a 0
for (i=0; i<50; i++) { // Recerca entre 0 i 49
sensorValue = analogRead(A0); //Es promitgen les dades
value = value + sensorValue; //El valor= valor + valor promitjat
}
if(value<1){ // Si el valor és 0, el sensor de moviment ha detectat
if(intacte){ // Si el sensor de moviment està en funcionament
Serial.println(“Algu ha entrat”);
intacte=false; // Sensor de moviment apagat
cell.print(“AT+CMGS=“); //Comanda per enviar desde el port sèrie del telèfon mòbil un
// SMS
cell.print(34,BYTE);
cell.print(mobilenumber); // El nombre de telèfon al qual se li enviarà el missatge
cell.println(34,BYTE);
delay(500);
cell.print(“T'han entrat a casa”);
cell.println(26,BYTE);
delay(15000);
Serial.println(“Acabem d'enviar un SMS”);
}
intrusio=true; //El sensor de moviment ha detectat
ms = millis(); // Temps que ha passat desde la última intrusió
}else{
49
intrusio=false; // El sensor de moviment no ha detectat res
}
}
//Llegeix els caràcters pel port sèrie
//Desde aquest punt, va comparant caràcter per caràcter, així comprovant que coincideix
// els conjunts de caràcters o paraules abans mencionats: alarma.on – alarma.off –
// alarma.info
if (Serial.available() > 0) { // Si s’agafen un byte vàlid, es llegeixen anàlogues instruccions
inchar = Serial.read(); //Llegeix els caràcters pel port sèrie
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10); // Espera de temps de 0,01 s
inchar = Serial.read();
if (inchar=='l') //Compara si és la lletra “l”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='r') //Compara si és la lletra “r”
{
delay(10);
inchar = Serial.read();
if (inchar=='m') //Compara si és la lletra “m”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='.') //Compara si és un punt “.”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
50
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
Serial.println(“La alarma esta engegada”); // Mostra pel monitor o pantalla del
//ordenador el escrit que està entre cometes “...”
flag=true; // Alarma engegada
}
else if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
Serial.print(“La alarma esta apagada“);
flag=false; //Alarma apagada
}
else
{
Serial.print(“Incorrecte”); // En el cas que hi hagi un error, mostrarà per
// pantalla. “Incorrecte”
}
}
else
{
Serial.print(“Incorrecte”);
}
}
else if (inchar=='i') //Compara si és la lletra “i”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
51
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
Serial.print(“Informacio:”); // Mostra per pantalla “Informació”
if(flag){ // Si l’alarma està engada
if (ms>0){ // Si el temps que ha passat abans de la última intrusió és més de
// 0ms
Serial.print(“La darrera intrusio va tenir lloc fa“);
Serial.print(millis()-ms);
Serial.print(“ milisegons \n”); // Milisegons que han passat desde la última
// intrusió
}else{
Serial.print(“No ha entrat ningu”);
}
}else{
Serial.print(“Potser que engeguis la alarma\n”);
}
}
else
{
Serial.print(“Incorrecte”);
}
}
else
{
Serial.print(“Incorrecte”);
}
}
else
{
Serial.print(“Incorrecte”);
}
}
else
{
Serial.print(“Incorrecte”);
}
}
else
52
{
Serial.print(“Falta un punt“);
}
}
}
}
}
}
}
}
// Descodifica les instruccions que li arriben pel port del telèfon mòbil.
while (cell.available() > 0) { // Si els caràcters que llegeix pel port sèrie del mòbil son mes
//grans que 0. Efectua la següent acció.
last_in2 = (last_in2 + 1)%BL; // Va llegint els nombres d’entrada i col·locant-los a al bloc BL
buffer_sms[last_in2]=cell.read();// Els caràcters son llegits pel port sèrie del telèfon mòbil
}
while(last_out2!=last_in2){ // Mentres els d’entrada i els de sortida no siguin iguals. El bucle
// segueix en la següent acció.
last_out2 = (last_out2 + 1)%BL; //Va llegint els caràcters de sortida i col·locant-los a al bloc
// BL d’un a un
inchar2=buffer_sms[last_out2]; // Els caràcters es van guardant
if (inchar2=='a' || inchar2=='A') // Compara si és el càracter “a” o “A”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='l') // Compara si és el càracter “l”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='a') // Compara si és el càracter “a”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='r') // Compara si és el càracter “r”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='m') // Compara si és el càracter “m”
{
53
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='a') // Compara si és el càracter “a”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='.') // Compara si és el càracter “.”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='o') // Compara si és el càracter “o”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='n') // Compara si és el càracter “n”
{
Serial.print(“Engengant alarma\n”);
flag=true; //Alarma engegada
}
else if (inchar2 =='f')
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='f') // Compara si és el càracter “f”
{
Serial.print(“Apagant alarma\n”);
flag=false; // Alarma apagada
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else if (inchar2=='i') // Compara si és el càracter “i”
54
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='n') // Compara si és el càracter “n”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='f') // Compara si és el càracter “f”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='o') // Compara si és el càracter “o”
{
Serial.print(“Informacio:\n”);
if(flag){ // Si l’alarma està engada
if (ms>0){ // Si el temps que ha passat abans de la última intrusió és més de
// 0ms
Serial.print(“La darrera intrusio va tenir lloc fa “);
Serial.print(millis()-ms); // Milisegons que han passat desde la última
// intrusió
Serial.print(“milisegons \n”);
}else{
Serial.print(“No ha entrat ningu \n”);
}
}else{
Serial.print(“Hauries d'engegar la alarma \n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
55
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Falta un punt\n”);
}
}
}
}
}
}
}
}
}
56
3.10. Presencia instruccions teclat pin
Aquest programa ha servit per mostrar que l’alarma es pot manipular pel port sèrie. Amb el
codi:
alarma.on: Per engegar l’alarma
alarma.off: Per apagar l’alarma
alarma.info: Per donar informació sobre el temps desde l’última intrusió en (ms)
Per altre banda, es pot manipular les accions del sensor de moviment a partir del teclat
introduïts els codis següents:
Per engegar o apagar l’alarma, s’ha de polsar: “1” ”2” ”3” ”4”
Per informació s’ha de polsar: “#”
Donarà informació encara que en un primer moment s’hagi començat a escriure el pin.
Per exemple: “12#” no comptant com a nombre d’intents
Per borrar el pin, abans d’introduir-lo: “*”
El nombre d’intents màxim per posar el codi correcte és de 3 vegades. En cas, d’equivocar-se
més cops. El sistema quedarà tancat i no es podrà manipular, encara que s’escrigui després el
codi correcte.
// El sensor de moviment, rebrà senyals. Sempre que l’alarma estigui engegada tant com
// pel port sèrie, introduint: “alarma.on”. O teclejant pel teclat “1” “2” “3” “4” si l’alarma
// està apagada.
#define KBL 100 // Bloc de 100 caselles pels caràcters del teclat
char buffer_teclat[KBL]; // Bloc que llegeix els caràcters en els pins del teclat
char inkey; // Llegeix els caràcters coneguts introduïts
char pin[4]; //Pin de confirmació, compte 4 caselles
char code[4] = {'1', '2', '3', '4'}; //Pin de confirmació “1234”, compte 4 caselles
int intents=0; // Nombre d’intents, inicialitza a 0
int pin_index=-1; //Nombre d’intents, per escriure el pin correcte
int inchar = 0; // Agafa els caràcters del port sèrie
boolean flag=false; // Si l’alarma està engegada o apagada
boolean intrusio=false; // Si el sensor de moviment a detectat o no
57
boolean intacte=true; // Si el sensor de moviment dóna señal o no
int sensorValue = analogRead(A0); // Llegeix una entrada analògica en el pin 0
int value; // value: Valor que serveix per anar evaluant i comparant
long int ms = 0; // Temps que tarda desde l’última intrusió
int i; // Nombre que actua com a comptador
signed int last_in2 = -1; // Llegeix els caràcters d’entrada, inicialitza a “-1”
signed int last_out2 = -1; // Llegeix els caràcters de sortida, inicialitza a “-1”
void setup()
{
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
pinMode(4, OUTPUT); // Envia el pin digital “4”com a sortida
pinMode(5, OUTPUT); // Envia el pin digital “5”com a sortida
pinMode(6, OUTPUT); // Envia el pin digital “6”com a sortida
pinMode(7, OUTPUT); // Envia el pin digital “7”com a sortida
pinMode(8, INPUT); // Envia el pin digital “8”com a entrada
pinMode(9, INPUT); // Envia el pin digital “9”com a entrada
pinMode(10, INPUT); // Envia el pin digital “10”com a entrada
Serial.println(“OK, teclat inicialitzat”);
}
void loop(){
digitalWrite(4, HIGH);
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL; // Es va guardant d’un a un els caràcters o nombres
// teclejats pel teclat
buffer_teclat[last_k_in]='1'; // Es guarda el nombre “1” al bloc KBL
Serial.println(“1”); // Es mostra per pantalla “1”
delay(1000); // Espera de temps de 1s
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='2'; // Es guarda el nombre “2” al bloc KBL
Serial.println(“2”); // Es mostra per pantalla “2”
delay(1000);
58
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='3'; // Es guarda el nombre “3” al bloc KBL
Serial.println(“3”); // Es mostra per pantalla “3”
delay(1000);
}
digitalWrite(4, LOW); // Escriu el pin digital “4” com ha apagat
digitalWrite(5, HIGH); // Escriu el pin digital “5” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='4'; // Es guarda el nombre “4” al bloc KBL
Serial.println(“4”); // Es mostra per pantalla “4”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='5'; // Es guarda el nombre “5” al bloc KBL
Serial.println(“5”); // Es mostra per pantalla “5”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='6'; // Es guarda el nombre “6” al bloc KBL
Serial.println(“6”); // Es mostra per pantalla “6”
delay(1000);
}
digitalWrite(5, LOW); // Escriu el pin digital “5” com ha apagat
digitalWrite(6, HIGH); // Escriu el pin digital “6” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='7'; // Es guarda el nombre “7” al bloc KBL
Serial.println(“7”); // Es mostra per pantalla “7”
delay(1000);
}
59
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='8'; // Es guarda el nombre “8” al bloc KBL
Serial.println(“8”); // Es mostra per pantalla “8”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='9'; // Es guarda el nombre “9” al bloc KBL
Serial.println(“9”); // Es mostra per pantalla “8”
delay(1000);
}
digitalWrite(6, LOW); // Escriu el pin digital “6” com ha apagat
digitalWrite(7, HIGH); // Escriu el pin digital “7” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='*'; // Es guarda el caràcter “*” al bloc KBL
Serial.println(“*”); // Es mostra per pantalla “*”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='0'; // Es guarda el nombre “0” al bloc KBL
Serial.println(“0”); // Es mostra per pantalla “0”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='#'; // Es guarda el nombre “#” al bloc KBL
Serial.println(“#”);// Es mostra per pantalla “#”
}
digitalWrite(7, LOW); // Escriu el pin digital “6” com ha apagat
if (last_k_in != last_k_out) { // Si el caràcter o nombre d’entrada no és igual al de sortida
last_k_out=(last_k_out + 1)%KBL; // Es van añadint un a un al bloc KBL
inkey= buffer_teclat[last_k_out]; // inkey: Els caràcters o nombre introduïts al bloc KBL
if (inkey=='#'){ // Si el caràcter és “#”
60
Serial.println(“Alarma informant. Torna escriure el pin”);
pin_index = -1; // Els intents per posar el pin correcte, no compten
}else if (inkey=='*'){ // Si es posa el caràcter “*”, s’elimina tot el pin escrit en anterioritat
Serial.println(“S’esborra el pin”);
pin_index = -1; // Els intents per posar el pin correcte, no compten
}
else{
pin_index = pin_index++; // Si no es posa el pin correcte, es van afegint el nombre d’intents
pin[pin_index]=inkey; // El pin es va afegint a un bloc de 4 casellas
if (pin_index==3){ // Si al escriure el pin, no s’han equivocat més de 3 vegades
pin_index = -1; // S’inicialitza amb pin_index=-1
intents++; // Es suma un intent
// Mostra per pantalla el nombre d’intents fins el moment
Serial.print(“Aquest es el teu intent “);
Serial.println(intents);
if(intents<=3){ // Si no s’han superat la quantitat d’intents
if(pin[0]==code[0]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “1”
if(pin[1]==code[1]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “2”
if(pin[2]==code[2]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “3”
if(pin[3]==code[3]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “4”
Serial.println(“El pin és correcte”);
intents=0; // El nombre d’intents, en cas d’equivocació en algun moment torna a 0
}
}
}
}
if(intents!=0){ //Si hi ha un primer error, en escriure el pin
Serial.println(“Error, torna a escriure el pin”);
}
if(intents==2){ // Si hi ha un segon error, en escriure el pin
Serial.println(“Error , al escriure el pin. Tens una última oportunitat “);
}
if(intents==3){
Serial.println(“El sistema està tancat “);
}
}
else {
Serial.println(“Has fet 3 errors, posat amb contacte amb el teu distribuidor “);
}
61
}
}
}
//Promitja les dades per evitar falsos positius.
if(flag){ // Si l’alarma està engegada, es fà la següent acció
value=0; //S’inicialitza value a 0
for (i=0; i<50; i++) { // Recerca entre 0 i 49
sensorValue = analogRead(A0); //Es promitgen les dades
value = value + sensorValue; //El valor= valor + valor promitjat
}
if(value<1){ // Si el valor és 0, el sensor de moviment ha detectat
if(intacte){ // Si el sensor de moviment està en funcionament
Serial.println(“Algu ha entrat”);
intacte=false; // Sensor de moviment apagat
}
intrusio=true; //El sensor de moviment ha detectat
ms = millis();// Temps que ha passat desde la última intrusió
}else{
intrusio=false; // El sensor de moviment no ha detectat res
}
}
//Llegeix els caràcters pel port sèrie
//Desde aquest punt, va comparant caràcter per caràcter, així comprovant que coincideix
// els conjunts de caràcters o paraules abans mencionats: alarma.on – alarma.off –
// alarma.info
if (Serial.available() > 0) { // Si s’agafen un byte vàlid, es llegeixen anàlogues instruccions
inchar = Serial.read();//Llegeix els caràcters pel port sèrie
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10); // Espera de temps de 0,01s
inchar = Serial.read();
if (inchar=='l') //Compara si és la lletra “l”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
62
if (inchar=='r') //Compara si és la lletra “r”
{
delay(10);
inchar = Serial.read();
if (inchar=='m') //Compara si és la lletra “m”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='.') //Compara si és un punt “.”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
Serial.print(“La alarma esta engegada\n”);
flag=true; // Alarma engegada
}
else if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
Serial.print(“La alarma esta apagada\n”);
flag=false; //Alarma apagada
}
else
{
Serial.print(“Incorrecte\n”); // En el cas que hi hagi un error, mostrarà per
// pantalla. “Incorrecte”
}
63
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else if (inchar=='i') //Compara si és la lletra “i”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
Serial.print(“Informacio:\n”);
if(flag){ // Si l’alarma està engada
if (ms>0){ // Si el temps que ha passat abans de la última intrusió és més de
// 0ms
Serial.print(“La darrera intrusio va tenir lloc fa “);
Serial.print(millis()-ms);
Serial.print(“milisegons \n”); // Milisegons que han passat desde la última
// intrusió
}else{
Serial.print(“No ha entrat ningu \n”);
}
}else{
Serial.print(“Potser que engeguis la alarma \n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
64
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Falta un punt\n”);
}
}
}
}
}
}
}
}
}
65
3.11. Presencia instruccions SMS teclat Pin
Aquest programa ha servit per mostrar que l’alarma es pot manipular pel port sèrie. Amb el
codi:
alarma.on: Per engegar l’alarma
alarma.off: Per apagar l’alarma
alarma.info: Per donar informació sobre el temps desde l’última intrusió en (ms)
Per altre banda, es pot manipular les accions del sensor de moviment a partir del teclat
introduïts els codis següents:
Per engegar o apagar l’alarma, s’ha de polsar: “1” ”2” ”3” ”4”
Per informació s’ha de polsar: “#”
Donarà informació encara que en un primer moment s’hagi començat a escriure el pin.
Per exemple: “12#” no comptant com a nombre d’intents
Per borrar el pin, abans d’introduir-lo: “*”
El nombre d’intents màxim per posar el codi correcte és de 3 vegades. En cas, d’equivocar-se
més cops. El sistema quedarà tancat i no es podrà manipular, encara que s’escrigui després el
codi correcte.
Indepentment, es pot manipular l’alarma igual que amb el port sèrie. A partir d’un SMS al
número de telèfon: “615754990” que és el número de la targeta SIM, que es va adquirir de
Orange i que està insertada al GSM a partir dels ports del telèfon mòbil.
Els codis via SMS per manipular l’alarma, són els següents:
Alarma.on o alarma.on: Per engegar l’alarma
Alarma.off o alarma.off: Per apagar l’alarma
Alarma.info o alarma.info: Per obtenir informació sobre el temps que ha passat desde l’última
intrussió en (ms). En cas de produir-se.
El sensor de moviment, rebrà senyals. Sempre que l’alarma estigui engegada tant com
pel port sèrie, introduint: “alarma.on”. Teclejant pel teclat “1” “2” “3” “4” si l’alarma
està apagada o per últim via SMS.
Un cop el sensor de moviment estigui engegat i detecti. Enviarà un SMS al destinatari per
66
avisar-lo de que hi ha una intrusió.
El missatge que enviarà és: “T’han entrat a casa”
#include <NewSoftSerial.h> // És la llibreria que necessaria per efectuar les accions del telèfon
// mòbil. Aquesta llibreria no anava incluida, o sigui que es va tindre que incluir apart
NewSoftSerial cell(2,3); // Els pins d’entrada que faràn servir la llibreria serien el “2” i “3”
char mobilenumber[] = “649745610”; // En cas d’enviar un missatge, s’enviarà el nombre de
// telefon determinat. En aquest cas el meu: Albert Montsant Fernàndez
#define BL 1000 // S’ha definit un bloc de com a màxim 1000 caràcters. Més que suficients per
// les aplicacions que s’efectuaran
#define KBL 100 // Bloc de 100 caselles pels caràcters del teclat
char buffer_sms[BL]; // Bloc que llegeix els caràcters en el pin del telefon mòbil
char buffer_teclat[KBL]; // Bloc que llegeix els caràcters en els pins del teclat
char inkey; // Llegeix els caràcters coneguts introduïts
char pin[4]; //Pin de confirmació, compte 4 caselles
char code[4] = {'1', '2', '3', '4'}; //Pin de confirmació “1234”, compte 4 caselles
int intents=0; // Nombre d’intents, inicialitza a 0
int pin_index=-1; //Nombre d’intents, per escriure el pin correcte
int inchar = 0; // Agafa els caràcters del port sèrie
char inchar2; // Agafa els caràcters del port del teclat
boolean flag=false; // Si l’alarma està engegada o apagada
boolean intrusio=false; // Si el sensor de moviment a detectat o no
boolean intacte=true; // Si el sensor de moviment dóna señal o no
int sensorValue = analogRead(A0); // Llegeix una entrada analògica en el pin 0
int value; // value: Valor que serveix per anar evaluant i comparant
long int ms = 0; // Temps que tarda desde l’última intrusió
int i; // Nombre que actua com a comptador
signed int last_in2 = -1; // Llegeix els caràcters d’entrada, inicialitza a “-1”
signed int last_out2 = -1; // Llegeix els caràcters de sortida, inicialitza a “-1”
void setup()
{
// El port sèrie, comença a 9600 bps
Serial.begin(9600);
pinMode(4, OUTPUT); // Envia el pin digital “4”com a sortida
67
pinMode(5, OUTPUT); // Envia el pin digital “5”com a sortida
pinMode(6, OUTPUT); // Envia el pin digital “6”com a sortida
pinMode(7, OUTPUT); // Envia el pin digital “7”com a sortida
pinMode(8, INPUT); // Envia el pin digital “8”com a entrada
pinMode(9, INPUT); // Envia el pin digital “9”com a entrada
pinMode(10, INPUT); // Envia el pin digital “10”com a entrada
Serial.println(“OK, teclat inicialitzat”);
// El port sèrie del telèfon mòbil, comença a 9600 bps
cell.begin(9600);
for(i=0;i<1750;i++){ //Recerca entre 0 i 1749
delay(20); //Espera de temps de 20ms
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció
{
inchar2=cell.read(); //Agafa els caràctes del port sèrie
Serial.print(inchar2); //Mostra per pantalla els caràcters
}
}
cell.println(“AT+CMGF=1”); // S’utilitza per donar l’ordre al GSM modem per operar el SMS
// en mode text
for(i=0;i<10;i++){ //Cerca entre 0 i 9
delay(20); // Espera de temps de 0,02 s
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
inchar2=cell.read();//Agafa els caràctes del port sèrie
Serial.print(inchar2); //Mostra per pantalla els caràcters
}
}
cell.println(“AT+CNMI=3,3,0,0”); // Mòdul per enviar missatges
for(i=0;i<10;i++){ //Cerca entre 0 i 9
delay(20); // Espera de temps de 0,02s
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
68
inchar2=cell.read(); //Agafa els caràctes del port sèrie
Serial.print(inchar2); //Mostra per pantalla els caràcters
}
}
Serial.println(“Inicialitzacio completada”);
// S'esborren els missatges pendents per sortir d'un estat conegut
cell.println(“AT+CMGD=1,4”);
Serial.println(“Hem esborrat els missatges de la bustia”);
}
void loop(){
digitalWrite(4, HIGH); // Escriu el pin digital “7” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL; // Es va guardant d’un a un els caràcters o nombres
// teclejats pel teclat
buffer_teclat[last_k_in]='1'; // Es guarda el nombre “1” al bloc KBL
Serial.println(“1”); // Es mostra per pantalla “1”
delay(1000); // Espera de temps de 1s
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='2'; // Es guarda el nombre “2” al bloc KBL
Serial.println(“2”); // Es mostra per pantalla “2”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='3'; // Es guarda el nombre “3” al bloc KBL
Serial.println(“3”); // Es mostra per pantalla “3”
delay(1000);
}
digitalWrite(4, LOW); // Escriu el pin digital “4” com ha apagat
digitalWrite(5, HIGH); // Escriu el pin digital “5” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
69
buffer_teclat[last_k_in]='4'; // Es guarda el nombre “4” al bloc KBL
Serial.println(“4”); // Es mostra per pantalla “4”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='5'; // Es guarda el nombre “5” al bloc KBL
Serial.println(“5”); // Es mostra per pantalla “5”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='6'; // Es guarda el nombre “6” al bloc KBL
Serial.println(“6”); // Es mostra per pantalla “6”
delay(1000);
}
digitalWrite(5, LOW); // Escriu el pin digital “5” com ha apagat
digitalWrite(6, HIGH); // Escriu el pin digital “6” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='7'; // Es guarda el nombre “7” al bloc KBL
Serial.println(“7”); // Es mostra per pantalla “7”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='8'; // Es guarda el nombre “8” al bloc KBL
Serial.println(“8”); // Es mostra per pantalla “8”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='9'; // Es guarda el nombre “9” al bloc KBL
Serial.println(“9”); // Es mostra per pantalla “8”
delay(1000);
}
70
digitalWrite(6, LOW); // Escriu el pin digital “6” com ha apagat
digitalWrite(7, HIGH); // Escriu el pin digital “7” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='*'; // Es guarda el caràcter “*” al bloc KBL
Serial.println(“*”); // Es mostra per pantalla “*”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='0'; // Es guarda el nombre “0” al bloc KBL
Serial.println(“0”); // Es mostra per pantalla “0”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='#'; // Es guarda el nombre “#” al bloc KBL
Serial.println(“#”);// Es mostra per pantalla “#”
delay(1000);
}
digitalWrite(7, LOW); // Escriu el pin digital “6” com ha apagat
if (last_k_in != last_k_out) { // Si el caràcter o nombre d’entrada no és igual al de sortida
last_k_out=(last_k_out + 1)%KBL; // Es van añadint un a un al bloc KBL
inkey= buffer_teclat[last_k_out]; // inkey: Els caràcters o nombre introduïts al bloc KBL
if (inkey=='#'){ // Si el caràcter és “#”
Serial.println(“Alarma informant. Torna a escriure el pin”);
pin_index = -1; // Els intents per posar el pin correcte, no compten
}
else if (inkey=='*'){ // Si es posa el caràcter “*”, s’elimina tot el pin escrit en anterioritat
Serial.println(“S’esborra el pin. Escriu-lo de nou”);
pin_index = -1; // Els intents per posar el pin correcte, no compten
}
else{
pin_index = pin_index++; // Si no es posa el pin correcte, es van afegint el nombre d’intents
pin[pin_index]=inkey; // El pin es va afegint a un bloc de 4 caselles
if (pin_index==3){ // Si al escriure el pin, no s’han equivocat més de 3 vegades
71
pin_index = -1; // S’inicialitza amb pin_index=-1
intents++; // Es suma un intent
// Mostra per pantalla el nombre d’intents fins el moment
Serial.print(“Aquest es el teu intent: “);
Serial.println(intents);
if(intents<=3){ // Si no s’han superat la quantitat d’intents
if(pin[0]==code[0]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “1”
if(pin[1]==code[1]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “2”
if(pin[2]==code[2]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “3”
if(pin[3]==code[3]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “4”
Serial.println(“El pin és correcte”); // Mostra per pantalla
intents=0; // El nombre d’intents, en cas d’equivocació en algun moment torna a 0
}
}
}
}
if(intents!=0){ // Si hi ha un primer error, en escriure el pin
Serial.println(“Error, torna a escriure el pin”);
}
if(intents==2){ // Si hi ha un segon error, en escriure el pin
Serial.println(“Error , al escriure el pin. Tens una última oportunitat”);
}
if(intents==3){ // Si hi ha un últim error, en escriure el pin
Serial.println(“El sistema està tancat”);
}
}
}
}
if(flag){ // Si l’alarma està engegada, es fà la següent acció
value=0; //S’inicialitza value a 0
for (i=0; i<50; i++) { // Recerca entre 0 i 49
sensorValue = analogRead(A0); //Es promitgen les dades
value = value + sensorValue; //El valor= valor + valor promitjat
}
if(value<1){ // Si el valor és 0, el sensor de moviment ha detectat
if(intacte){ // Si el sensor de moviment està en funcionament
Serial.println(“Algu ha entrat”);
intacte=false; // Sensor de moviment apagat
72
cell.print(“AT+CMGS=“); //Comanda per enviar desde el port sèrie del telèfon mòbil un
// SMS
cell.print(34,BYTE);
cell.print(mobilenumber); // El nombre de telèfon al qual se li enviarà el missatge
cell.println(34,BYTE);
delay(500);
cell.print(“T'han entrat a casa”);
cell.println(26,BYTE); //
delay(15000);
Serial.println(“Acabem d'enviar un SMS”);
}
intrusio=true; //El sensor de moviment ha detectat
ms = millis();// Temps que ha passat desde la última intrusió
}else{
intrusio=false; // El sensor de moviment no ha detectat res
}
}
//Llegeix els caràcters pel port sèrie
//Desde aquest punt, va comparant caràcter per caràcter, així comprovant que coincideix
// els conjunts de caràcters o paraules abans mencionats: alarma.on – alarma.off –
// alarma.info
if (Serial.available() > 0) { // Si s’agafen un byte vàlid, es llegeixen anàlogues instruccions
inchar = Serial.read();//Llegeix els caràcters pel port sèrie
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10); // Espera de temps de 0,01 s
inchar = Serial.read();
if (inchar=='l') //Compara si és la lletra “l”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='r') //Compara si és la lletra “r”
{
delay(10);
73
inchar = Serial.read();
if (inchar=='m') //Compara si és la lletra “m”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='.') //Compara si és un punt “.”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
Serial.print(“La alarma esta engegada\n”);
flag=true; // Alarma engegada
}
else if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
Serial.print(“La alarma esta apagada\n”);
flag=false; //Alarma apagada
}
else
{
Serial.print(“Incorrecte\n”); // En el cas que hi hagi un error, mostrarà per
// pantalla. “Incorrecte”
}
}
else
{
74
Serial.print(“Incorrecte\n”);
}
}
else if (inchar=='i') //Compara si és la lletra “i”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
Serial.println(“Informacio:”);
if(flag){ // Si l’alarma està engada
if (ms>0){ // Si el temps que ha passat abans de la última intrusió és més de
// 0ms
Serial.print(“La darrera intrusio va tenir lloc fa “);
Serial.print(millis()-ms);
Serial.print(“milisegons \n”); // Milisegons que han passat desde la última
// intrusió
}else{
Serial.print(“No ha entrat ningu”);
}
}else{
Serial.print(“Potser que engeguis la alarma \n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
75
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Falta un punt\n”);
}
}
}
}
}
}
}
}
while (cell.available() > 0) { // Si els caràcters que llegeix pel port sèrie del mòbil son mes
//grans que 0. Efectua la següent acció.
last_in2 = (last_in2 + 1)%BL; // Va llegint els nombres d’entrada i col·locant-los a al bloc BL
buffer_sms[last_in2]=cell.read();// Els caràcters son llegits pel port sèrie del telèfon mòbil
}
while(last_out2!=last_in2){ // Mentres els d’entrada i els de sortida no siguin iguals. El bucle
// segueix en la següent acció.
last_out2 = (last_out2 + 1)%BL; //Va llegint els caràcters de sortida i col·locant-los a al bloc
// BL d’un a un
inchar2=buffer_sms[last_out2]; // Els caràcters es van guardant
if (inchar2=='a' || inchar2=='A') // Compara si és el càracter “a” o “A”
{
last_out2 = (last_out2 + 1)%BL;
76
inchar2=buffer_sms[last_out2];
if (inchar2=='l') // Compara si és el càracter “l”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='a') // Compara si és el càracter “a”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='r') // Compara si és el càracter “r”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='m') // Compara si és el càracter “m”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='a') // Compara si és el càracter “a”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='.') // Compara si és el càracter “.”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='o') // Compara si és el càracter “o”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='n') // Compara si és el càracter “n”
{
Serial.print(“Engengant alarma\n”);
flag=true; //Alarma engegada
}
else if (inchar2 =='f')
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='f') // Compara si és el càracter “f”
77
{
Serial.print(“Apagant alarma\n”);
flag=false; // Alarma apagada
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else if (inchar2=='i')
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='n') // Compara si és el càracter “n”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='f') // Compara si és el càracter “f”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='o') // Compara si és el càracter “o”
{
Serial.print(“Informacio:\n”);
if(flag){ // Si l’alarma està engada
if (ms>0){ // Si el temps que ha passat abans de la última intrusió és més de
// 0ms
Serial.print(“La darrera intrusio va tenir lloc fa: “);
Serial.print(millis()-ms); // Milisegons que han passat desde la última
// intrusió
Serial.print(“ milisegons \n”);
}else{
Serial.print(“No ha entrat ningu \n”);
}
78
}else{
Serial.print(“Hauries d'engegar la alarma \n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Incorrecte\n”);
}
}
else
{
Serial.print(“Falta un punt\n”);
}
}
}
}
}
}
}
}
}
79
3.12. Presencia instruccions SMS teclat pin LCD
Aquest programa és el programa definitiu
És pot manipular les accions del sensor de moviment a partir del teclat
introduïts els codis següents:
Per engegar o apagar l’alarma, s’ha de polsar: “1” ”2” ”3” ”4”
Per informació s’ha de polsar: “#”
Donarà informació encara que en un primer moment s’hagi començat a escriure el pin.
Per exemple: “12#” no comptant com a nombre d’intent
Per borrar el pin, abans d’introduir-lo: “*”
El nombre d’intents màxim per posar el codi correcte és de 3 vegades. En cas, d’equivocar-se
més cops. El sistema quedarà tancat i no es podrà manipular, encara que s’escrigui després el
codi correcte.
Indepentment, es pot manipular l’alarma igual que amb el port sèrie. A partir d’un SMS al
número de telèfon: “615754990” que és el número de la targeta SIM, que es va adquirir de
Orange i que està insertada al GSM a partir dels ports del telèfon mòbil.
Els codis via SMS per manipular l’alarma, són els següents:
Alarma.on o alarma.on: Per engegar l’alarma
Alarma.off o alarma.off: Per apagar l’alarma
Alarma.info o alarma.info: Per obtenir informació sobre el temps que ha passat desde l’última
intrussió en (ms). En cas de produir-se.
El sensor de moviment, rebrà senyals. Sempre que l’alarma estigui engegada tant com
pel port sèrie, introduint: “alarma.on”. Teclejant pel teclat “1” “2” “3” “4” si l’alarma
està apagada o per últim via SMS.
Un cop el sensor de moviment estigui engegat i detecti. Enviarà un SMS al destinatari per
avisar-lo de que hi ha una intrusió.
El missatge que enviarà és: “T’han entrat a casa”
Tots els texts que sortien a partir del port sèrie pel monitor, s’han eliminat ja que no serà
necessari cap visualització i aquests es mostraran per la pantalla LCD.
80
#include <NewSoftSerial.h> // És la llibreria que necessaria per efectuar les accions del telèfon
// mòbil. Aquesta llibreria no anava incluida, o sigui que es va tindre que incluir apart
NewSoftSerial cell(2,3); // Els pins d’entrada que faràn servir la llibreria serien el “2” i “3”
char mobilenumber[] = “649745610”; // En cas d’enviar un missatge, s’enviarà el nombre de
// telefon determinat. En aquest cas el meu: Albert Montsant Fernàndez
NewSoftSerial pantalla(12,13); // Els pins d’entrada que efectuaran les accions “12” i “13”
#define BL 1000 // S’ha definit un bloc de com a màxim 1000 caràcters. Més que suficients per
// les aplicacions que s’efectuaran
#define KBL 100 // Bloc de 100 caselles pels caràcters del teclat
char buffer_sms[BL]; // Bloc que llegeix els caràcters en el pin del telefon mòbil
char buffer_teclat[KBL]; // Bloc que llegeix els caràcters en els pins del teclat
char inkey; // Llegeix els caràcters coneguts introduïts
char pin[4]; //Pin de confirmació, compte 4 caselles
char code[4] = {'1', '2', '3', '4'}; //Pin de confirmació “1234”, compte 4 caselles
int intents=0; // Nombre d’intents, inicialitza a 0
int pin_index=-1; //Nombre d’intents, per escriure el pin correcte
int inchar = 0; // Agafa els caràcters del port sèrie
char inchar2; // Agafa els caràcters del port del teclat
boolean flag=false; // Si l’alarma està engegada o apagada
boolean intrusio=false; // Si el sensor de moviment a detectat o no
boolean intacte=true; // Si el sensor de moviment dóna señal o no
int sensorValue = analogRead(A0); // Llegeix una entrada analògica en el pin 0
int value; // value: Valor que serveix per anar evaluant i comparant
long int ms = 0; // Temps que tarda desde l’última intrusió
int i; // Nombre que actua com a comptador
signed int last_in2 = -1; // Llegeix els caràcters d’entrada, inicialitza a “-1”
signed int last_out2 = -1; // Llegeix els caràcters de sortida, inicialitza a “-1”
void imprimir_missatge(String aaa) {
pantalla.print(0xFE, BYTE); // Envia comandes la pantalla LCD
pantalla.print(0x01, BYTE); //Neteja la pantalla LCD
pantalla.print(aaa);
delay(2500);
}
void imprimir_missatge_sortida(String aaa) {
81
pantalla.print(0xFE, BYTE); // Envia comandes la pantalla LCD
pantalla.print(0x01, BYTE); //Neteja la pantalla LCD
pantalla.print(aaa);
delay(2500);
missatge_per_defecte();
}
void imprimir_enter(String aaa, int iii) {
pantalla.print(0xFE, BYTE); // Envia comandes la pantalla LCD
pantalla.print(0x01, BYTE); //Neteja la pantalla LCD
pantalla.print(aaa);
pantalla.print(“ “);
pantalla.print(iii);
delay(2500);
}
void missatge_per_defecte() {
pantalla.print(0xFE, BYTE); // Envia comandes la pantalla LCD
pantalla.print(0x01, BYTE); //Neteja la pantalla LCD
pantalla.print(“Alarma preparada “);
}
void engega_alarma() {
imprimir_missatge_sortida(“Engegant alarma”); // Mostra per la pantalla LCD
// Serial.println(“Engegant alarma”); // En el programa definitiu, com no es mostrarà res pel
// monitor, no fa falta ninguna comanda que entri pel port sèrie
flag=true; //Alarma engegada
}
void apaga_alarma() {
imprimir_missatge_sortida(“Apagant alarma”);
//Serial.println(“Engegant alarma”);
flag=false; // Alarma apagada
}
void setup()
{
// Comença el port sèrie a 9600 bps
// Serial.begin(9600);
82
// Comença el port pantalla a 9600 bps
pantalla.begin(9600);
pinMode(4, OUTPUT); // Envia el pin digital “4”com a sortida
pinMode(5, OUTPUT); // Envia el pin digital “5”com a sortida
pinMode(6, OUTPUT); // Envia el pin digital “6”com a sortida
pinMode(7, OUTPUT); // Envia el pin digital “7”com a sortida
pinMode(8, INPUT); // Envia el pin digital “8”com a entrada
pinMode(9, INPUT); // Envia el pin digital “9”com a entrada
pinMode(10, INPUT); // Envia el pin digital “10”com a entrada
// Serial.println(“OK, teclat inicialitzat”);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
// El port sèrie del telèfon mòbil, comença a 9600 bps
cell.begin(9600);
for(i=0;i<1750;i++){ //Recerca entre 0 i 1749
delay(20); //Espera de temps de 20ms
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
inchar2=cell.read();
// Serial.print(inchar2);
}
}
cell.println(“AT+CMGF=1”); // S’utilitza per donar l’ordre al GSM modem per operar el SMS
// en mode text
for(i=0;i<10;i++){ //Cerca entre 0 i 9
delay(20);
if(cell.available() >0) // Si els caràcters que llegeix pel port sèrie del mòbil son mes grans
// que 0. Efectua la següent acció.
{
inchar2=cell.read(); //Agafa els caràctes del port sèrie
// Serial.print(inchar2);
}
83
}
cell.println(“AT+CNMI=3,3,0,0”); // Mòdul per enviar missatges
for(i=0;i<10;i++){
delay(20);
if(cell.available() >0)
{
inchar2=cell.read();
// Serial.print(inchar2);
}
}
delay(1000);
// S'esborren els missatges pendents per sortir d'un estat conegut
cell.println(“AT+CMGD=1,4”);
// Serial.print(“Hem esborrat els missatges de la bustia”);
missatge_per_defecte();
}
void loop(){
digitalWrite(4, HIGH); // Escriu el pin digital “4” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL; // Es va guardant d’un a un els caràcters o nombres
// teclejats pel teclat
pantalla.print(“1”); // Es mostra per pantalla LCD “1”
buffer_teclat[last_k_in]='1'; // Es guarda el nombre “1” al bloc KBL
//Serial.println(“1”); // Es mostra per pantalla “1”
delay(1000); // Espera de temps de 1s
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL;
pantalla.print(“2”); // Es mostra per pantalla LCD “2”
buffer_teclat[last_k_in]='2'; // Es guarda el nombre “2” al bloc KBL
// Serial.println(“2”); // Es mostra per pantalla “2”
84
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “4”
last_k_in = (last_k_in + 1)%KBL;
pantalla.print(“3”); // Es mostra per pantalla LCD “3”
buffer_teclat[last_k_in]='3'; // Es guarda el nombre “3” al bloc KBL
// Serial.println(“3”); // Es mostra per pantalla “3”
delay(1000);
}
digitalWrite(4, LOW); // Escriu el pin digital “4” com ha apagat
digitalWrite(5, HIGH); // Escriu el pin digital “5” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
pantalla.print(“4”); // Es mostra per pantalla LCD “4”
buffer_teclat[last_k_in]='4'; // Es guarda el nombre “4” al bloc KBL
//Serial.println(“4”); // Es mostra per pantalla “4”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
pantalla.print(“5”); // Es mostra per pantalla LCD “5”
buffer_teclat[last_k_in]='5'; // Es guarda el nombre “5” al bloc KBL
Serial.println(“5”); // Es mostra per pantalla “5”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “5”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='6'; // Es guarda el nombre “6” al bloc KBL
pantalla.print(“6”); // Es mostra per pantalla LCD “6”
//Serial.println(“6”); // Es mostra per pantalla “6”
delay(1000);
}
digitalWrite(5, LOW); // Escriu el pin digital “5” com ha apagat
digitalWrite(6, HIGH); // Escriu el pin digital “6” en funcionament
85
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='7'; // Es guarda el nombre “7” al bloc KBL
pantalla.print(“7”); // Es mostra per pantalla LCD “7”
//Serial.println(“7”); // Es mostra per pantalla “7”
delay(1000);
}
if (digitalRead(9) == HIGH) { //Si es retorna el valor “9” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='8'; // Es guarda el nombre “8” al bloc KBL
pantalla.print(“8”); // Es mostra per pantalla LCD “8”
//Serial.println(“8”); // Es mostra per pantalla “8”
delay(1000);
}
if (digitalRead(10) == HIGH) { //Si es retorna el valor “10” del pin dígital “6”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='9'; // Es guarda el nombre “9” al bloc KBL
pantalla.print(“9”); // Es mostra per pantalla LCD “9”
//Serial.println(“9”); // Es mostra per pantalla “8”
delay(1000);
}
digitalWrite(6, LOW); // Escriu el pin digital “6” com ha apagat
digitalWrite(7, HIGH); // Escriu el pin digital “7” en funcionament
if (digitalRead(8) == HIGH) { //Si es retorna el valor “8” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='*'; // Es guarda el caràcter “*” al bloc KBL
pantalla.print(“*”);// Es mostra per pantalla LCD “*”
// Serial.println(“*”); // Es mostra per pantalla “*”
delay(1000);
}
if (digitalRead(9) == HIGH) {
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='0'; // Es guarda el nombre “0” al bloc KBL
pantalla.print(“0”); // Es mostra per pantalla LCD “0”
// Serial.println(“0”); // Es mostra per pantalla “0”
delay(1000);
}
86
if (digitalRead(10) == HIGH) { //Si es retorna el valor “9” del pin dígital “7”
last_k_in = (last_k_in + 1)%KBL;
buffer_teclat[last_k_in]='#'; // Es guarda el nombre “#” al bloc KBL
pantalla.print(“#”);// Es mostra per pantalla LCD “#”
//Serial.println(“#”);// Es mostra per pantalla “#”
delay(1000);
}
digitalWrite(7, LOW); // Escriu el pin digital “6” com ha apagat
if (last_k_in != last_k_out) { // Si el caràcter o nombre d’entrada no és igual al de sortida
last_k_out=(last_k_out + 1)%KBL; // Es van añadint un a un al bloc KBL
inkey= buffer_teclat[last_k_out]; // inkey: Els caràcters o nombre introduïts al bloc KBL
if (inkey=='#'){ // Si el caràcter és “#”
imprimir_missatge_sortida(“Alarma informant”);
// Serial.println(“Alarma informant”);
pin_index = -1; // Els intents per posar el pin correcte, no compten
}
else if (inkey=='*'){ // Els intents per posar el pin correcte, no compten
imprimir_missatge_sortida(“Pin borrat”);
//Serial.println(“Pin borrat”);
pin_index = -1; // Els intents per posar el pin correcte, no compten
}
else{
pin_index = pin_index++; // Si no es posa el pin correcte, es van afegint el nombre d’intents
pin[pin_index]=inkey; // El pin es va afegint a un bloc de 4 caselles
if (pin_index==3){ // Si al escriure el pin, no s’han equivocat més de 3 vegades
pin_index = -1; // S’inicialitza amb pin_index=-1
intents++; // Es suma un intent
// Mostra per pantalla el nombre d’intents fins el moment
imprimir_enter(“Nombre d'intents:”, intents);
// Serial.print(“Nombre d'intents: “);
// Serial.println(intents);
if(intents<=3){ // Si no s’han superat la quantitat d’intents
if(pin[0]==code[0]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “1”
if(pin[1]==code[1]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “2”
if(pin[2]==code[2]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “3”
if(pin[3]==code[3]){ // Si el pin escrit coincideix amb el codi sèrie, en aquest cas “4”
imprimir_missatge(“Pin correcte”);
//Serial.println(“Pin correcte”);
87
intents=0; // El nombre d’intents, en cas d’equivocació en algun moment torna a 0
if(flag){ // Si l’alarma esta engegada
apaga_alarma();
}else{
engega_alarma();
}
}
}
}
}
if(intents!=0){ //Si hi ha un primer error, en escriure el pin
imprimir_missatge_sortida(“Incorrecte”);
// Serial.println(“Error, torna a escriure el pin “);
}
if(intents==2){
imprimir_missatge_sortida(“Incorrecte”);
// Serial.println(“Error , al escriure el pin. Tens una última oportunitat “);
}
if(intents==3){
imprimir_missatge_sortida(“Incorrecte”);
//Serial.println(“El sistema està tancat “);
}
}
else {
imprimir_missatge_sortida(“Sistema tancat”);
//Serial.println(“Has fet 3 errors, posat amb contacte amb el teu distribuidor “);
}
}
}
}
if(flag){ // Si l’alarma està engegada, es fà la següent acció
value=0; //S’inicialitza value a 0
for (i=0; i<50; i++) { // Recerca entre 0 i 49
sensorValue = analogRead(A0); //Es promitgen les dades
value = value + sensorValue; //El valor= valor + valor promitjat
}
if(value<1){ // Si el valor és 0, el sensor de moviment ha detectat
88
if(intacte){ // Si el sensor de moviment està en funcionament
imprimir_missatge(“Algu ha entrat”);
// Serial.println(“Algu ha entrat”);
intacte=false; // Sensor de moviment apagat
cell.print(“AT+CMGS=“); //Comanda per enviar desde el port sèrie del telèfon mòbil un
// SMS
cell.print(34,BYTE);
cell.print(mobilenumber); // El nombre de telèfon al qual se li enviarà el missatge
cell.println(34,BYTE);
delay(500);
cell.print(“T'han entrat a casa”); // S’envia el següent text a partir de SMS
cell.println(26,BYTE);
delay(15000);
imprimir_missatge_sortida(“Acabem d'enviar un SMS”);
// Serial.println(“Acabem d'enviar un SMS”);
}
intrusio=true; //El sensor de moviment ha detectat
ms = millis();// Temps que ha passat desde la última intrusió
}else{
intrusio=false; // El sensor de moviment no ha detectat res
}
}
//Llegeix els caràcters pel port sèrie
//Desde aquest punt, va comparant caràcter per caràcter, així comprovant que coincideix
// els conjunts de caràcters o paraules abans mencionats: alarma.on – alarma.off –
// alarma.info
/* if (Serial.available() > 0) { // Si s’agafen un byte vàlid, es llegeixen anàlogues instruccions
inchar = Serial.read();//Llegeix els caràcters pel port sèrie
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10); // Espera de temps de 0,01 s
inchar = Serial.read();
if (inchar=='l') //Compara si és la lletra “l”
{
delay(10);
89
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='r') //Compara si és la lletra “r”
{
delay(10);
inchar = Serial.read();
if (inchar=='m') //Compara si és la lletra “m”
{
delay(10);
inchar = Serial.read();
if (inchar=='a') //Compara si és la lletra “a”
{
delay(10);
inchar = Serial.read();
if (inchar=='.') Compara si és un punt “.”
{
delay(10);
inchar = Serial.read();
if (inchar=='o') //Compara si és la lletra “o”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
pantalla.print(“Engegant alarma”);
//Serial.println(“Engegant alarma”);
delay(2000);
pantalla.print(0xFE, BYTE); // Envia comandes a la pantalla LCD
pantalla.print(0x01, BYTE); // Neteja la pantalla LCD
flag=true; // Alarma engegada
}
else if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
90
{
pantalla.print(“Apagant alarma”);
// Serial.println(“Apagant alarma”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
flag=false; //Alarma apagada
}
else
{
pantalla.print(“Incorrecte”);
// Serial.println(“Incorrecte”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}
else
{
pantalla.print(“Incorrecte”);
// Serial.println(“Incorrecte”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}
else if (inchar=='i') //Compara si és la lletra “i”
{
delay(10);
inchar = Serial.read();
if (inchar=='n') //Compara si és la lletra “n”
{
delay(10);
inchar = Serial.read();
if (inchar=='f') //Compara si és la lletra “f”
{
delay(10);
inchar = Serial.read();
91
if (inchar=='o') //Compara si és la lletra “o”
{
if(flag){ // Si l’alarma està engada
if (ms>0){ // Si el temps que ha passat abans de la última intrusió és més de
// 0ms
pantalla.print(“La darrera“);
pantalla.print(“intrusio fa: “);
pantalla.print(millis()-ms);
pantalla.print(“milisegons”);
//Serial.println(“La darrera“);
//Serial.println(“intrusio fa:“);
//Serial.println(millis()-ms);
//Serial.println(“milisegons”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}else{
pantalla.print(“Ningu ha entrat”);
//Serial.println(“Ningu ha entrat”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}else{
pantalla.print(“Hauries d'engegar“);
pantalla.print(“l'alarma”);
//Serial.println(“Hauries d'engegar “);
//Serial.println(“l'alarma”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}
else
{
pantalla.print(“Incorrecte”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
92
}
}
else
{
pantalla.print(“Incorrecte”);
// Serial.println(“Incorrecte”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}
else
{
pantalla.print(“Incorrecte”);
//Serial.println(“Incorrecte”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}
else
{
pantalla.print(“Incorrecte”);
//Serial.println(“Incorrecte”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}
else
{
pantalla.print(“Falta un punt”);
//Serial.println(“Falta un punt”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}
}
93
}
}
}
}
} */
while (cell.available() > 0) { // Si els caràcters que llegeix pel port sèrie del mòbil son mes
//grans que 0. Efectua la següent acció.
last_in2 = (last_in2 + 1)%BL; // Va llegint els nombres d’entrada i col·locant-los a al bloc BL
buffer_sms[last_in2]=cell.read();// Els caràcters son llegits pel port sèrie del telèfon mòbil
}
while(last_out2!=last_in2){ // Mentres els d’entrada i els de sortida no siguin iguals. El bucle
// segueix en la següent acció.
last_out2 = (last_out2 + 1)%BL; //Va llegint els caràcters de sortida i col·locant-los a al bloc
// BL d’un a un
inchar2=buffer_sms[last_out2]; // Els caràcters es van guardant
if (inchar2=='a' || inchar2=='A') // Compara si és el càracter “a” o “A”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='l') // Compara si és el càracter “l”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='a') // Compara si és el càracter “a”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='r') // Compara si és el càracter “r”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='m') // Compara si és el càracter “m”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='a') // Compara si és el càracter “a”
94
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='.') // Compara si és el càracter “.”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='o') // Compara si és el càracter “o”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='n') Compara si és el càracter “n”
{
imprimir_missatge_sortida(“Engegant alarma”);
//Serial.println(“Engegant alarma”);
flag=true; //Alarma engegada
}
else if (inchar2 =='f')
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='f') // Compara si és el càracter “f”
{
imprimir_missatge_sortida(“Apagant alarma”);
//Serial.println(“Apagant alarma”);
flag=false; // Alarma apagada
}
else
{
imprimir_missatge_sortida(“Incorrecte”);
//Serial.println(“Incorrecte”);
}
}
else
{
imprimir_missatge_sortida(“Incorrecte”);
//Serial.println(“Incorrecte”);
}
}
95
else if (inchar2=='i') // Compara si és el càracter “i”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='n') // Compara si és el càracter “n”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='f') // Compara si és el càracter “f”
{
last_out2 = (last_out2 + 1)%BL;
inchar2=buffer_sms[last_out2];
if (inchar2=='o') // Compara si és el càracter “o”
{
imprimir_missatge(“Informacio”);
//Serial.println(“Informacio”);
if(flag){ // Si l’alarma està engada
if (ms>0){ // Si el temps que ha passat abans de la última intrusió és més de
// 0ms
imprimir_enter(“Intrs. fa (ms):”, millis()-ms);
//Serial.println(“La darrera“);
// Serial.println(“intrusio fa“);
//Serial.println(millis()-ms);
// Serial.println(“milisegons”);
missatge_per_defecte();
}else{
imprimir_missatge_sortida(“Ningu ha entrat”);
//Serial.println(“No ha entrat ningu”);
}
}else{
imprimir_missatge_sortida(“Alarma apagada”);
//Serial.println(“Hauries d'engegar “);
//Serial.println(“l'alarma”);
}
}
else
{
imprimir_missatge_sortida(“Incorrecte”);
//Serial.println(“Incorrecte”);
96
}
}
else
{
imprimir_missatge_sortida(“Incorrecte”);
//Serial.println(“Incorrecte”);
}
}
else
{
imprimir_missatge_sortida(“Incorrecte”);
//Serial.println(“Incorrecte”);
delay(2000);
pantalla.print(0xFE, BYTE);
pantalla.print(0x01, BYTE);
}
}
else
{
pantalla.print(“Incorrecte”);
//Serial.println(“Incorrecte”);
}
}
else
{
imprimir_missatge_sortida(“Incorrecte”);
//Serial.println(“Incorrecte”);
}
}
}
}
}
}
}
}
}
97
4. Resultats
4.1. Àmbit d’utilització
L’àmbit d’utilització més directe d’aquest projecte seria en qualsevol domicili o qualsevol zona que es vulgui vigilar o protegir. Com per exemple: Una botiga, nau industrial o fins i tot algu simple com seria una caixa forta. Ja que la seva gamma de possibilitats es molt diversa, perque el sensor de moviment és molt petit i la caixa la qual està tot el sistema electrònic es podria amagar en una paret falsa, sota un moble... donant molta llibertat. A sobre, amb el telèfon mòbil es podria manipular degudament a partir dels diferents codis via SMS al número: 615754990. Encara que donaria un cost addicional, segons la companyia de telèfon, però la caixa sempre quedaria oculta. La seva principal virtut es que la seva instal∙lació es bastant senzilla i no necessita professionals, ja que la part electrònica e informàtica ja està adequada. I només faria falta alimentació. Canviar el número de telèfon del destinatari i saber quina és el número de la targeta que s’ha insertat al GSM, que pot ser de qualsevol companyia de telèfons .
4.2. Validació dels dissenys
L’execució dels programes han estat desde el més petit que només servia per reconèixer codificacions a partir del port sèrie, ja que es volia manipular l’alarma escrivint una sèrie de caràcters. I aquests codis s’han creat mesclant el català i l’anglès, per dificultar la seva identificació, en cas de manipulació externa o robatori.
Aquest programa s’anomena, descodificació instruccions:
Figura 1.1: Compilació descodificació instruccions
98
‐ En el primer cas, s’ha introduït a partir del port sèrie alarma.on ‐ En el segon cas, s’ha introduït a partir del port sèrie alarma.off ‐ I per últim, s’ha introduït a partir del port sèrie alarma.info
El sensor de moviment va rebre la senyal de forma óptima, encara que al començament van aparèixer molts problemes. Degut, a que el sensor de moviment segons els Datasheets, podien rebre 5V i funcionar correctament. Però detectava moviment molta estona i no retornava a la seva situació inicial, fins passats uns 20 segons. Llavors fins a que no li va arribar una tensió de com a mínim 7V, no va funcionar de la forma desitjada.
Aquest programa s’anomena, sensor de presencia:
Figura 1.2: Compilació sensor de presència
En el cas del teclat, al polsar qualsevol botó es mostrava correctament pel monitor de la pantalla. Però van aparèixer moltes repeticions de la tecla polsada.
99
Aquest programa s’anomena, teclat prova:
Figura 1.3: Compilació teclat prova
Per solucionar el problema de les repeticions en el cas de polsar un botó del teclat. Es va introduir, un “delay” desprès de cada Serial.print(“...”) perque fes una espera de 1s. Desprès de cada tecla polsada, ja que pel port sèrie després d’introduir la tecla. No dongués la possibilitat de repeticions.
Aquest programa s’anomena, teclat bàsic:
Figura 1.4: Compilació teclat bàsic
100
En aquest cas, es va validarà el programa perque segons el codi teclejat, l’alarma farà una acció o altre. Els codis que utilitza són els següents:
‐ Per engegar o apagar l’alarma s’ha de polsar: “1234”
‐ Per rebre informació s’ha de polsar en qualsevol moment: “#”
‐ Per borrar el pin, abans d’introduir els 4 nombres s’ha de polsar: “*”
‐ El nombre d’intents màxim per posar el codi correcte és de 3 vegades. En cas, d’equivocar‐se més cops. El sistema quedarà tancat i no es podrà manipular, encara que s’escrigui després el codi correcte.
Aquest programa s’anomena, teclat Pin:
Figura 1.5.1: Compilació teclat Pin
101
Figura 1.5.2: Compilació teclat Pin
S’ha validat que es pugui manipular l’alarma o sigui engegar‐la, apagar‐la o donar informació a partir del telèfon mòbil via SMS a partir del GSM, segons els codis establerts. I rebré un SMS en cas de que el sensor de moviment detecti.
Aquest programa s’anomena, descodificació instruccions SMS:
Figura 1.6.1: Compilació teclat Pin
‐ S’ha enviat SMS, escrit el codi: alarma.on al “615754990”
102
Figura 1.6.2: Compilació teclat Pin
‐ S’ha rebut un SMS, a causa d’una intrusió detectada pel sensor de moviment
I per últim s’ha validat que tots els textos que s’introduïen pel port sèrie i es mostraven pel monitor del ordinador. Es poden mostrar a la pantalla LCD, de la mateixa manera. Encara que estant determinat per la seva longitud de text, degut a la seva quantitat de displays que hi ha. Sent un total de 32, dues files de 16 displays.
Aquest programa s’anomena, presencia instruccions sms teclat pin LCD:
Figura 1.6.2: Compilació presencia instruccions sms teclat pin lcd
103
4.3. Descripció del funcionament
L’alarma domèstica tant pot operar de forma analògica a partir del teclat matricial. Posant el codi correcte, que en aquest cas és el “1234” per engegar o apagar l’alarma. Per rebre informació sobre l’alarma s’hauria de polsar la tecla “#” el qual no importa si en aquell moment estaves escrivint el codi pin. I per esborrar el codi pin degut a una equivocació abans d’introduir‐lo, s’hauria de polsar la tecla “*”.
També pot operar via SMS, enviant els següents codis:
‐ Alarma.on o alarma.on: Per engegar l’alarma. ‐ Alarma.off o alarma.off: Per apagar l’alarma. ‐ Alarma.info o alarma.info: Per rebre informació sobre l’alarma.
4.4. Aplicacions del projecte
El resultat global d’aquest projecte té com a aplicació directa aquella per a la que ha estat dissenyat. Detectar una intrusió en cas de produir‐se i poder manipular degudament tant per via SMS com pel teclat matricial, segons la forma desitjada. Per altra banda, el fet d’haver‐lo programat amb wire, disposa de total flexibilitat per fer diferents coses. Algú senzill, seria canviar els comentaris que es mostra per la pantalla LCD o canviar el destinatari del missatge SMS en cas d’intrusió.
104
4.5. Estudi de mercat
Es farà un estudi sobre les principals empreses que distribueixen a España, amb les principals característiques de cadascuna.
Alarmes ADT
Característiques principals:
‐ Supervisió per vídeo i àudio simultàniament ‐ Fàcil maneig del sistema. ‐ Centraleta oculta ‐ Sistema GPRS de comunicació ‐ Canals de protecció: intrusió, emergència mèdica, ‐ Coacció, agressió, alarmes tècniques ‐ Sense obres i sense cables.
Pressupost:
‐ Instal∙lació: 99€ + IVA = 116,82€ ‐ Quota mensual: 31€/mes ‐ Quota mensual sense càmera: 27€/mes ‐ Període mínim de permanència: 2 anys ‐ Total mínim: 860,82€
Alarmes Prosegur
Característiques principals:
‐ Vídeo detectors amb gravació nocturna
‐ Detecció remota d’errors
‐ Bona qualitat d’imatge
‐ Garantia de privacitat
‐ Instal∙lació ràpida i sense cables
‐ Llarga duració de la bateria
105
Pressupost:
‐ Quota mensual: 30€/mes ‐ Període mínim de permanència: 3 anys ‐ Total mínim: 1080€
Securitas Direct
Característiques principals:
‐ Supervisió per vídeo i àudio simultàniament ‐ Fàcil maneig del sistema. ‐ Sistema GPRS de comunicació ‐ Bona qualitat d’imatge ‐ Garantia de privacitat ‐ Sense obres i sense cables.
Pressupost:
‐ Instal∙lació: 99€ + IVA= 116,82€ ‐ Amortització: 36 quotes per 15€ = 540€ ‐ Total mínim: 656,82€
Conclusions: Els preus de les alarmes domèstiques adquirides per empreses, tenen un preu amb un marge de benefici elevat. Per això la construcció d’una alarma domèstica més senzilla, podria ser viable.
106
5. Comentaris
5.1. Plà de treball El pla de treball d’aquest projecte consisteix en els següents punts: 1‐ Adquirir Arduino Uno i placa GSM
2‐ Col∙locar‐los en una petita estructura per immobilitzar‐los
3‐ Adquirir una antena per enviar SMS i soldar‐la a la placa GSM
4‐ Crear un circuit d’alimentació.
5‐ Aconseguir un ordinador per programar per Java els diferents dispositius
6‐ Adquirir un sensor de moviment
7‐ Programar el sensor de moviment perquè actuï de forma òptima
8‐ Adquirir una targeta SIM.
9‐ Programar perquè envií SMS en cas d’intrusió
10‐ Programa perquè rebi via SMS les comandes designades
11‐ Adquirir el teclat matricial
12‐ Fer una configuració pel teclat matricial
13‐ Programar el teclat matricial perquè doni senyal al polsar
14‐ Programar el teclat matricial al introduir el pin
15‐ Crear una caixa
16‐ Adquirir la pantalla LCD
17‐ Programar la pantalla LCD
107
5.2. Llista de materials Teclat ‐ 4 resistències 1kΩ
‐ 4 resistències 10kΩ
‐ 1 Placa fenòlica
‐ Teclat matricial 16x2 displays
Circuit d’alimentació
‐ 1 resistència 220Ω
‐ 1 resistència 1kΩ
‐ 3 díodes 1N4007
‐ 1 led vermell 5mm
‐ 1 transistor IC1‐780S
‐ 1 condensador electrolític 2000µF
‐ 2 condensadors electrolítics 100nF
‐ 1 fusible 2A
‐ 4 suports
‐ 4 femelles
‐ 1 placa fenòlica
GSM
‐ Targeta SIM(Orange: 50 missatges + 10€)
Arduino
‐ 4 suports
Sensor Moviment
108
Targeta SIM
Cables elèctrics
Bateries
Transformador 100‐240V/12V (Dura Micro Inc.)
Antena
4 Jack stereo
4 entrades stereo
Pantalla LCD
Caixa
Material addicional
Soldador
Estany
Silicona
Ordenador
Instrumentació per produir la caixa
1a caixa
2a caixa
109
5.3. Pressupost Teclat matricial
Referencia Quantitat Preu unitari(€) Preu total(€) Resistencia 1kΩ 4 0,03 0,12 Resistencia 10kΩ 4 0,03 0,12 Placa fenòlica 1 3,5 3,5 Teclat matricial 1 5,2 5,2 Preu total 8,94
Circuit d’alimentació
Referencia Quantitat Preu unitari(€) Preu total(€) Resistencia 220Ω 1 0,03 0,03 Resistencia 1kΩ 1 0,03 0,03 Diode 1N4007 3 0,07 0,021 Led vermell 1 0,12 0,12 Transistor IC1‐780S 1 0,25 0,25 Condensador 2000µF 1 0,25 0,25 Condensador 100µF 2 0,19 0,38 Fusible 2ª 1 0,15 0,15 Suport 4 0,1 0,4 Femelles 4 0,03 0,12 Placa fenòlica 1 3,5 3,5 Preu total 5,41
GSM + Arduino
Referència Quantitat Preu unitari(€) Preu total(€) GSM + Arduino 1 77,9 77,9 Suport 4 0,1 0,4 Femelles 4 0,03 0,12 Preu total 78,42
110
Caixa
5.4. Fites aconseguides
Les fites aconseguides són:
1‐ Aconseguir que el sensor de moviment actui de forma óptima.
2‐ Enviar un SMS puguen controlar l’alarma de la manera desitjada.
3‐ Rebre un SMS en cas de qualsevol intrusió detectada pel sensor de moviment.
4‐ Controlar a partir del teclat matricial, el estat de l’alarma.
5‐ Mostrar per pantalla LCD, les diferents accions que van succeint
Referència Quantitat Preu unitari(€) Preu total(€) Sensor de moviment 1 8,95 8,95 Cables 10 0,12 1,2 Bateries 2 1,25 2,5 Transformador 1 12 12 Caixa 1 30 30 Entrades stereo 4 0,08 0,32 Jack stereo 4 0,15 0,6 Pantalla LCD 1 15,1 15,1 Antena 1 7,25 7,25 Preu 77,92
Preu total 180,69 €
111
5.5. Conclusions
A continuació s’enumeren les conclusions de més importància:
1. Els preus de les alarmes domèstiques adquirides per empreses, tenen un preu amb un marge de benefici elevat.
2. La programació de molts dispositius ha estat molt complicada en varis casos. Ja que no actuaven de la forma desitjada. Tinguen que replantejar i repetir molts cops quasi de 0 els programes.
3. La part electrònica també ha estat molt problemàtica, com ha estat el cas del sensor de moviment que no podia treballar correctament a 5V sinó com a mínim a 7V. I la part, important es que estava delimitat per el nombre de pins existents. O sigui que en tot moment devíem comprovar que els dispositius poguessin estar interconnectats entre si, sense donar problemes.
4. Per finalitzar, creiem que hem complert els nostres objectius que es van posar en un primer moment. En un projecte en el cual apenes teníem base alguna per treballar. I quasi sempre treballant sobre la marxa i trobant dificultats en tot moment, tan electrònica com informàticament
5.6. Millores futures
Per tal d’explotar millor les possibilitats de l’alarma seria añadint dispositius:
‐ Una càmera de vídeo miniatura que s’hauria de programar perque només funcionés quan estigues l’alarma engegada.
‐ Poder cambiar el número pin i el número de telèfon, el qual rebrà un SMS. En cas d’intrusió
‐ Posar un interruptor d’engegada i apagada que funcionés de forma retardada
‐ Afegir un actuador o una sirena, en cas d’intrusió
‐ Afegir un micròfon i altaveu, perquè sigues possible utilitzar l’alarma com a un
telèfon mòbil a partir del GSM
‐ Un sensor de moviment inàlambric, d’aquesta manera seria més fàcil col∙locar‐lo en una zona molt més estratègica i no tindre que suportar ningun tipus de cable extern apart de l’alimentació.
112
‐ Un sensor de fum que estigués en tot moment engegat, en cas de que es produís un incendi.
‐ D’altre banda, el programa wire dóna una gran gamma de possibilitats. O sigui que, sempre es podrien millorar els programes. Com per exemple, utilitzar més el string i no fer tanta comparació de caràcters.
113
6. Bibliografia Bricogreek 1. http://www.bricogeek.com/shop/arduino/286‐arduino‐cellular‐shield‐
sm5100b.html (15/09/11)”GSM + Arduino” 2. http://www.bricogeek.com/shop/sensores/42‐sensor‐de‐movimiento‐pir.html
(25/09/11)”Sensor de moviment” 3. http://www.bricogeek.com/shop/componentes/84‐teclado‐matricial‐de‐12‐
botones.html (15/10/11)”Teclat matricial” 4. http://www.bricogeek.com/shop/pantallas‐lcd‐oled/27‐pantalla‐lcd‐16x2‐
caracteres‐fstn‐blanco‐sobre‐negro.html (20/11/11) “Pantalla LCD” 5. http://www.automatismos‐mdq.com.ar/ (21/11/11) 6. http://www.arduino.cc/(02/09/11) 7. http://www.circuitstoday.com/atmega32‐avr‐microcontroller‐an‐introduction
(03/10/11) 8. http://www.automatismos‐mdq.com.ar/blog/2009/07/leer‐un‐teclado‐
matricial.html (18/10/11)
9. http://www.securitasdirect.es/alarmas_hogar.html (12/12/11)
10. [1]http://www.alarmahogarprosegur.com/?gclid=CMHGka3nxK0CFUIMfAodOU8e
CA (12/12/11) 11. http://www.alarmahogarprosegur.com/?gclid=CMHGka3nxK0CFUIMfAodOU8eCA
(12/12/11) 12. http://www.intereconomia.com/noticias‐negocios/mercados‐y‐
valores/empresas/prosegur‐aumenta‐7‐ganancias‐gracias‐mejora‐negocio 13. Programación con el Estándar ISO y la Biblioteca de plantillas(STL), Paraninfo(2002)
14. Programación estructurada en C, Prentice Hall(2000)
114
A. Llenguatge dels programes
El llenguatge Java es va dissenyar de manera que els diferents tipus de dades que utilitzin estiguin units a les seves operacions. Així, les dades i el codi (funcions o mètodes) es combinen en entitats anomenades objectes. Un objecte pot veure's com un paquet que conté el “comportament” (el codi) i el “estat” (dades). El principi és separar allò que canvia de les coses que romanen inalterables. Freqüentment, canviar una estructura de dades implica un canvi en el codi que opera sobre els mateixos, o viceversa. Aquesta separació en objectes coherents i independents ofereix una base més estable per al disseny d'un sistema programari. L'objectiu és fer que grans projectes siguin fàcils de gestionar i manejar, millorant com a conseqüència la seva qualitat i reduint el nombre de projectes fallits.
Principals operadors i expressions utilitzats:
∙ #include: Dóna accés al programador a un grup gran d'estàndard de llibreries escrites especialment per Arduino.
∙ #define: És un útil component en C que permet el programador donar un nom a un valor constant abans del programa és compilat.
∙ setup: S’utilitza per inicialitzar variables, els modes dels pins, llibreries...
∙ loop: Després de crear una funció setup, el qual inicialitza i posa els valors inicials. El loop fa bucles consecutivament.
∙ char: Les variables contenen un únic caràcter
∙ int: Les variables contenen un únic nombre
∙ delay(): Efectuar una espera de temps, segons el temps estipulat entre parèntesis en [ms]
∙ “...”: Els texts escrits entre les doble cometes, serveixen per mostrar o una variable designada. En el cas que estigui de color groc, aquest es mostrarà per pantalla LCD o monitor.
∙ Serial.print(“...”): Mostra per pantalla, els escrits entrats a partir del port sèrie.
∙ Serial.println(“...”):Mostra per pantalla, els escrits entrats a partir del port sèrie. Però una línia a sota del últim escrit. L’altre mètode es escriure, Serial.print(“...\n”).
∙ Serial.read: Llegeix les variables a partir del port sèrie.
∙ for(i=0, i<=10, i++): Fa una búsqueda entre 0 i 9. S’utilitza normalment com a comptador la i, però podria ser qualsevol caràcter. (Inicialització, finalització, búsqueda). La búsqueda en realitat és i = i +1.
∙ if (): Serveix per comparar o donar una condició.
∙ else: En el cas de no donar‐se una condició o una comparació.
∙ cell.print(): Mostra per SMS, el escrit entrat a partir del port del cel∙lular.
115
∙ cell.read():Llegeix les variables a partir del port del telèfon móvil.
∙ while(): Fa un bucle tancat que mentre no surti de la condició designada no pararà de repetir‐se.
∙ long: Les variables contenen un o més nombres
∙ boolean: Les variables tan poden ser true o false. True normalment serveix per indicar que algu està en funcionament o es compleix tal acció. En canvi, false tot el contrari.
∙ PinMode(pin, mode): Configura el pin especificat per comportar‐se com a una entrada o una sortida. Input(Entrada)‐ Output(Sortida).
∙ digitalWrite(pin, valor): Per configurar el valor del pin depenent si el valor és HIGH, li arribarà una tensió de 5V. I si és LOW, actuarà com a terra o 0V.
∙ digitalRead():Llegeix el valor del pin especificat, en estat HIGH o LOW.
116
B. “Datasheets” dels components GSM SM5100B
Pin(nombre) Vmínima(V) Vnominal(V) Vmàxima(V)VBAT (Tensió bateries) 1,3,5,7 3,3 3,6 4,2
GND (Terra) 9,11,13,15,17
VCC Output (Tensió sortida) 47,6
Pin(nombre) Pin “nom” Descripció 33 Lcd_data SPI* Dades 38 Lcd_clk SPI Rellotge 39 Lcd_rst SPI Resetejar 41 Lcd_rs Seleccionar Dades 54 Lcd_cs Activar SPI 29 Sim_da Sim* Dades 27 Sim_clk Sim Rellotge 21 Sim_rst Sim Resetejar 51 Sim_vcc Vsuplementaria SIM 19 TXD0 Transmitir dades 20 RSD0 Rebre dades 10 U0_CTS Netejar per enviar 22 U0_RTS Solicitar per enviar 52 U0_DTR Terminal de dades preparades45 U0_DSR Conjunt de dades preparades 46 TX1 Transmitir dades 43 RX1 Rebre dades 6 ADCIN1 Convertidor A/C 8 ADCIN2 Convertidor A/C 34 Reset Resetejar 59 Power_on Mòdul Tensió engegada
*SPI: Bus estàndard de comunicacions.
*SIM: Targeta obligatòria en les reds GSM.
117
Sensor de moviment
Pantalla LCD
Pin(nombre) Simbol Funció 1 Vss Terra per LCM(GND) 2 VDD Tensió subministrada +5V 3 Vo Ajustar contrast 4 RS Registrar la selecció de señal 5 R/W Llegir/Escriure la selecció de señal 6 E Permitir señal
7‐10 DB0‐DB3 Transferir dades entre el CPU i LCD 11‐14 DB4‐DB7 Transferir dades a la CPU 15 LED+ Subministrar tensió per BKL (Ànode) 16 Led‐ Subministrar tensió per BKL (Terra)