SISTEMA DE SEGURIDAD GSM

24/5/2018 SISTEMA DE SEGURIDAD GSM – ecuduino
ecuduino
SISTEMA DE SEGURIDAD GSM
file:///C:/Users/Personal/Downloads/Paginas%20web/SISTEMA%20DE%20SEGURIDAD%20GSM%20%E2%80%93%20ecuduino.html 2/25
El sistema de seguridad GSM es un proyecto de seguridad para laboratorios, departamentos u oficinas.

Permite enviar mensajes de texto SMS de alertas por violación o acceso no autorizado hacia un usuario
establecido o usuario master, recibir mensajes de solicitud de estado del sistema por cuatro usuarios
registrados en el sistema, recibir códigos de activación y desactivación del sistema, y enviar estados.
Para un sistema de seguridad se puede usar sensores de presencia o PIR, y sensores magnéticos para
detectar presencias e intentos de acceso por ventanas y puertas. En este proyecto se aplica pulsadores para
simular los sensores.
¿QUÉ NECESITAMOS?
Para el desarrollo de este proyecto dispondremos de los siguientes materiales:
1x Arduino MEGA 2560

1x módulo GSM/GPRS SIM900
1x pantalla LCD 16×2
2x LEDS (rojo y verde)
4x resistencias de 330 Ω
6x resistencias de 4.7 KΩ
1x potenciómetro de 10 KΩ
6x pulsadores
Cables
Protoboard.
DESARROLLO
La recepción, transmisión y segmentación de datos para este proyecto son los mismos métodos aplicados de
proyectos anteriores: Monitoreo de temperatura, tiempo y objetos
(h ps://ecuduino.wordpress.com/monitoreo-de-temperatura-tiempo-y-objetos/), Mensajes de texto SMS
(h ps://ecuduino.wordpress.com/mensajes-de-texto-gsm/), Identificación de números telefónicos
(h ps://ecuduino.wordpress.com/identificacion-de-numeros-celulares/) y Estacion de monitoreo GSM
(h ps://ecuduino.wordpress.com/estacion-de-monitoreo-gsm/).
PROCESAMIENTO DE INFORMACIÓN
Este sistema permite procesar información solo para cuatro usuarios registrados en el código del proyecto.
Si un invasor trata de enviar claves de seguridad, el programa no permitirá realizar alguna acción para
aquel usuario falso, pero si permite leer su número telefónico.
D t l did d l ód l t í j d t t l li t t
file:///C:/Users/Personal/Downloads/Paginas%20web/SISTEMA%20DE%20SEGURIDAD%20GSM%20%E2%80%93%20ecuduino.html
j d 3/25
Durante el encendido del módulo, este envía un mensaje de texto al cliente master con un mensaje de
bienvenida al sistema a través de la función Send_initial_message() y en la pantalla LCD presenta un
mensaje similar de bienvenida.
Durante la recepción de mensajes se lo hace a través de la función Receive_Messages(), dentro de esta

función el sistema imprime en la pantalla el texto RECIBIENDO MENSAJE… Después de este proceso de
recepción, el sistema expone en pantalla el número telefónico de origen, por ejemplo: N°:+593982832027.
El sistema acepta solo ocho mensajes de texto o claves:
Claves Descripción
Act ha1 Activa la seguridad de la habitación 1.
Des ha1 Desactiva la seguridad de la habitación 1.
Act ha2 Activa la seguridad de la habitación 2.
Des ha2 Desactiva la seguridad de la habitación 2.
Act luc Activa luces.
Des luc Desactiva luces.
Des ala Desactiva alarma.
Estados Petición de estados del sistema.
La clave Estados permite a los usuarios solicitantes recibir información importante del estado del sistema.
Este envía información como: Habitaciones activadas o desactivadas y luces apagadas o encendidas. Toda
esta información es enviada a los usuarios a través de la función Send_State_System(), dentro de esta
función un texto en la pantalla LCD se expondrá ENVIANDO… SOLICITUD ESTADO.
La claves Act ha1 y Act ha2 permiten activar las habitaciones 1 y 2, es decir activa el sistema de seguridad
para estas dos habitaciones. Si durante la activación existe una violación al sistema de seguridad, un
mensaje de alerta será enviado al usuario master a través de la función Send_Security_Alert(), un mismo
texto se expondrá en la pantalla LCD ALERTA!!! SISTEMA VIOLADO, y una alarma se activará.
Las claves Des ha1 y Des ha2 permiten desactivar la seguridad de las dos habitaciones, durante esta acción,
el sistema queda vulnerable a cualquier acción, y no se enviará ningún mensaje de alerta o activará la
alarma.
Las claves Act luc y Des luc permiten encender o apagar las luces respectivamente de las habitaciones.
La clave Des ala permite desactivar la alarma encendida por cualquier intento de violación al sistema.
Es importante mantener las luces apagadas durante la activación del sistema de seguridad de las
habitaciones. Si se encienden las luces de las habitaciones, la misma alarma de activar y enviará el mismo
mensaje de alerta al usuario master.
Los sensores que se pueden usar en el proyecto pueden ser magnéticos para puertas y ventanas, o sensores
de presencia que pueden ser instalados en dos habitaciones, laboratorios u oficinas. Los pulsadores de este
proyecto simulan los sensores, ya que son de pulsos digitales como los pulsadores.
CONEXIONES DEL MÓDULO AL ARDUINO
Para la comunicación entre el modulo y Arduino MEGA se usa el puerto serial 0.
Para usa el puerto serial del módulo, conectaremos los Jumpers del módulo SIM900 a la posición Xduino.
Esto nos permite conectar directamente al puerto serial 0.
Si se prefiere el encendido automático del módulo se procederá a soldar con mucho cuidado el puente JP
del módulo. Esto nos permite realizar el encendido o apagado por software a través del pin D9 que es
reservado para este propósito.
CIRCUITO
PROGRAMACIÓN
La programación desarrollada en el IDE de Arduino utiliza una única librería LiquidCrystal.h para la
pantalla LCD.
/******************************************************************************
* Proyecto: *
* SISTEMA DE SEGURIDAD GSM *
*******************************************************************************
Este proyecto permite enviar mensajes de texto SMS de alertas por violación o
acceso no autorizado hacia un usuario establecido o usuario master, recibir
mensajes de solicitud de estado del sistema por cuatro usuarios registrados en
el sistema, recibir códigos de activación y desactivación del sistema, y enviar
estados.
******************************************************************************/
/*Circuito LCD:
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 10
* LCD R/W pin to ground
* 10K resistor:
* ends to +5V and ground
* wiper to LCD VO pin (pin 3)*/
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 10, 6, 5, 4);
// Numeros celulares registrados en el sistema.

String Number_One = "+593982832027"; // Número master o Cliente master
String Number_Two = "+593990275709"; // Cliente 2
String Number_Three = "+593989883340"; // Cliente 3
String Number_Four = "+593995586175"; // Cliente 4
String Comment_Room_1 = "";

String Comment_Room_2 = "";
String Comment_Lamp = "";
String keys = "";
String Cell_Number = "";
int Find_Chars = 0;
char incoming_char;
char Digits;
char Character1;
char Character2;
char Character3;
char Character4;
char Character5;
char Character6;
char Character7;
char country_code_1;
boolean Country_code = false;
// Declaración de pines digitales

int Alarm = 2;
int Lamp = 3;
int Door_1 = 48;
int Door_2 = 49;

int Win_1 = 50;
int Win_2 = 51;
int Door_3 = 52;
int Win_3 = 53;
int POWERKEY = 9;
// Declaración de puerto analogico 0 para un sensor fotoresistivo.

int PhotoRes = A0;
boolean Presence = false;

boolean State_Room_1 = false;
boolean State_Room_2 = false;
boolean State_Lamp = false;
int State_Door_1;
int State_Door_2;
int State_Win_1;
int State_Win_2;
int State_Door_3;
int State_Win_3;
int Count_Room_1 = 0;
int Count_Room_2 = 0;
int Count_Lig = 0;
byte customChar[8] = { // creación del caracter °

byte customChar[8] = { // creación del caracter
B01110,
B01010,
B01110,
B00000,
B01110,
B00000,
B00000,
B00000
};
void setup(){
pinMode(Alarm, OUTPUT);
pinMode(Lamp, OUTPUT);
pinMode(Door_1, INPUT);
pinMode(Win_1, INPUT);
pinMode(POWERKEY,OUTPUT);
Serial.begin(19200);
lcd.begin(16, 2);
lcd.createChar(0, customChar);
lcd.setCursor(3, 0);
lcd.print("BIENVENIDO");
SIM900_AUTO_POWER(); // encendido automático del módulo SIM900.
lcd.print("INICIANDO MODULO");
delay(1000);
Serial.print("AT+CMGF=1\r"); // configura SMS en modo de texto.
delay(100);
Serial.print("AT+CNMI=2,2,0,0,0\r"); /* Transmisión de mensaje directamente
al puerto serial del dispositivo. */
delay(100);
Send_initial_message();
Serial.println("AT+CMGD=1,4"); // eliminar todos los mensajes
Serial.println("AT+CMGL=\"ALL\",0 ");
Comment_Room_1 = "Habitacion 1 Desactivado.";
Comment_Lamp = "Luces Apagadas.";
lcd.clear();
}
void loop(){
lcd.print("SECURITY SYSTEM");
if(Cell_Number != ""){ //imprimo el número telefónico en la LCD.
lcd.print("N");
lcd.write(byte(0));
lcd.print(":");
lcd.print(Cell_Number);
}
int sensor = analogRead(PhotoRes);

int Light level = map(sensor 0 1023 0 255); // Mapeamos datos de 0 a 255
int Light_level = map(sensor, 0, 1023, 0, 255); // Mapeamos datos de 0 a 255
if (Serial.available() > 0){

Receive_Messages();
}
//Asignamos el número telefónico remitente y enviamos una alerta.

if ((Country_code == true) && ((Cell_Number == Number_One) ||
(Cell_Number == Number_Two) || (Cell_Number == Number_Three) ||
(Cell_Number == Number_Four))){
Cell_Number = Cell_Number;
}
// leemos las contraseñas

if(keys == "Act ha1"){ // activa cuarto 1
keys = "";
State_Room_1 = true;
Comment_Room_1 = "Habitacion 1 Activado.";
}
else if(keys == "Des ha1"){ // desactiva cuarto 1
keys = "";
State_Room_1 = false;
}
else if(keys == "Act ha2"){ // activa cuarto 2
State_Room_2 = true;
Comment_Room_2 = "Habitacion 2 Activado.";
}
else if(keys == "Des ha2"){ // desactiva cuarto 2
keys = "";
State_Room_2 = false;

}
else if(keys == "Act luc"){ // activa luces
keys = "";
State_Lamp = true;
digitalWrite(Lamp, HIGH);
Comment_Lamp = "Luces Encendidas.";
}
else if(keys == "Des luc"){ // desactiva luces
keys = "";
State_Lamp = false;
digitalWrite(Lamp, LOW);
Comment_Lamp = "Luces Apagadas.";
}
else if(keys == "Des ala"){ // desactiva alarma
keys = "";
digitalWrite(Alarm, LOW);
}
else if(keys == "Estados"){ // Petición "Estados"
keys = "";
Send_State_System();
}
else;
// Alarma de puertas y ventanas del cuarto 1.

if(State Room 1 == true){
if(State_Room_1 == true){
// Sistema de seguridad de puertas y ventanas activadas.
State_Door_1 = digitalRead(Door_1);
State_Win_1 = digitalRead(Win_1);
if((State_Door_1 == 1) || (State_Door_2 == 1) ||
(State_Win_1 == 1) || (State_Win_2 == 1)){
Count_Room_1 ++;
digitalWrite(Alarm, HIGH);
if(Count_Room_1 == 1){
Send_Security_Alert();
}
}
else Count_Room_1 = 0;
// Alarma de luces.
if(State_Lamp == false){ // Luces apagadas
// Si durante el proceso de pagado de luces se encienden, activa alarma.
if(Light_level >= 200){
Count_Lig ++;
Comment_Lamp = "Luces Encenidas.";
if(Count_Lig == 1){
}
}
else Count_Lig = 0;
}
}
else{
State_Door_1 = 0;
State_Door_2 = 0;
State_Win_1 = 0;
State_Win_2 = 0;
}
// Alarma de puerta y ventana del cuarto 2.

if(State_Room_2 == true){
// Sistema de seguridad de puerta y ventana activadas.
// Si se abren la puerta o ventana, se activa la alarma.
if((State_Door_3 == 1) || (State_Win_3 == 1)){
Count_Room_2 ++;
if(Count_Room_2 == 1){
}
}
else Count_Room_2 = 0;
}
else{
State_Door_3 = 0;
State_Win_3 = 0;
}
}
///////////////////////////FUNSIONES////////////////////////////////////////
// Encendido automático del módulo SIM900

void SIM900_AUTO_POWER(){
digitalWrite(POWERKEY, HIGH);
delay(1000);
digitalWrite(POWERKEY, LOW);
delay(7000);
}
////////////// Salida de mensajes de bienvenida /////////////////////

void Send_initial_message(){
Serial.println("AT + CMGS = \"" + Number_One + "\"");
delay(100);
Serial.print("BIENBENIDOS!");
Serial.print('\n');
delay(100);
Serial.print("Iniciando Sistema de Seguridad...");
Serial.print('\n');
delay(100);
Serial.write((char)26); //ctrl+z
delay(1000);
}
////////////// Salida de mensajes de estados /////////////////////

void Send_State_System(){
lcd.clear();
lcd.print("ENVIANDO...");
lcd.print("SOLICITUD ESTADO");
delay(3000);
Serial.println("AT + CMGS = \"" + Cell_Number + "\"");
delay(100);
Serial.print(Comment_Room_1);
Serial.print('\n');
delay(100);
Serial.print(Comment_Room_2);
Serial.print('\n');
delay(100);
Serial.print(Comment_Lamp);
Serial.print('\n');
delay(100);
delay(1000);
}
////////////// Salida de mensajes de alertas /////////////////////

void Send_Security_Alert(){
lcd.clear();
lcd.print("ALERTA!!!");
lcd.print("SISTEMA VIOLADO");
delay(3000);
Serial println("AT + CMGS = \"" + Number One + "\"");
Serial.println( AT + CMGS = \ + Number_One + \ );
delay(100);
Serial.print("ALERTA!!!");
Serial.print('\n');
delay(100);
Serial.print("Violacion al Sistema de Seguridad.");
Serial.print('\n');
delay(100);
delay(1000);
}
////////////// Llegada mensajes de texto /////////////////////

void Receive_Messages(){
incoming_char = Serial.read();
if((Find_Chars == 0) && (incoming_char == 'C')){
Find_Chars = 1;
Cell_Number = "";
keys = "";
}
if((Find_Chars == 1) && (incoming_char == 'M')){
Find_Chars = 2;
}
if((Find_Chars == 2) && (incoming_char == 'T')){
Find_Chars = 3;
}
if((Find_Chars == 3) && (incoming_char == ':')){
Find_Chars = 4;
}
if((Find_Chars == 4) && (incoming_char == ' ')){
Find_Chars = 5;
}
if((Find_Chars == 5) && (incoming_char == '"')){
Find_Chars = 6;
for(int i = 0; i <= 13; i++){
Digits = Serial.read();
if (Digits == '"') break;
else Cell_Number += Digits; // Obtengo todo el número telefónico.
}
lcd.clear();
lcd.print("RECIBIENDO");
lcd.print("MENSAJE...");
delay(3000);
country_code_1 = (char)Cell_Number[1];
if ((country_code_1 == '5') && (country_code_2 == '9') &&
(country_code_3 == '3')) Country_code = true; // código país.
else Country_code = false;
}
// la clave va seguido del caracter Numeral "\n".
if ((Find_Chars == 6) && (incoming_char == '\n')){
Find_Chars = 0;
// Todas las claves están comprendidas en un tamaño de 7 caracteres.
Character1 = Serial read();
Character1 = Serial.read();
keys += Character1;
keys += Character2;
keys += Character3;
keys += Character4;
keys += Character5;
keys += Character6;
keys += Character7;
}
delay(100);
}
FUNCIONAMIENTO DEL PROYECTO
Después de la programación y armado el circuito en la placa Arduino MEGA 2560 ponemos en

funcionamiento el sistema y a realizar pruebas con los diferentes pulsadores para simular sensores
magnéticos de ventanas y puertas de dos habitaciones u oficinas.
La tarjeta implementada es el Arduino MEGA, para este proyecto es necesario usar una tarjeta Arduino con
una gran cantidad de puertos digitales.
Al iniciar el sistema observaremos un mensaje de BIENVENIDO e INICIANDO MODULO. En este

proceso el módulo SIM900 se activará automáticamente si se tiene soldado el puente de JP.
Una vez encendido el módulo enviara un mensaje de texto al número celular registrado en el software o
mejor llamado número master.
Inmediatamente el sistema entra en un proceso de espera por mensajes de texto de cualquier remitente
llamado Security System.
Ahora estamos listos para enviar los códigos para activar o desactivar: sensores, luces, alarmas, o solicitar el
estado del sistema. En este caso enviaremos Estados para la solicitud de estado.
Durante la llega de un mensaje SMS al módulo, Arduino mostrará en pantalla el comentario RECIBIENDO
MENSAJE…
Después de recibir el mensaje de texto, Arduino expondrá el número telefónico del remitente. En este
ejemplo es: +593982832027.
Si el mensaje de llega al módulo es una solicitud de estado del sistema Estados, el modulo enviará un
mensaje con información específica del estado del sistema al número remitente.
Para activar las luces y sensores, enviaremos los códigos Act ha1 para la habitación 1, Act ha2 para la
habitación 2, y Act luc para encender las luces. Si todo esto se ha llevado con éxito, enviaremos otro mensaje
de solicitud del estado del sistema Estados para verificar la seguridad implementada en el sistema, después
recibiremos un mensaje diciendo Habitación 1 activado, habitación 2 activado y luces encendidas.
Una vez activados los sensores de todo el sistema, este es vulnerable a cualquier intento de acceso. Cuando
es violado el sistema enviará un mensaje de alerta al teléfono master y se activará una alarma.
Para desactivar la alarma se enviará otro mensaje de texto con el código Des ala, y para desactivar la
seguridad, enviaremos mensajes de texto con los códigos Des luc para apagar las luces, Des ha1, y Des ha2
para las habitaciones.
Listo, Para implementar este proyecto a un laboratorio, oficinas o departamentos se debe invertir la lógica
para la lectura de los pulsadores por sensores magnéticos o de presencia (PIR).
VIDEO
SISTEMA DE SEGURIDAD GSM
Anuncios

SISTEMA DE SEGURIDAD GSM - Ecuduino CAPITULO 3 PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SISTEMA DE SEGURIDAD GSM - Ecuduino CAPITULO 3 PDF

Uploaded by

Copyright:

Available Formats

24/5/2018 SISTEMA DE SEGURIDAD GSM – ecuduino

El sistema de seguridad GSM es un proyecto de seguridad para laboratorios, departamentos u oﬁcinas.

Para el desarrollo de este proyecto dispondremos de los siguientes materiales:

1x Arduino MEGA 2560

Durante la recepción de mensajes se lo hace a través de la función Receive_Messages(), dentro de esta

El sistema acepta solo ocho mensajes de texto o claves:

CONEXIONES DEL MÓDULO AL ARDUINO

Para la comunicación entre el modulo y Arduino MEGA se usa el puerto serial 0.

LiquidCrystal lcd(12, 11, 10, 6, 5, 4);

// Numeros celulares registrados en el sistema.

String Comment_Room_1 = "";

// Declaración de pines digitales

int Door_2 = 49;

// Declaración de puerto analogico 0 para un sensor fotoresistivo.

boolean Presence = false;

byte customChar[8] = { // creación del caracter °

int sensor = analogRead(PhotoRes);

if (Serial.available() > 0){

//Asignamos el número telefónico remitente y enviamos una alerta.

// leemos las contraseñas

Comment_Room_2 = "Habitacion 2 Desactivado.";

// Alarma de puertas y ventanas del cuarto 1.

// Alarma de puerta y ventana del cuarto 2.

// Encendido automático del módulo SIM900

////////////// Salida de mensajes de bienvenida /////////////////////

////////////// Salida de mensajes de estados /////////////////////

////////////// Salida de mensajes de alertas /////////////////////

////////////// Llegada mensajes de texto /////////////////////

FUNCIONAMIENTO DEL PROYECTO

Después de la programación y armado el circuito en la placa Arduino MEGA 2560 ponemos en

Al iniciar el sistema observaremos un mensaje de BIENVENIDO e INICIANDO MODULO. En este

SISTEMA DE SEGURIDAD GSM

You might also like