Alarma arduino wavecom programa y esquema numeros borrados 48 pag

D714 D613 D512 D411 D310 D29 D18 D07

E6 RW5 RS4

VSS1

VDD2

VEE3

LCD1

LM016L

+5V

Autor: Joaquín Berrocal Piris

ALARMA_ARDUINO_WAVECOM : CONTROL DE SISTEMA DE ALARMA

Arduino Control por Telfno y SMS

+5V

R16220

1 2 3

654

8 9

=

7

CON 0

A5

B6

C7

D8

11

22

44

33

KEYSTECLADO

1 2 3

4 5 6

7 8 9

* #

A

B

C

D

>>>

<<<

FILA_A

FILA_B

FILA_C

FILA_D

COL_2COL_3COL_4

COL_1

clave :0000PWM COMUNICATION

DIG

ITA

L

ANALOG IN

ATMEGA256016AU 1126

microcontrolandos.blogspot.com

TX0

TX3

TX2

TX1

SDA

SCL

RX0

RX3

RX2

RX1

PD0/

SCL/

INT0

21PD

1/SD

A/IN

T120

PD2/

RXD

1/IN

T219

PD

3/TX

D1/

INT3

18PH

0/R

XD2

17PH

1/TX

D2

16PJ

0/R

XD3/

PCIN

T915

PJ1/

TXD

3/PC

INT1

014

PE0/

RXD

0/PC

INT8

0PE

1/TX

D0/

PDO

1PE

4/O

C3B

/INT4

2PE

5/O

C3C

/INT5

3PG

5/O

C0B

4PE

3/O

C3A

/AIN

15

PH3/

OC

4A6

PH4/

OC

4B7

PH5/

OC

4C8

PH6/

OC

2B9

PB4/

OC

2A/P

CIN

T410

PB5/

OC

1A/P

CIN

T511

PB6/

OC

1B/P

CIN

T612

PB7/

OC

0A/O

C1C

/PC

INT7

13

AREF

PA0/AD0 22

PA1/AD1 23

PA2/AD2 24

PA3/AD3 25

PA4/AD4 26

PA5/AD5 27

PA6/AD6 28

PA7/AD7 29

PC6/A14 31

PC5/A13 32

PC4/A12 33

PC3/A11 34

PC2/A10 35

PC1/A9 36

PC0/A8 37

PD7/T0 38

PG2/ALE 39

PG1/RD 40

PG0/WR 41

PL7 42

PL6 43

PL5/OC5C 44

PL4/OC5B 45

PL3/OC5A 46

PL2/T5 47

PL1/ICP5 48

PL0/ICP4 49

PB3/MISO/PCINT3 50

PB2/MOSI/PCINT2 51

PB1/SCK/PCINT1 52

PB0/SS/PCINT0 53

PK7/

ADC

15/P

CIN

T23

A15

PK6/

ADC

14/P

CIN

T22

A14

PK5/

ADC

13/P

CIN

T21

A13

PK4/

ADC

12/P

CIN

T20

A12

PK3/

ADC

11/P

CIN

T19

A11

PK2/

ADC

10/P

CIN

T18

A10

PK1/

ADC

9/PC

INT1

7A

9PK

0/AD

C8/

PCIN

T16

A8

PF7/

ADC

7/TD

IA

7

PF6/

ADC

6/TD

OA

6

PF5/

ADC

5/TM

SA

5

PF4/

ADC

4/TC

KA

4

PF3/

ADC

3A

3PF

2/AD

C2

A2

PF1/

ADC

1A

1PF

0/AD

C0

A0

RES

ET

PC7/A15 30

DUINO1

ARDUINO MEGA2560 R3

D1

LED-GREEN

D2

LED-BLUE

D3

LED-RED

R11k

+5V

FILA

_AFI

LA_B

FILA

_CFI

LA_D

CO

L_4

CO

L_3

CO

L_2

CO

L_1

RXD

RTS

TXD

CTS

SDA

SCL

TRIG

Rx

Tx

TX

RX

Pue

rtas PUERTAS

LCD I2C de www.geetech.comlibrerias usadas para su manejo:<Wire.h> y LiquidCrystal_I2C.h>

LiquidCrystal_I2C mi_lcd (0x27,16,2);set the LCD address to 0x27 for a 16 chars and 2 line

Con esta librería se maneja la LCD con sólo 4 cables2 de alimentación y las señales de datos (SDA) y reloj(SCL)Utiliza los pines AD4/SDA y AD5/SCL que se uniran conlos respectivos de la lcd_I2C SDA y SCL

Representa la union con la LCD I2C

Verano 2014

Representa el RS232-TTL

para union con Modem Wavecom Q2303 A

/* //Titulo: "ALARMA_ARDUINO_WAVECOM" * Fecha: 26/Agosto/2014 * Autor: Joaquín Berrocal Piris * Realizado en ARDUINO. válido para Arduino UNO o superior

Componentes:-. MODEM WAVECOM Q2303A-. RS232-TTL para convertir las señales Rx Pin 0 y Tx Pin 1 a niveles TTL 5V-. TECLADO. "No necesita resistencias"-. LCD_I2C 16x2. utilizo la del fbte "www.geeetech.com" Librería "LiquidCrystal_I2C.h"-. PULSADOR NA. Puertas Cerradas nivel Alto en el pin 7 de la placa Arduino. (al Abrir puerta nivel Bajo)-. Placa Arduino UNO R3 o bien la Arduino Mega 2560

***********FUNCIONAMIENTO*********A la placa Arduino acoplo al moden GSM WAVECOM Q2303A por el puerto SERIE con la ayuda de un conversor SERIE-TTLpines de comexión de la placa al conversor Serie-TTL son el 1-> Tx y el 0->RXPero podría haberlo hecho con cualquier otro utilizando la libreria #include <SoftwareSerial.h> SoftwareSerial mySerial (Rx,Tx);

-. Utilizo una LCD 2X16 CON CONECTOR I2C. para simplificar el cableadopues tan sólo se necesitan 4 pines; 2 de alimentación y otros 2 para la conexión serieque utiliza los pines clásicos de la placa 0 --> RX y el 1 --> Tx Para el manejo del LCD I2C 16X2 UTILIZO la libreria ; "LiquidCrystal_I2C.h"

-Se escanea el pin 7 conectado a las puertas/ventanas de entrada a la casa-Puerta CERRADA nivel alto. Al abrirla nivel bajo; activa alarma. Utilizo para ello un Pulsador Normamente Abierto "Pulsador NA"

-tiempos configurados de fÁbrica 12sg para -tConfigurar/tSalida/tEntrada -//posicion 0 para flag indicador que el cliente ha configurado su alarma.-//posicion 1 para tConfiguracion-//posicion 2 para tSalida-//posicion 3 para tEntrada-//posicion telefono/SMS de la 8 a la 16

-La alarma te hace llamada de telefono durante 15 segundos. después -envía SMS advirtiéndote que la puedes desconectar desde el móvil // son unos 15 sgdos para hacer la llamda y desconectarla con "ATH" // Lo que suponen unos 3 timbreos del telefono. // el SMS se envía en unos 11 segos.

-Para desconectar desde el movil <D1> -Para Activar de nuevo del movil <C1> -. Desde el teclado para Desconectar "D" o Conectar "C" nos exigirá la CLAVE-. Pero desde el móvil mediante SMS para desconectar "D1" o Conectar "C1" -. NO nos exigirá la clave al hacerlo desde el móvil!!!-. Cuando desde el MÓVIL desconecte o conecte la alarma. recibiré un mensaje-. de confirmación.

-. Se tiene tiempo para salir y entrar antes de que salte la alarma-. Una vez entremos si no pulsamos 'D' en el teclado antes de finalizar el tiempo de -. entrada, saltará la alarma. Nos pedirá clave, max 3 intentos.

-.Los tiempos iniciales de; tConfiguracion/tSalida/tEntrada están en 12 sgdos. configurados.

MEJORAS POSIBLES:

H77

Resaltado

H77

Resaltado

H77

Resaltado

H77

Resaltado

H77

Resaltado

H77

Resaltado

H77

Resaltado

H77

Resaltado

H77

Resaltado

H77

Resaltado

1-. Eviar MENSAJE A correo electrónico 2-. Enviar FOTOS pero requeriría módulo de cámara fotográfica (y almacenar en tarjeta de memoria)

*/

// Incluimos la libreria para el teclado #include <Keypad.h>// ----Incluimos la libreria para el manejo del LCD_I2C de greeetech.com---- #include <Wire.h> //para el manejo del LCD 16X2 conectar sus pines SDA y SCL //con los pines de la placa Arduino D4/SCA Y D5/SCL, //los cuales se ven en la placa UNO como los analogicos A4 y A5 #include <LiquidCrystal_I2C.h> //Como sólo manejo el "Serial" pines (Rx pin 0 y Tx pin 1) // Utilizo estos pines para comunicar con monitor Serial y con el modem !! por ello; //No necesito incluir la librería "SoftwareSerial.h" que permite otros pines.

/* --------------------------------------------- //EL MODELO MEGA DISPONE DE HASTA 4 PUERTOS SERIE //Serial(pines 0Rx,1Tx) / Serial(pines 19Rx,18Tx)/Serial2(pines 17Rx,16Tx)/Serial3(pines 15Rx,14Tx) //De Todos estos seriales tan sólo El "Serial" (pines 0,1)está asociado al monitor serial //(Esta información esta sacada del libro RC Curso práctico... pag 183)

// #include <SoftwareSerial.h> // no me hace falta la dejo por si la necesitara // SoftwareSerial mySerial (50,51); //el Rx52 y el Tx 53 *///----------------------------------------------- #include <string.h> //para el manejo de string //Libreria oficial EEPROM sólo //dispone de dos funciones //La EEPROM.write(posicion,valor) posición de 0 a 1023 y valor de 0 a 255 //la EEPROM.read(posición) lee de la posición 0 a 1023 #include <EEPROM.h>

//++++++++++Declaramos las variables para el proyecto+++++++++ boolean Flag = 1; //para permitirme salir o no del While boolean flagTel = 0; //para permitir leer como caracter o los valores de EEPROM //si vale 1 leer como entero el nº de telefono guardado en la eeprom // int pinVal = 0; boolean claveCorrecta = false; // estado inicial de la clave // ---valores iniciales de fabrica ---- int tConfigurar = 12; // Tiempo para poder seleccionar Configurar o NO. int tSalida = 12; //Tiempo para poder salir int tEntrada = 12; //Tiempo para poder Entrar //-------------------------------------- int valorTiempo; // int activaAlarma = 7; // Pin lectura puertas abiertas. String lecturaE =""; //para concatener los datos guardados en la EEPROM String lectura; //para lectura del teclado guardar las teclas pulsdas // Pines para las patillas de cada color del Led RGB int rojo = 9; int verde = 10;

H77

Resaltado

H77

Resaltado

int azul = 11; String clave =""; int longitud = 4; // Longitud de nuestra contraseña

String bufferClave="";

//PARA TANTO LA CLAVE COMO PARA EL TELEFONO CONFIGURAR // 8 porque del 0 al 8 son 9 digitos que tiene un telefono char nuevoBuffer[8]; char teclaPulsada ; int x = 0; // Variable para rotar la posicion de array donde guardar la contraseña introducida int i=0; //Para el contaje de tiempo //++++++++CONFIGURAMOS EL TECLADO++++++++++++

const byte ROWS = 4; // Cuatro filas const byte COLS = 4; // Cuatro columnas //Definimos los simbolos que tiene nuestro teclado char hexaKeys[ROWS][COLS] = { {'1','2','3','A'}, {'4','5','6','B'}, {'7','8','9','C'}, {'*','0','#','D'} }; byte rowPins[ROWS] = {3, 4, 5, 6}; // Pines de Arduino para las filas byte colPins[COLS] = {14, 15, 16, 17}; // Pines de Arduino para las columnas //Creamos un nuevo teclado(Sustituyo "customKeypad" por "mi_teclado" y char "customkey" por "char tecla_pu Keypad mi_Teclado = Keypad( makeKeymap(hexaKeys),rowPins, colPins, ROWS, COLS);//+++++++++++++++++++++++++++++++++++++++++++++ //Con esta librería se maneja la LCD con sólo 4 cables //2 de alimentación y las señales de datos (SDA) y reloj(SCL) //Utiliza los pines AD4/SDA y AD5/SCL que se uniran con //los respectivos de la lcd_I2C SDA y SCL //Debo hacerlo aquí como variable global para poder utilizarlo en todo el programa // set the LCD address to 0x27 for a 16 chars and 2 line display creo que si fuese de 20x4 seria la (0x20 LiquidCrystal_I2C mi_lcd (0x27,16,2); //--------------------------- PROGRAMA -------------------------void setup(){ //INICIALIZAR la lcd es de 16x2 por defecto. si fuese de 20x4 sería (20,4) //+++Para Comunicación con LCD utilizo una controlada por BUS I2C++++ mi_lcd.init(); mi_lcd.begin(16,2); //LCD DE 16X2 //// mi_lcd.backlight(); // "para ilumniar la pantalla" INTERESANTE mi_lcd.setCursor(0,0); //columna 1 y fila 1 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //configuro el puerto serial monitor para observacion datos // y comunicación con el MODEM Serial.begin(9600);

H77

Resaltado

// CONFIGURACIÓN DE PINES //¿¿creo que no es necesario si utilizo digitalWrite (rojo,LOW/HIGH); ???? pinMode(rojo, OUTPUT); pinMode(verde, OUTPUT); pinMode(azul, OUTPUT); //Como entrada el pin 7 por donde recibirá la señal apertura puertas nivel bajo pinMode(activaAlarma,INPUT); //-----LO PRIMERO GRABAR LOS VALORES DE FÁBRICA EN LA EEPROM------

if (EEPROM.read(0)!= 170)// si todavía el cliente no ha configurado su Alarma //lo sé si en la posición 0 no esta grabado el valor 170 { //se grabaran los datos de fabrica //--TIEMPOS DE tConfigurar,tSalida , tEntrada ------- EEPROM.write (1,12); //posicion 1 Tiempo de Configurar 12 segs EEPROM.write (2,12); //posicion 2 Tiempo de SALIDA 12 segs EEPROM.write (3,12); //Posición 3 Tiempo de ENTRADA 12 segs //--------------------------------------------------- //------CLAVE DE LA posición 4 a la 7------ // clave inicial alarma Clave= "0000" EEPROM.write (4,0); //dígito 1 clave: 0 EEPROM.write (5,0); //dígito 2 clave: 0 EEPROM.write (6,0); //dígito 3 clave: 0 EEPROM.write (7,0); //dígito 4 clave: 0 //------------------------------------------ // ------TELEFONO/SMS de la 8 a la 16 ------------ //Nº TELFNO: 123456789 EEPROM.write (8,1); //dígito 1 tefno SMS EEPROM.write (9,2); //dígito 2 tefno SMS EEPROM.write (10,3); //dígito 3 tefno SMS EEPROM.write (11,4); //dígito 4 tefno SMS EEPROM.write (12,5); //dígito 5 tefno SMS EEPROM.write (13,6); //dígito 6 tefno SMS EEPROM.write (14,7); //dígito 7 tefno SMS EEPROM.write (15,8); //dígito 8 tefno SMS EEPROM.write (16,9); //dígito 9 tefno SMS //-------------------------------------------------- } //FIN del if EEPROM.read(0) !170) tiempos y tefno fábrica//--------------------------------------------------------------

//LO PRIMERO SERÁ VER SI YA HEMOS GRABADO Y CONFIGURADO EL TELÉFONO // si es así estará grabado en posición 0 de la EEPROM el valor 170D -- 1010 1010B // de lo contrario pasar directamente a la rutina de configuración void RdeConfiguracion () //ESTO PASARÁ UNA SOLA VEZ al ser puesta en marcha por el cliente y este haya configurado x = 0; //iniciamos variable global //hacer función de lectura de la EEPROM posiciones 4 a 7 con la clave clave = RlecturaEEPROM (4,7,0); //variable global String clave //recoge el valor de retun lecturaE Serial.println(clave); delay(1500) ; //para que se vea

} //FIN del void setup()

//----------------El void loop()---------------- void loop() { RtConfigurar(); //ir a rutina del tiempo para configurar RtSalida(); //ir a rutina para contaje tiempo de salida }//FIN del void loop()

//--------------------------------------------------------------

//+++++++++++++++++++++++++++++++++++++++++ //+++++CONJUNTO DE RUTINAS EMPLEADAS+++++++ //+++++++++++++++++++++++++++++++++++++++++

void ledRojo() //activa led rojo { digitalWrite (rojo,HIGH); //se enciende cuando salta la alarma digitalWrite (verde,LOW); //se enciende cuando está operativa digitalWrite (azul,LOW); //se enciende para configurar ALARMA posible configuración } void ledVerde() //activa led Verde { digitalWrite (rojo,LOW); digitalWrite (verde,HIGH); digitalWrite (azul,LOW); } void ledAzul() //activa led Azul { digitalWrite (rojo,LOW); digitalWrite (verde,LOW); digitalWrite (azul,HIGH); }

//-----------------------------------------------//++++++ Funcion para validad Clave +++++++++++++//-----------------------------------------------

boolean RvalidarClave() { // INICIAMOS las variables String bufferClave = ""; //Reiniciamos la variable //NOTA DEBO DEFINIR LAS VARIABLES EN CADA FUNCIÓN //AUNQUE YA SEAN DE TIPO global . de LO CONTRARIO //RESULTADOS INESPERADOS. claveCorrecta = false; int numIntentos = 3; //lo iniciamos a 3 intentos //OBLIGATORIO DEFINIR LA VARIABLE int x = 0 //aunque se una variable global. definida como int x = 0 int x = 0; // x es variable global int la iniciamos a 0 //+++ MENSAJE PARA PONER CLAVE EN LCD +++ mi_lcd.clear(); //limpia pantalla y posiciona en 0,0 columna fila mi_lcd.print("PONER CLAVE"); //11 caracteres

mi_lcd.setCursor(0,1); //posición 0 de la línea 2 mi_lcd.print ("Num intentos <3>"); // tiene 16 caracteres //y posicionar el cursor par ver la clave que pulsemos mi_lcd.setCursor(12,0); //posición 12 de la línea 2 //--------------------------------------------------------------------- //LO PRIMERO ES VER QUE ES LO QUE TENEMOS EN EEPROM COMO //CLAVE, EN POSICIONES 4 A 7 clave = RlecturaEEPROM (4,7,0); //variable global String clave //recoge el valor de retun lecturaE Serial.print ("Guardado en el buffer la clave ");//("Se ha guardado en el buffer la clave "); Serial.println(clave); delay(1500) ; //para se vea //---------------------------------------------------------------------- // //-------------CHEQUEAMOS TECLADO.---------------//----------TENDREMOS 3 INTENTOS MÁXIMOS ------- while(numIntentos <=3) // nos permite máx 3 intentos { //*** CHEQUEO DEL TECLADO ***** delay(10); char teclaPulsada = mi_Teclado.getKey(); //lee el teclado if (teclaPulsada != NO_KEY) //Si esta pulsada { bufferClave.concat(teclaPulsada) ; delay(10); // adecuado para completar la concatenación x++; // incrementamos el contaje para llegar a 4 caracteres de la clave //se verá a continuación de "PONER CLAVE" XXXX mi_lcd.print (teclaPulsada); // referencia tecla pulsada. } //Cuando ya hemos pulsado el numero maximo de // digitos para nuestra contraseña //longitud de nuestra contraseña inicial es de 4 caracteres if (x == 4) // si se ha completado la clave de longitud 4 digitos verificar si es correcta { delay (1500); //para poder ver la clave puesta si no no se vería el último nº introducido Serial.print("Se ha guardado en el buffer la clave "); Serial.println(bufferClave); //++COMPARAMOS LA CONTRASEÑA INTRODUCIDA CON LA GUARDADA++ // if (strcmp(clave, bufferClave) == 1) // en principio la clave[] = "0000"; if (clave.equals(bufferClave)) // { Serial.println(bufferClave); //escribe en el serial monitor el buffer Serial.println(" CLAVE CORRECTA ");

ledVerde(); //enciende sólo el verde mi_lcd.clear(); // limpia LCD y posiciona 0 de la línea 1 mi_lcd.print(" CLAVE CORRECTA "); //16 caracteres para eliminar: " Clave erronea " delay(3000); //para poder ver el mensaje return claveCorrecta = true; // variable boolean Verdadera usada como testigo } //FIN DEL if (clave.equals(bufferClave)) //+++si CLAVE INCORRECTA sigue el contaje de intentos+++ else { x=0; //iniciamos la posición del buffer a 0 mi_lcd.clear(); //limpia pantalla y posiciona en 0,0 columna fila mi_lcd.print(" Clave erronea "); //16 caracteres mi_lcd.setCursor(0,1); //posición 0 de la línea 2 mi_lcd.print ("Num intentos < >"); mi_lcd.setCursor(14,1); //posición 15 de la línea 2 justo <x> mi_lcd.print (numIntentos-1); // indica el numero de intenetos que van quedando. delay (3000); //para ver el mensaje y pedir de nuevo clave mi_lcd.setCursor(0,0); //posición 0 de la línea 1 mi_lcd.print("PONER CLAVE "); //14 caracteres para eliminar: " Clave erronea " //y posicionar el cursor par ver la clave que pulsemos mi_lcd.setCursor(12,0); //posición 12 de la línea 1 Serial.println("Clave erronea "); ////**** Serial.print ("Num intentos <"+ numIntentos-1 + '>'); CREA PROBLEMAS Serial.print ("Num intentos <"); Serial.print (numIntentos-1); Serial.print ('>'); Serial.println(bufferClave); bufferClave = ""; //la reiniciamos por seguridad } x = 0; //Establecemos x a cero, para iniciar de nuevo escritura en bufferClave //decrementamos el número de intentos en uno al llegar a 3 decrementos // saldrá del While (NumIntentos <= 3) numIntentos -- ; if (numIntentos == 0)// se ha superado el Numero de intentos { bufferClave = ""; //la reiniciamos por seguridad return claveCorrecta = false; } } //FIN del if (x== 4) para conocer cuando se ha escrito la } //FIN del While (numIntentos <=3) // nos permite máx 3 intentos //Aquí no es necesario poner nada pues ya salimos con la variable claveCorrecta = true/false si es o

} // Fin de la rutina RvalidarClave //---------------------------------------------------//+++++++++++Función para configurar el +++++++++++++//+++contaje del tiempo para configurar la alarma +++//---------------------------------------------------

void RtConfigurar()

{ //------------------------------------------------- //Inicializamos los leds a cero menos el azul que //nos indica que podemos configurar la alarma ledAzul (); mi_lcd.clear();//limpiamos la pantalla mi_lcd.print("CONFIG ALARMA"); //13 Caracteres mi_lcd.setCursor(0,1); //posición 0 de la línea 2 mi_lcd.print ("Si <C> No <1>");//pulsar "C" para configurar y "1" para no configurar //------------------------------------------------- //LECTURA del tiempo para la configuración esta en la posición 1 de la EEPROM tConfigurar = EEPROM.read(1); //RlecturaEEPROM(1,1); //-----ESTABLEZCO UN MÍNIMO de 5 sg PARA PODER OPTAR A CONFIGURAR:---- if (tConfigurar < 5) { tConfigurar = 5; }//fin del if tConfigurar delay(10); //conveniente para hacer una buena lectura CREO QUE NO ES NECESARIO PERO LO DEJO //-------------------------------------------------------------------

// tConfigurar = valor;(int lecturaE); //es el valor devuelto por la rutina: void RlecturaEEPROM(int inicio, int final) //hacer contaje del tiempo para configurar. Si se pulsa 'C' ir a configurar //si se pulsa '1' salir del bucle y continuar. Si se pasa el tiempo para configurar //salir y continuar for (i = 0; i<= tConfigurar ; i++) { delay (1000); //1 segundo mantener pulsada la tecla al menos este tiempo REDUCIR PARA HACER MÁS SENS int valorTiempo = (tConfigurar-i); //al primer ciclo sale tConfigurar y poder ver el decremento mi_lcd.setCursor(14,0); //posición 15 de la línea 1 para ver los segundos que me quedan if (valorTiempo <= 9) //cuando se llegue a 9 borrar unidades de las decenas para que no se manteng { mi_lcd.setCursor(14,0); //posición 15 de la línea 1 para ver los segundos que me quedan mi_lcd.print(" "); //borra para que no se vean la mi_lcd.setCursor(15,0); // volver a posición 15 de la línea 1 } mi_lcd.print(valorTiempo); //ver en LCD lo que me va quedando de tiempo para configurar

//*** CHEQUEO DEL TECLADO ***** char teclaPulsada = mi_Teclado.getKey(); //lee el teclado mantener pulsado almenos 1 sg //---- SI se ha pulsado; COMPROBAR Si es 'C'configurar o '1' salir---

if (teclaPulsada != NO_KEY) { if (teclaPulsada == 'C') { // se mantiene el LED AZUL activo. //Ahora podría enviarlo a la rutinade configurar la alarma y después salir del bucle FOR //haciendo: i = tConfigurar; Serial.println("SE HA PULSADO <C>"); ledAzul (); //se enciende para configurar ALARMA //Enviarlo Rutina para validad Clave y permitir así pode configurar RvalidarClave (); // Una vez configurada salir y continuar //hacer la rutina RdeConfiguración () para crear los tConfigurar/tEntrada/tSalida/telefono/correo/cla // incluso podría permitir cambiar la longitud de la clave en lugar de q sea 4 poner más digitos. if (claveCorrecta == true) { // se permite hacer LA CONFIGURACIÓN; void RdeConfiguracion () claveCorrecta = false; //la reiniciamos RdeConfiguracion(); break; //para poder salir del bucle FOR hará por tanto la rutina RtSalida() !!!!!!!!!!! } } //FIN del if (teclaPulsada == 'C') //Si No se desea CONFIGURAR se habrá pulsado '1' o bien habría pasado el tiempo establecido. if (teclaPulsada == '1') { // se mantiene el LED AZUL activo. Serial.println("SE HA PULSADO <1>"); break ; //Sale del bucle for (i = 0; i<= tConfigurar ; i++). //Irá a hacer RtSalida Desde el void loop () } } //FIN DEL if (teclaPulsada != NO_KEY) puedo quitar este if pero dejando su interior //lo dejo por ser mas adeucado } // FIN del for (i = 0; i<= tConfigurar ; i++) //AQUÍ PONER LAS INSTRUCCIONES NECESARIAS UNA VEZ SE SALGA DEL FOR POR LA RAZON QUE SEA //ya sea por pasarme del tiempo o por pulsar por EJE PONER CASE .... break segun sea 'C' o '1' Serial.print("HA PASADO EL TIEMPO: TOTAL: "); Serial.println(tConfigurar); Serial.println ("o bien se ha pulsado C o 1"); //Una vez que pase el tiempo total se continua yendo a la rutina de tiempo para salir RtSalida () // desde el void loop () } //fin de la rutina void RtConfigurar()

//---------------------------------------------------

// RUTINA PARA CONFIGURAR TODOS LOS TIEMPOS, LA CLAVE, Y EL TELFNO/SMS//longitud es el Nº DE DIGITOS de 00 a 99 Por tanto son 2 digitos//la posicionE es la posicion de EEPROM DONDE SE GRABARA EL TIEMPO++

//Permite: configurar los tiempos máx de 0 a 99 por razon de espacio en la lcd//poscion 0 --> valor 170//poscion 1 --> tConfigurar 12 Segundos de fabrica//poscion 2 --> tSalida 12 Segundos de fabrica//poscion 3 --> tEntrada 12 Segundos de fabrica//poscion 4 a 7 --> clave: "0000"//poscion 8 a 16 --> el número de telefono/SMS 62696xxxx

//---------------------------------------------------void RdeConfiguracion()

{ // ---------------EN LA POSICIÓN 0 DE LA EEPROM ------------------ // ---Se grabará o no el valor 170 para indicar al chip //que se ha configurado por el cliente la alarma. //si no esta dicho valor en la eeprom se mantienen los datos de fabrica // se grabara el valor 170 si pulso 'A' confirmando grabacion //----------------------------------------------------------- // ---------------TIEMPO DE CONFIGURACIÓN tConfigurar--------- //-----------------grabar en posicion 1 EEPROM---------------- int a = 2; // representa la longitud de los 2 digitos a grabar 00 a 99 int b = 1; //Representa la posición inicial a grabar en la eeprom int d = 1; //Representa la posición Final a grabar en la eeprom y es en la misma q la inicial String mensaje1= "Tiemp Config: "; String mensaje2= "Nuevo tiempo: "; String mensaje3= "tConfigu GRABADO"; String mensaje4= "AHORA EL tSalida"; boolean e = 1; // PARA GRABAR TIEMPOS ///leerlo como ENTERO boolean f = 1; //para sólo permitir lectura de NUMEROS en teclado delay(20); RgrabarConfiguracion(a,b,d,mensaje1,mensaje2,mensaje3,mensaje4,e,f); //configurar el telefono/SMS delay(20); //----------------------------------------------------------- // ---------------TIEMPO DE SALIDA tSalida-------------------- //-----------------grabar en posicion 2 EEPROM---------------- a = 2; // representa la longitud de los 2 digitos a grabar 00 a 99 b = 2; //Representa la posición inicial a grabar en la eeprom d = 2; //Representa la posición Final a grabar en la eeprom y es en la misma q la inicial mensaje1= "Tiemp. Salir: "; mensaje2= "Nuevo tiempo: "; mensaje3= "tSalida GRABADO"; mensaje4= "AHORA EL tSalid"; e = 1; //PARA GRABAR TIEMPOS///leerlo como ENTERO f = 1; //para sólo permitir lectura de NUMEROS en teclado delay(20); RgrabarConfiguracion(a,b,d,mensaje1,mensaje2,mensaje3,mensaje4,e,f); //configurar el telefono/SMS delay(20); //----------------------------------------------------------- // ---------------TIEMPO DE ENTRADA tEntrada------------------ //-----------------grabar en posicion 3 EEPROM---------------- a = 2; // representa la longitud de los 2 digitos a grabar 00 a 99 b = 3; //Representa la posición inicial a grabar en la eeprom

d = 3; //Representa la posición Final a grabar en la eeprom y es en la misma q la inicial mensaje1= "Tiemp Entrar: "; mensaje2= "Nuevo tiempo: "; mensaje3= "tEntrada GRABADO"; mensaje4= "AHORA LA Clave"; e = 1; //PARA GRABAR TIEMPOS ///leerlo como ENTERO f = 1; //para sólo permitir lectura de NUMEROS en teclado delay(20); RgrabarConfiguracion(a,b,d,mensaje1,mensaje2,mensaje3,mensaje4,e,f); //configurar el telefono/SMS delay(100); //----------------------------------------------------------- // ---------------CONFIGURAR LA CLAVE DE 4 NUMEROS------------------ //-----------------grabar en posicion 4 A 7 EEPROM---------------- a = 4; // representa la longitud 9 NUMEROS de la clave b = 4; //Representa la posición inicial a grabar en la eeprom d =7; //Representa la posición Final a grabar en la eeprom mensaje1= "Su Clave: "; mensaje2= "La nueva: "; mensaje3= " CLAVE GRABADA "; mensaje4= "AHORA EL Telefno"; e = 0; // PARA GRABAR LA CLAVE ///leerlo como CARACTER f = 0; //para permite lectura de TODO el Teclado //(para poder CUALQUIER caracter para la CLAVE) delay(20); RgrabarConfiguracion(a,b,d,mensaje1,mensaje2,mensaje3,mensaje4,e,f); //configurar el telefono/SMS delay(20); //----------------------------------------------------------- // ---------------CONFIGURAR EL TFNO A LLAMAR/SMS------------------ //-----------------grabar en posicion 8 A 16 EEPROM---------------- a = 9; // representa la longitud 9 NUMEROS del tefno b = 8; //Representa la posición inicial a grabar en la eeprom d =16; //Representa la posición Final a grabar en la eeprom mensaje1= "Tefno: "; mensaje2= "nuevo: "; mensaje3= " Telfno GRABADO "; mensaje4= "Alarma Operativa"; e = 0; ///PARA GRABAR TELEFONO ///leerlo como caracter f = 1; //para sólo permitir lectura de NUMEROS en teclado delay(20); RgrabarConfiguracion(a,b,d,mensaje1,mensaje2,mensaje3,mensaje4,e,f); //configurar el telefono/SMS delay(20); //----------------------------------------------------------------- } //FIN rutina void RdeConfiguracion ()

//-------------------------------------------------------------------------------------

// +++++++ESTA FUNCION PERMITE GRABAR TODOS LOS DATOS DE CONFIGURACIÓN COMO+++++++++ //++++++++++++++++LOS TIEMPOS, LA CLAVE Y EL TELFNO/SMS.+++++++++++++++++++++++++ //PARA LOS TIEMPOS Y EL TELFNO ""SÓLO SE PERMITE LEER LOS NUMEROS""//-------------------------------------------------------------------------------------

void RgrabarConfiguracion (int longitud,int posInicialE,int posFinalE,String mensaje1, String mensaje2,String mensaje3,String mensaje4, boolean flagTel, boolean flagS{ lecturaE = ""; //iniciamos la variable global String lecturaE lectura = ""; //iniciamos la variable global String lectura char teclaPulsada; // lee las posiciones de la CLAVE en la EEPROM de posicion 4 a la 7 lecturaE = RlecturaEEPROM(posInicialE,posFinalE,flagTel); delay(10); mi_lcd.clear(); //limpia LCD y posiciona 0,0 mi_lcd.print(mensaje1 + lecturaE); mi_lcd.setCursor(0,1); mi_lcd.print (mensaje2); delay(10); Serial.print (mensaje1); Serial.println(lecturaE); delay(10); Serial.print(mensaje2); delay(10); ///++++SE MANTIENE A LA ESPERA DE PULSAR LOS 4 CARACTERES ++++++

int x = 0; // es variable global int x lectura = ""; //iniciamos la variable global String lectura while (x < longitud) //1º WHILE para lectura CLAVE DE 4 CARACTERES { // -----------CHEQUEO DEL TECLADO SOLO PERMITE LECTURA NUMEROS------------------ // ------------------Para los TIEMPOS y el telefono. --------------------------- char teclaPulsada = mi_Teclado.getKey(); //lee el teclado // mientras no se pulse ninguna tecla permanecer haciendo el (x < longitud) de forma permanente if (flagSoloNum == 1) { if (teclaPulsada != NO_KEY) { if ((teclaPulsada !='A') and (teclaPulsada !='B') and (teclaPulsada !='C') and (teclaPulsada !='D') { mi_lcd.print(teclaPulsada); // en poscion 9 linea 2 Serial.print (teclaPulsada); //se van concatenando las teclas pulsadas formando una cadena lectura.concat(teclaPulsada); delay(10); //para asegurar la concatenacion //------------------------------------------- nuevoBuffer[x]= teclaPulsada; delay(10); //-------------------------------------------

x++; // incrementamos la variable } }// FIN DEL if (teclaPulsada != NO_KEY) } //FIN DEL if (flagSoloNum == 1)

//------------------------------------------------------------------ //------------------------------------------------------------------

//------ Para la CLAVE Acepta TODOS LOS CARACTERES----------------- if (flagSoloNum == 0) { if (teclaPulsada != NO_KEY) { mi_lcd.print(teclaPulsada); // en poscion 9 linea 2 Serial.print (teclaPulsada); //se van concatenando las teclas pulsadas formando una cadena lectura.concat(teclaPulsada); delay(10); //para asegurar la concatenacion //------------------------------------------- nuevoBuffer[x]= teclaPulsada; delay(10); //------------------------------------------- x++; // incrementamos la variable } // FIN DEL if (teclaPulsada != NO_KEY) } // // FIN DEL if (flagSoloNum == 0) //------------------------------------------------------ //Cuando ya hemos pulsado el numero maximo de // digitos para nuestra Tiempo/contraseña/telefono if(x == longitud) { delay (1000); //para poder ver, Si no, no se vería el último nº introducido mi_lcd.clear(); mi_lcd.print("Guardar: " + lectura); //lo que tengamos en lectura que será la clave nueva o el t delay(10); mi_lcd.setCursor(0,1); //linea 2 del lcd mi_lcd.print(" Si <A> No <1> "); //15 caracteres delay(10); Serial.println(); //para pasar al siguiente línea Serial.print ("Guardar: "); Serial.println (lectura); Serial.println (" Si <A> No <1> "); delay(10); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// char teclaPulsada; //NOTA IMPORTANTE DEBO DECLARARLA EN LA FUNCION aunque //ya esta al principio del programa como variable global char teclaPulsada. //de lo contrario es como si no recibiera nada de la funciÓn char RRlecturaSi_No_A_1_

teclaPulsada = RlecturaSi_No_A_1_Teclado(); if (teclaPulsada == 'A') //GRABAMOS LA NUEVA CLAVE en posición 4 a 7 de EEPROM { // ---------------PARA GRABAR 170 EN POSICIÓN 0 DE LA EEPROM--------- //NOS SIRVE PARA NO LEER EL VALOR DE FABRICA SE HACE UNA SOLA VEZ int valor170; valor170 = EEPROM.read(0); delay(10); if (valor170 != 170) { EEPROM.write(0,170); delay (10); } //FIN del if (valor170 != 170) //----------------------------------------------------------- Serial.print("Se ha pulsado: "); Serial.println(teclaPulsada); delay (10);//para esperar a leer //------------------------------------------------------------------------ //PARA GRABAR ADECUAMENTE LOS TIEMPOS 00 A 99 //en posicion 1-2-3 tConfiguracion-tSalida-tEntrada respectivamente if (flagTel==1) { EEPROM.write((posInicialE), lectura.toInt()); //graba LOS TIEMPOS 00 a 99 delay(10); //en posicion 1-2-3 tConfiguracion-tSalida-tEntrada respectivamente } //FIN DEL if (flagTel==0) //------------------------------------------------------------------------ //++++++++++++++PARA GRABAR LA NUEVA CLAVE y el TELEFONO +++++++++++++ ////en caso de ser flagTel == 1 entonces GRABAR DE ESTA OTRA MANERA LA CLAVE Y/O EL TELEFONO/SMS //se leera como Caracteres if (flagTel==0) { x = 0 ; //iniciamos la variable aunque no lo creo necesario for (x=0; x <longitud; x++) ///puede ser de 4 para la clave u 8 para el tfno for (x=0; x <4; x++ { EEPROM.write((x+posInicialE), nuevoBuffer[x]); //graba la nueva clave de la posición 4 a la delay(10); // o bien el tefno de la 8 a la 16 } //FIN del for (x=0; x <longitud; x++) de grabación de la nueva clave o del tfno } //FIN DEL if (flagTel==0) //+++++++++++++++++++++++++++++++++++++++++++++++++++++++ //------------------------------------------------------------------------ mi_lcd.clear(); mi_lcd.print (mensaje3);//(" CLAVE GRABADA "); //16 mi_lcd.setCursor(0,1); //linea 2 mi_lcd.print (mensaje4); //("AHORA EL tConfig"); Serial.println (mensaje3);//(" CLAVE GRABADA "); delay(10); Serial.println(mensaje4);//("AHORA EL tConfig "); delay(10);

delay(2000); //para que se pueda leer }//FIN del if teclaPulsada = 'A' else //PARA INFORMAR SI NO SE HA GRABADO LA NUEVA CLAVE { mi_lcd.clear(); mi_lcd.print (" NO GRABADA "); //16 delay(10); Serial.println (" NO GRABADA ");//("NUEVA NO GRABADA"); delay(2000); //para poder verla }//del else si se ha pulsado 'A' se ha pulsado '1' } //FIN del if(x == longitud) // longitud 4 digitos } //FIN DEL 1º while x < LONGITUD de valor longitud 4 para la clave

}// FIN de la Funcion void RgrabarConfiguracionTiemposTelefono (int.......) //----------------------------------------------------------------------- //++++++ Rutina LECTURA DE LAS TECLAS PULSADAS RlecturaSi_No_A_1_Teclado+++++ //------------------------------------------------------------------------

char RlecturaSi_No_A_1_Teclado () //ejemplo Si 'A' No '1'{ //PERMANECE A LA ESPERA DE PULSAR UNA TECLA LA 'A' o la '1' //OBLIGATORIA DECLARARLA aunque ya este como variable global tipo char. char teclaPulsada; while (1) //para que permanezca siempre leyendo el teclado { teclaPulsada = mi_Teclado.getKey(); delay(10); if ((teclaPulsada == 'A') or (teclaPulsada == '1')) { delay(10); return teclaPulsada; //devuelve la 'A' o '1' }//FIN del if (teclaPulsada == a) or (teclaPulsada == b) } //FIN DEL while (1) } // FIN Rutina void RlecturaSi_No_A_1_Teclado (char a, char b)

//------------------------------------------------------------------------ //------------------------------------------------------------------------------//++ FUNCION para el tiempo de salida una vez pasado el tiempo de configurar +++//------------------------------------------------------------------------------

void RtSalida(){ i=0; //reinicio el contador de la variable global int i = 0 //Se enciende para indicar que debo salir ledRojo ();

mi_lcd.clear();//limpiamos la pantalla mi_lcd.print("Tiempo en Salir:"); //15 caracteres // mi_lcd.setCursor(7,1); //posición 7 de la línea 2 //--LECTURA del tiempo para SALIR esta en la posición 2 de la EEPROM--- tSalida = EEPROM.read(2); //RlecturaEEPROM(2,2); //---------------------------------------------------------------------- //-----ESTABLEZCO UN MÍNIMO de 5 sg PARA PODER OPTAR A CONFIGURAR:---- if (tSalida < 5) { tSalida = 5; }//fin del if tConfigurar delay(10); //conveniente para hacer una buena lectura//------------------------------------------------------------------- for (i=0 ; i<= tSalida; i++) { delay(1000); //tiempo espera de 1 sg valorTiempo = (tSalida-i); //al primer ciclo sale tConfigurar y poder ver el decremento mi_lcd.setCursor(7,1); //posición 7 de la línea 2 //cuando sea menor a 10 borrar unidades de las decenas para que no se mantengan if (valorTiempo <= 9) { mi_lcd.setCursor(7,1); //posición 7 de la línea 2 mi_lcd.print(" "); //borra para que no se vean la unidades de las decenas mi_lcd.setCursor(8,1); // posición 8 de la línea 2; unidades } mi_lcd.print(valorTiempo); //ver en LCD el contaje hasta llegar al valor establecido //de tSalida //--------------CHEQUEO DEL TECLADO ------------------------------ char teclaPulsada = mi_Teclado.getKey(); //lee el teclado mantener pulsado al menos 1 sg if (teclaPulsada == 'D') //Si pulso 'D' Desconectar Alarma. { // APAGA LOS LEDS Y ESPERA ser pulsda tecla "C" para activar de nuevo pedirá clave Rdesconectar(); break ;//para poder salir del bucle for (i=0 ; i<= tSalida; i++) } } //FIN del for (i=0 ; i<= tSalida; i++) //---------------------------------------------------------------- //Si se ha llegado al tiempo límite de salida ir a rutina void RchequeoEntradas() RchequeoEntradas(); } //FIN de la rutina RtSalida ()

//------------------------------------------------------------------

//------------------------------------------------------------------------------//++++++++++++++++ Rutina para el tiempo de ENTRADA +++++++++++++++++++//++++++++++++++ Si se pasa del tiempo establecido ACTIVAR ALARMA +++++// ++++++++++++++++++ Si se pulsa`'D' Desactivarla ++++++++++++++++++++//------------------------------------------------------------------------------

void RtEntrada() //se viene desde el void loop > RtSalida() > viene RchequeoEntradas ()> RtEntrada{ int i=0; //variable global tipo int . reinicio el contador CREO QUE NO ES NECESARIO PERO por si a //Se enciende para indicar que debo salir ledRojo (); mi_lcd.clear();//limpiamos la pantalla mi_lcd.print(" Tiempo Entrar: "); //16 caracteres **** // mi_lcd.setCursor(7,1); //posición 7 de la línea 2 //LECTURA del tiempo para la ENTRADA esta en la posición 3 de la EEPROM // tEntrada = EEPROM.read(3); //RlecturaEEPROM(3,3); //-----ESTABLEZCO UN MÍNIMO de 5 sg PARA PODER OPTAR A CONFIGURAR:---- if (tEntrada < 5) { tEntrada = 5; }//fin del if tConfigurar //------------------------------------------------------------------- for (i=0 ; i<= tEntrada; i++) //******** { delay(1000); //tiempo espera de 1 sg int valorTiempo = (tEntrada-i); //Al primer ciclo sale tEntrada y poder ver el decremento mi_lcd.setCursor(7,1); //posición 7 de la línea 2 //cuando sea menor a 10 borrar unidades de las decenas para que no se mantengan if (valorTiempo <= 9) //cuando se llegue a 9 borrar unidades de las decenas para que no se manten { mi_lcd.setCursor(7,1); //posición 7 de la línea 2 mi_lcd.print(" "); //borra para que no se vean la unidades de las decenas mi_lcd.setCursor(8,1); // posición 8 de la línea 2; unidades } mi_lcd.print(valorTiempo); //ver en LCD el contaje hasta llegar al valor establecido //de tSalida //******** CHEQUEO DEL TECLADO ********* char teclaPulsada = mi_Teclado.getKey(); //lee el teclado mantener pulsado almenos 1 sg if (teclaPulsada == 'D') //Si pulso 'D' Desconectar Alarma. { // APAGAR LED EN SEÑAL DE DESCONEXIÓN . //Ahora podría enviarlo a la rutina de configurar la alarma y despues salir del bucle FOR //haciendo: break; o bien i = tConfigurar; Serial.println("SE HA PULSADO <D>"); //Apagar TODO

// APAGA LOS LEDS Y ESPERA ser pulsda tecla "C" para activar de nuevo pedirá clave Rdesconectar(); break ; //de aquí vuelve a "void loop ()" Y vuelve a pedir rutina de configuración //ahora podría enviarlo a la rutinade TESTEAR CLAVE para poder Desconectar: } } //del for (i=0 ; i<= tEntrada; i++) //AQUÍ PONER LAS INSTRUCCIONES NECESARIAS UNA VEZ SE SALGA del tiempo de entrada // si ello es así dar tiempo para entrar y si no se desactiva alarma activar la alarma.

Serial.print("HA PASADO EL TIEMPO: TOTAL: "); Serial.println(tEntrada);

RalarmaActivada(); //Activar la alarma. Ahí se chequea 'D' para desconectarla //Aquí no hay q poner nada } //FIN de la rutina RtEntrada ()

//------------------------------------------------------------------------------//++++++++ Rutina Para El CHEQUEO DE LAS ENTRADAS ++++++++++++++//++++++++++al pasar el tiempo de salida "RtSalida" +++++++++++++//+++++++++++Chequear el pin 7 señal entrada puertas ++++++++++++//+++Si nivel "LOW" puerta abierta; hacer el tiempo de entrada ++//++++++++si no se pulsa "D" o "D1" por móvil Activar la alarma +//------------------------------------------------------------------------------

void RchequeoEntradas() //se viene desde el void loop () > RtSalida{ //-----COMIENZA EL CHEQUEO DE LAS ENTRADAS --------- mi_lcd.clear(); //Limpio la pantalla cursor en posicion 0 fila 1 /// mi_lcd.setCursor (0,0); //posición 0 de la línea 1 mi_lcd.print(" Chequeando ... "); //16 caracteres // Mientras esté cerrada: Intermitencia. " Chequeando ... " while (digitalRead (7) == HIGH) //leer constantemente las entradas { //-----COMIENZA EL CHEQUEO DE LAS ENTRADAS --------- mi_lcd.clear(); //Limpio la pantalla cursor en posicion 0 fila 1 delay (500); // para producir intermitencia. mi_lcd.print(" Chequeando ... "); //16 caracteres delay (500); // para producir intermitencia. } //Fin del while (digitalRead (7) == HIGH) //---------------------------------------------------- // Al abrirsela puerta; hace el contje del tiempo de Entrada. //----Sobra lo del debounce pero lo dejo--- if (digitalRead (7) == LOW) delay (30); //tiempo anular efecto "debounce" de los contactos if (digitalRead (7) == LOW) //sin el Debounc; Si alguien entra; nivel bajo { RtEntrada(); //ir a la rutina de Tiempo de entrada donde además se chequea si //pulso 'D' Desconectar } //----------------------------------------------------

} //FIN de RChequeoEntradas

//-----------------------------------------------------------------//+++++++++++++++++ Rutina ALARMA ACTIVADA +++++++++++++++// ++++Se llega aquí si se supera el tiempo de entrada ++// +++++Y no se ha pulsado 'D' o bien por el móvil "D1" +++//-----------------------------------------------------------------

void RalarmaActivada(){ // ++++NOTA pra manejar el MODEM utilizo el "Serial" pines Rx 0 y Tx 1++++ // +++++++y para el Serial monitor UTILIZO los mismos++++++++ //nota sería más conveniente haber utilizado pines distintos. //para no crear posibles conflictos. Pero Ok. Serial.flush(); //----Para preparar el MODEN en modo Texto---------- Serial.println("AT+CMGF = 1"); // setting the module in txt mode delay(1500); //para que pase el tiempo de recepción del "OK" q envía el modem Serial.println("AT+CNMI=2,2,0,0,0"); // Serial.flush();//pag 175 espera que la ejecución de los datos sea //completa para continuar el programa delay(1500); // A la espera que pase el 'OK' //variable global boolean Flag = 1 Para permitirme boolean Flag = 1; //Activa el LED ROJO los demás apagados ledRojo() ; //--- Para ver en la LCD -------- mi_lcd.clear(); delay (10); mi_lcd.print("ALARMA ACTIVADA"); mi_lcd.setCursor (0,1); //línea 2 mi_lcd.print("ENVIANDO SMS ..."); delay(1000); //-------------------------------- //---PARA VER EN SERIAL MONITOR a través de "Serial" pines Rx 0 y Tx 1--- Serial.println("ALARMA ACTIVADA"); Serial.println("ENVIANDO SMS ..."); Serial.println ("ATDTxxxxxxxxx"); Serial.println ("Alarma Activada. Para desconectar: 'D' o por SMS 'D1'"); Serial.flush(); //Espera hasta que la transmisión sea completa para continuar //la ejecución del sketch. //------------------------------------------------------------------------- //-------------------------------------------------- //+++++ HACE BORRADO DE TODOS LOS SMS leídos. "AT+CMGD = 1,4" ++++ RlimpiarBufferSerie(); delay(200); RlimpiarBufferModem(); //Para ASEGURAR un buen borrado. Y PUEDA ACEPTAR NUEVOS SMS

//++++Hace el envío del SMS y llamada al telefono establecido++++++ RllamadaTelefono(); // Tarda 15 segundos en aparecer ATH (desconexion de la llamada delay (3000); //tiempo para que pase la respuesta del modem "OK" //Con 500 ms sería más que suficiente, pero por seguridad lo dejo RmandaSMS("MENSAJE SMS: Alarma Activada. Para desconectar: 'D' o por SMS 'D1'");

//-------------------------------------------------------

// ++++++ CHEQUEO DEL TECLADO tecla 'D' Y DEL PUERTO SERIE++++++// --------por si entran comandos de control como: -------------//--------- "D1" para desactivar o "C1" para conectar ----------//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

while(Flag == 1) //Bucle cerrado siempre activo hasta el break; { //--------------------------------------------------------------------------- //********************* CHEQUEO DEL TECLADO ****************** //++++DESDE EL TECLADO SÍ PEDIRÁ CLAVE PARA PODER CONECTAR++++ // +++++++++++++++++++Desde el teclado: "D"+++++++++++++++++++++ teclaPulsada = mi_Teclado.getKey(); //lee el teclado mantener pulsado al menos 1 sg

//-------SI SE PULSA TECLA, AVERIGUAR si es 'D' de DESCONECTAR ------- if (teclaPulsada != NO_KEY) { if (teclaPulsada == 'D') //Si pulso 'D' , pedir clave si OK, Desconectar Alarma. { RvalidarClave (); //pedir clave } //+++++Si la Clave es correcta DESCONECTAR ALARMA ++++++ // la tengo como variable global y también operativa en RvalidadClave () if (claveCorrecta == true ) { claveCorrecta = false; //la reiniciamos Rdesconectar(); //desconectarlo TODO y poner MENSAJE. AHÍ SE ESPERA // a poner operativa PULSANDO 'C' o desde el móvil 'C1' break ; //de aquí vuelve a "void loop ()" Y vuelve a pedir rutina de configuración } } //FIN DEL if teclaPulsada != NO_KEY //--------------------------------------------------------------------------- //************ CHEQUEO DEL PUERTO SERIE ************** //++++++NO PEDIRÁ CLAVE SI SE HACE DESDE EL MÓVIL+++++ // +++++++++++++++++ACEPTA "D1"++++++++++++++++++++ lectura = ""; //PARA REINICIARLA //pag 180 libro RC "Serial.find()" lee datos del buffer de entrada (eliminándolos de allí) // hasta que se encuentre la cadena de caracteres(o un carácter individual)especificada como //parámetro, o bien se hayan leido todos los datos actualmente en el buffer. //La instrucción devuelve "true" si se encuentra la cadena o "false" si no

/// RlimpiarBufferSerie(); // OJO //-------------------------- IMPORTANTE ------------------------------------- // ESTOS DOS BLUCLES DE (Serial.available() ME GARANTIZAN EL //PODER LEER SMS con más de 64 bytes que ES LO MÁXIMO QUE ACEPTA EL CHIP TTL-UART --llamada buffer--// de la placa Arduino (ver explicación en pag 178-179 libro RC Curso práctico de Formación.// y ya sabemos que el moden cuando recibe un mensaje envía a la placa arduino el siguiente formato.://+CMGL: 1,"REC UNREAD","+341xxxxxxx9",, "14/08/27,23:25:48+48 (hasta aquí hay 57 caracteres)//Y en la siguiente línea: el texto del mensaje. LO QUE PROVOCARIA QUE SE DESBORDARA provocando//un resultdo IMPREDECIBLE.//---------------------------------------------------------------------------

if (Serial.available()>0) { while (Serial.available()>0) { //Esta instrucción lee datos del buffer de entrada (eliminándolos de allí) //hasta que encuentre la cadena o carácter buscado. if (Serial.find("D1")) { //para verlo en lcd DURANTE 3 SGS SE PUEDE BORRAR AL FINAL //Mensaje cortado para que quepa en la LCD 16x2 mi_lcd.clear(); mi_lcd.print("Alar Desconectad"); mi_lcd.setCursor(0,1); mi_lcd.print("Para Activar:'C'"); //---Para ver en el Serial Monitor---- Serial.println("Alarma Desconectada. Para Conectar: 'C' o por SMS 'C1'"); //------------------------------------- Serial.flush(); //Espera hasta que la transmisión sea completa para continuar RlimpiarBufferSerie(); delay(200); RlimpiarBufferModem(); //Para ASEGURAR un buen borrado. Y PUEDA ACEPTAR NUEVOS SMS RmandaSMS("MESAJE SMS: EXITO Alarma Desconectada. Para Conectar: 'C' o por SMS 'C1'"); //HACER LA RUTINA desconexion de todos y vuelta al loop Flag = 0; //para poder salir del primer while (Flag ==1) Rdesconectar(); break; //salir del While(Serial.available()>0) para ir al inicio void setup() } // FIN del if (Serial.find("D1") or (Serial.find("D1"))) } //FIN DEL while (Serial.available()>0) Serial.flush(); }//FIN DEL if(Serial.available()) } // FIN Del While (Flag == 1)cuando se pulsa 'D' o se introduce por puerto Serie //el comando "D1" para desconectar // para hacer de nuevo RtConfigurar() y comenzar de nuevo el ciclo

} //FIN de void RalarmaActivada() //------------------------------------------------------------------------------------- //----------------------------------------------------------- //++++++ FUNCIÓN DESCONECTAR TODA LA ALARMA +++++ //Depués vuelve al void loop () //donde me pedirá de nuevo configurar SI o NO. //----------------------------------------------------------- void Rdesconectar()

{ lectura=""; boolean Flag = 1; //variable global boolean Flag = 1 //Para permitirme salir o no del While // APAGAR TODOS LOS LEDS EN SEÑAL DE DESCONEXIÓN .

digitalWrite(rojo,LOW); digitalWrite(verde,LOW); digitalWrite(azul,LOW);

//--- Para ver en la LCD -------- mi_lcd.clear(); //limpia y posiciona en 0 de la fila 1 delay (10); //para producir intermitencia mi_lcd.print(" A DESCONECTADA "); //16 caracteres mi_lcd.setCursor(0,1); mi_lcd.print("ACTIVAR CON <C>") ; //15 Caracteres //--------------------------------------------- //NO necesito mandar de aquí mensaje por venir ya de void RalarmaActivada() // RmandaSMS("MESAJE SMS: EXITO Alarma Desconectada. Para Activar: 'C' o por SMS 'D1'"); // Para ver en el Serial monitor usar "Serial" pines Rx 0 y Tx 1 Serial.println(" A DESCONECTADA "); //Apagar TODO Serial.println("ACTIVAR CON <C> o desde el movil <C1>"); //Apagar TODO //------------------------------------------ Serial.flush(); //Espera hasta que la transmisión sea completa //para continuar la ejecución //------------------------------------- RlimpiarBufferSerie(); delay(200); RlimpiarBufferModem(); //Para ASEGURAR un buen borrado. Y PUEDA ACEPTAR NUEVOS SMS //---------------------------------------------------------- // PARA CHEQUEAR TECLADO Y PUERTO SERIE a la espera de //que se pulse "C" de activar o "C1" de conectar vía Serie //---------------------------------------------------------- while(Flag == 1) //Bucle cerrado siempre { // PROVISIONAL DE PRUEBA //********************* CHEQUEO DEL TECLADO ****************** //++++DESDE EL TECLADO SÍ PEDIRÁ CLAVE PARA PODER CONECTAR++++ // +++++++++++++++++++Desde el teclado: "C"+++++++++++++++++++++ char teclaPulsada = mi_Teclado.getKey(); //lee el teclado mantener pulsado almenos 1 sg if (teclaPulsada == 'C') //Si pulso 'C' , pedir clave si OK, Activar Alarma. { RvalidarClave (); //pedir clave } //+++++Si la Clave es correcta DESCONECTAR ALARMA ++++++ if (claveCorrecta == true ) // la tengo como variable global y también operativa en RvalidarClave ( { claveCorrecta = false; //la reiniciamos break; //de aquí vuelve a "void loop ()" Y vuelve a pedir rutina de configuración } //del if (ClaveCorrecta == true )

//---------------------------------------------------------------------- //************ CHEQUEO DEL PUERTO SERIE ************** //++++++NO PEDIRÁ CLAVE SI SE HACE DESDE EL MÓVIL+++++ // +++++++++++++++++ACEPTA "C1"++++++++++++++++++++ lectura = ""; //PARA REINICIARLA //pag 180 libro RC "Serial.find()" lee datos del buffer de entrada (eliminándolos de allí) // hasta que se encuentre la cadena de caracteres(o un carácter individual)especificada como //parámetro, o bien se hayan leido todos los datos actualmente en el buffer. //La instrucción devuelve "true" si se encuentra la cadena o "false" si no

/// RlimpiarBufferSerie(); // OJO //-------------------------- IMPORTANTE ------------------------------------- // ESTOS DOS BLUCLES DE (Serial.available() ME GARANTIZAN EL //PODER LEER SMS con más de 64 bytes que ES LO MÁXIMO QUE ACEPTA EL CHIP TTL-UART --llamada buffer--// de la placa Arduino (ver explicación en pag 178-179 libro RC Curso práctico de Formación.// y ya sabemos que el moden cuando recibe un mensaje envía a la placa arduino el siguiente formato.://+CMGL: 1,"REC UNREAD","+341xxxxxxx9",, "14/08/27,23:25:48+48 (hasta aquí hay 57 caracteres)//Y en la siguiente línea: el texto del mensaje. LO QUE PROVOCARIA QUE SE DESBORDARA provocando//un resultdo IMPREDECIBLE.//---------------------------------------------------------------------------

if (Serial.available()>0) { while (Serial.available()>0) { if (Serial.find("C1")) //(Serial.find("C1") or (Serial.find("C1"))) { mi_lcd.clear(); mi_lcd.print(" A. OPERATIVA "); mi_lcd.setCursor(0,1); //para verlo en lcd DURANTE 3 SGS SE PUEDE BORRAR AL FINAL mi_lcd.print(" A RtConfigurar "); //llegará a RtConfigurar del void setup () Serial.println(" A. OPERATIVA "); Serial.println ("A RtConfigurar del void setup"); Serial.flush(); //Espera hasta que la transmisión sea completa para continuar //----------------------------------------------- RlimpiarBufferSerie(); delay(200); RlimpiarBufferModem(); //Para ASEGURAR un buen borrado. Y PUEDA ACEPTAR NUEVOS SMS // Activada. Para Desconectar: 'D' o por SMS 'D1'"); RmandaSMS("MESAJE SMS: EXITO Alarma Conectada. Inicia ciclo."); Flag = 0; //para poder salir del primer while (Flag ==1) RchequeoEntradas(); //Al hacer la CONEXIóN DESDE EL MÓVIL, ir a "RchequeoEntradas();" break; //salir del While(Serial.available()>0) para ir al inicio void setup() } // FIN del if (Serial.find("C1")

} //FIN DEL while (Serial.available()>0)

Serial.flush(); }//FIN DEL if(Serial.available())

} // FIN Del While (Flag == 1)cuando se pulsa 'C' o se introduce por puerto Serie //el comando "C1" para Conectar // Vuelve al void loop() comienza de nuevo } //FIN de void Rdesconectar() //;------------------------------------------------------------------------------

//;------------------------------------------------------------------------------ //++++++ Rutina de ENVÍO DE SMS POR SALTAR LA ALARMA +++++ //;------------------------------------------------------------------------------

void RmandaSMS(String

{ //---------------------------------------------------- //ir a rutina para leer el nº de telfno posicion 8 a 16 y leerlo como caracter String telefono = "" ;// Numero de telefono para Mandar SMS telefono = RlecturaEEPROM(8,16,0); delay(100); //----------------------------------------------- //Lo quito por estar ya configurado así el modem en la rutina "RalarmaActivada()" //Seleccionamos el formato del SMS (1 = texto y 0 = PDU) ///// Serial.println("AT+CMGF=1"); //Seleccionamos modo texto // delay(1500); //quizas mejor poner 3000 Como hace arduteka Serial.print("AT+CMGS=\""); //Añadimos el numero de telefono Serial.print(telefono); Serial.println("\""); delay(1500); // Y CREO QUE incluso menos tiempo. // --Para ver en el serial monitor el mensaje----- Serial.println(mensajeSMS) ; // recibirá el mensaje: "Alarma Activada. Para Desconectar: 'D1'" // o bien el mensaje: "Alarma Desconectada. Para Activar: 'C1'" delay(500); //------------------------------------------------- //write escribe un sólo caracter. print escribe cualquier cosa; caracter, //texto, char, int,long etc. ver pag 225 libro RC Serial.write(0x1A); //Mandamos un Ctrl+Z //Estas dos instrucciones de abajo se pueden sustituir por: //Serial.println(); Serial.write(0x0D); //Mandamos un CR Serial.write(0x0A); //Mandamos un LF Serial.flush(); //----------------------------------------------- //----------------------------------------------- RlimpiarBufferSerie(); delay(200); RlimpiarBufferModem(); //Para ASEGURAR un buen borrado. Y PUEDA ACEPTAR NUEVOS SMS } //FIN void RmandaSMS()

//;----------------------------------------------------------

//;---------------------------------------------------------- //++++++ Rutina de LLAMADA DE TELEFONO/S +++++ //;----------------------------------------------------------

void RllamadaTelefono()

{ //Este es el comando para envío de llamada; !!!es más rápido!!!! //si utilizase "ATD" descuelga el telefono y Espera tono antes de marcar //TARDA 2 sgs más que haciendolo con "ATDT"

delay(500);

String comandoAT ="ATDT"; //lo necesito para poder poner el comando GSM //a los 7 segundos salta el telefono y desconecta despues de 3 pitadas //+++++++PARA VER EN LCD SE PUEDE ELIMINAR !!!!!!!!!!!!!!!!!!!!!!!!! //lecturaE es variable gloabal String mi_lcd.setCursor(0,1); //POSICIÓN EN EEPROM DEL TELEFONO el 0 es para "flafTel" si es ==0 "char c" en lugar de "int c lecturaE = RlecturaEEPROM(8,16,0); mi_lcd.setCursor(0,1);// fila 2 mi_lcd.print (comandoAT + lecturaE);//(comandoAT + telefono + ';'); // //No pongo "println" para que no se vea en pantalla enter y salto de linea ## //para efectuar llamada es Serial.println(comandoAT + lecturaE + ';'); //es decir punto y coma , enter y cambio linea

//////////////////////////////////////////////////////////////// delay(1500); Serial.println(comandoAT + lecturaE + ';'); //Añadimos el numero de telefono Serial.println(comandoAT delay(15000); // con este tiempo suena 3 veces el telfno. con 12sg suena 2 veces Serial.println("ATH"); //colgaremos y finalizaremos la llamada delay(5000); //espera 5 sg } //FIN void RllamadaTelefono()

/* TAMBIÉN FUNCIONA a los 7 segundos salta el tele

Serial.print("ATD"); //Añadimos el numero de telefono Serial.print(telefono); //se encuentra en variable global char telefono[]="123456789"; Serial.print(';'); Serial.println("\"");//DEBO PONERLO DE LO CONTRARIO suena el tefno más mucho mas tarde*** delay(12000); // CON 12 SG suena 2 veces el telefono y con 15000 suena 3 veces Serial.println("ATH"); //colgaremos y finalizaremos la llamada */

//------------------------------------------------------------------------------- ///++++++ Rutina RlimpiarBufferSerie() +++++ // Eliminación de los datos del buffer de entrada que no queremos //de modo que se limpie de ""basura"" con available() se almacenan en una pequeña

//memoria temporal de 64 bytes los bytes recibidos por el puerto serie a la espera //de ser leidos y borrados por Seria.read() ver pag 178 libro RC... //-------------------------------------------------------------------------------

void RlimpiarBufferSerie()

{ while (Serial.available()> 0) { Serial.read() ; //lee y limpia lo que lee } } //FIN rutina RlimpiarBufferSerie()

//--------------------------------------------------------

//--------------------------------------------------------------------- ///++++PARA LEER TODOS LOS MENSAJES LEIDOS Y NO, PARA LUEGO BORRARLOS+++++++ //hago esto para poder usar la instruccion borrar todos los SMS LEÍDOS (1,1), pues //con "AT+CMGD=1,4" que borraria TODOS NO PUEDO TRABAJAR crea problemas EN MI MODEM // Una vez que de la orden de mostrarlos todos YA SERÁN TODOS como leídos // y los podré borrar con la instruccion "AT+CMGD=1,1"//---------------------------------------------------------------------- void MostrarSMSTodos() { delay(300); // Serial.print("AT+CMGL=\""); Serial.print("ALL"); Serial.println("\""); //son las comillas (se envía el enter println) Serial.flush(); // espera a que se envíe antes de continuar //ello es debido a que la instruccion "Serial..." es asíncrona //lo que significa que el programa sigue sin esperar a que se realice //el envío de datos ver explicacion en pági 175 libro RC Curso Practico de prog

delay(3000); }// FIN DEL void MostrarSMSTodos() //------------------------------------------------ //-------------------------------------------------------- ///++++++ Rutina RlimpiarBufferModem(() +++++ //NOTA el buffer del MODEM wavewom puede almacenar hasta 20 mensajes //por ello conviene eliminarlos de vez en cuando para que no se //queden esperando a ser leídos. lo que porvocaría que la alarma //no pueda ser actuada desde el telefono móvil//-------------------------------------------------------- void RlimpiarBufferModem() { delay(500); Serial.println("AT+CMGD=1,4"); //Borramos TODOS los SMS. Serial.flush() ; //Esepra que se la transmisión sea completa //------------------ "IMPORTANTE" ------------------ //Espera a recibir el "OK" DE TODOS LOS SMS BORRADOS, //puede llegar a tardar bastantes segundos 15 sg . NO SUPRIMIR!! while(Serial.read()!='K') {

; } RlimpiarBufferSerie(); delay(200); //-------------------------------------------------- delay(5000); //tiempo proceder actuar nuevamente el modem. } //FIN DEL void RlimpiarBufferModem()

//---------------------------------------------------------//--------------------------------------------------------- ///++++++ Rutina RlecturaEEPROM (......)+++++ //lee la MEMORIA EEPROM desde las posiciones indicadas //Para obtener : los //posicion 1 para tConfiguracion //posicion 2 para tSalida //posicion 3 para tEntrada // la clave posiciones 4 a 7 //telefono posiciones 8 a 16 //los numeros como ENTEROS sacados de ; lectura.toInt()//--------------------------------------------------------

String RlecturaEEPROM (int inicio, int final, boolean flagTel){ x = 0 ; //variable global int lecturaE = ""; //Variable global String for (x=inicio; x <= final; x++) //SOLO LEE CARACTERES { //Sies flagTel == 1 leer como ENTERO la eeprom

if (flagTel == 1) //LECTURA COMO ENTERO con int c = EEPROM.read(x) { int c = EEPROM.read(x); lecturaE.concat (c); delay(10); //Conveniente para que la concatenación //ver ej 4.22 explicativo en libro RC pag 209 //mi_lcd.print (c); } //PARA LA CLAVE Y EL NÚMERO DE TELEFONO/SMS SE DEBE LEER COMO CARCTERES //usando char c = EEPROM.read(x); // tipo char para ver en LCD y PC la cadena de la clave y numeros del telefono //posición 8 a 16 EEPROM lecturaE.concat (c) else /// es mejor y mas seguro poner "else" que " if (flagTel == 0)" { char c = EEPROM.read(x); lecturaE.concat (c); delay(10); //Conveniente para que la concatenación se haga de forma ordenada //ver ej 4.22 explicativo en libro RC pag 209 /// mi_lcd.print (c); } //FIN DEL else } //FIN del for

flagTel = 0; //lo reiniciamos

return lecturaE;

} //FIN rutina RlecturaEEPROM (int inicio, int final)

//------------------------------- 0 ------------------------------

//////////////////// OTRO PROGRAMA CON EL CUAL ME HE AYUDADO /////////////////////////////////////

/** Fecha: 10/07/2013* Autor: Cristóbal Medina López* Licencia:* Este Software está distribuido bajo la licencia general pública de GNU, GPL. Puedes encontrar esta licen* Es gratuito, puedes copiar y utlizar el código líbremente sin cargo alguno. Tienes derecho a modificar* el código fuente y a distribuirlo por tu cuenta, siempre informando de la procedencia original.** Activar relé mediante llamada de teléfono. Versión 2013.*/

/* //Hacemos uso de SoftwareSerial para usar dos pines cualquiera de arduino #include <SoftwareSerial.h>

SoftwareSerial Serial(5,6); //rx,txString inGSM; //Almacenar la informaciÓn leida del modulo gsmString numList[]={"6352----1","9566----9"}; //Números autorizados boolean intrusos=false;double ttl=0; //Tiempo de vida

void setup(){ pinMode(9, OUTPUT); // relé pinMode(2, INPUT); // pulsador pinMode(11, OUTPUT); // altavoz pinMode(10, OUTPUT); // igt modulo gsm tc35 Serial.begin(9600); Serial.begin(9600); initGSM(); //iniciar el modulo gsm}

void initGSM(){ digitalWrite(9,LOW); //desactivamos el relé (activo a nivel bajo) digitalWrite(10,LOW); //activamos el modulo gsm (activo a nivel bajo) Serial.println("Iniciando..."); ///// Serial.print("AT+CPIN=1234\r\n"); //Enviar PIN (1234) delay(10000); ////// Serial.print("AT+CLIP=1\r\n"); //Activar alarma llamada ///// delay(500); Serial.print("AT+CMGF=1\r\n"); //Activar modo texto delay(500); }

//Función: Comprueba si el número está autorizado//true si tiene permiso, false si no lo tiene.boolean isAllow(String num){ for (int i=0;i<sizeof(numList);i++){

if (num==numList[i]) return true;

} return false;}

// Función: Accionar relé

void fire(){ digitalWrite(9,HIGH); delay(800); //tiempo que permanece activo el rel'e digitalWrite(9,LOW);}

// Función: Enviar smsvoid sendSMS(){ Serial.print("AT+CMGS=635----61\r\n"); //Comando AT enviar

SMS delay(1000); Serial.print("Estoy operativo ;)"); //Mensaje delay(1000); Serial.print("\x1A"); //Enviar ascii SUB es crtl+Z en Hexadecimal }

void loop() { inGSM=""; ttl++;

//Si se detectan intrusos llamar al administrador (666554433) //Se ha liberado el pulsador if (digitalRead(2) == HIGH && intrusos==false){

intrusos=true;Serial.print("ATD956----19;\r\n"); //el código ATDnumero descuelga y llama al nº

solicitado, // espera tono de llamada antes de marcar, //si no se detecta ese tono en 5Seg el modem devuelve "No dial

//si se detecta el tono el modem espera 7 sg, //si no establece conexión el moden vuelve a estado de comando.

delay(500); }

//Si intrusos, emitir sonido (alarma). if (intrusos){ tone(11,800,100); //en el pin 11 genera un tono de 800 Hz y duración de 100 ms delay(200);

}

//Leer enventos en modulo gsm while (Serial.available()>0){

delay(10); inGSM += (char)Serial.read(); }

Serial.print(inGSM);

//Si llamada if (inGSM.indexOf("RING")>-1){

delay(1000); Serial.print("AT+CHUP\r\n"); //Rechazar llamada

String num; int inicio=inGSM.indexOf('"')+1; int fin=inicio+9;

num=inGSM.substring(inicio,fin); //Extraer n'umero

//Si es el administrador, detener alarma.if (num=="956-----9"){

intrusos=false; }

//Si autorizado, accionar rel'e if (isAllow(num)){

fire();

}else{ // *** Opcional *** // Si n'umero de control (950000000) if (num=="956-----9"){

// Enviar SMS al administrador para consumir saldo. sendSMS();

} }

}

//En caso de perder la cobertura, volver a conectarse a la red if (inGSM.indexOf("CREG:")>-1 && inGSM.indexOf("CREG: 0,1")==-1 && inGSM.indexOf("CREG: 0,5")==-1){ Serial.println("Se ha perdido la cobertura, reiniciando..."); Serial.print("AT+CFUN=1,1\r\n");

delay(4000); initGSM(); }

//Comprobar estado de la red if (ttl==150000){ Serial.print("AT+CREG?\r\n"); ttl=0;

} }*///////////////////////////////////////////////////////////////////////////////////

Módem Wavecom M1306B. Punto Flotante S.A.

1

GUÍA PARA LA CONFIGURACIÓN Y PRUEBAS PRELIMINARES D EL

MÓDEM WAVECOM M1306B

NOTA IMPORTANTE: Por favor consulte el manual Fastrack_M1306B_User_Guide.PDF para mayor información al respecto de la operación del módem, y el documento AT Commands Guide.PDF para una referencia completa sobre el set extendid o de comandos AT. Ambos documentos los puede encontrar e n el sitio:

www.puntoflotante.net/MODEM-WAVECOM.htm Para realizar estas pruebas y en general para imple mentar y operar el módem WAVECOM M1306B dentro de un sistema automático de s upervisión y control a través de la red GSM, es indispensable que el usuar io cuente con:

- Conocimientos y experiencia en electrónica, en part icular, el funcionamiento de los sistemas basados en microcontroladores y su programación.

- Conocimiento del manejo del puerto serial RS232 y e l cable USB-Serial. - Conocimiento del manejo del programa Hyperterminal en la PC. - Conocimiento del manejo del set extendido de los co mandos “AT” para

módems GSM. - Conocimientos generales de la operación de la red G SM-SMS.

En esta guía se describe: - Cómo instalar el SIM en el módem y conectarlo a la PC. - Pruebas para recibir y generar llamadas de voz desd e el módem - Pruebas de envío de mensaje SMS. - Pruebas de recepción de mensajes SMS. Cómo leer los mensajes y cómo

borrarlos. - Cómo medir la calidad de la señal del enlace entre el módem y la red GSM. - Cómo configurar el módem para el cambio de banda de operación. - Cómo configurar el módem para cambiar la velocidad a 9600 bps.

Configuración actual del Módem WAVECOM M1306B Su módem ya está configurado para operar en la band a de 1900 Mhz, que es la utilizada en México, y a una velocidad de su puerto serial de 115,200 bps. Al final de este instructivo se señala n los comandos para modificar estos dos parámetros, en caso de que el usuario así lo requiera.


2

1. El módem requiere un chip SIM para funcionar en la red GSM.

Usted puede utilizar un chip tomado de su propio ce lular ó ir a su compañía para adquirir uno. Es recomendable que, si acude a la compañía, lleve el módem y lo muestre al ejecutivo que lo atienda.

2. Oprimiendo el botoncito amarillo con la punta de una pluma,

extraiga el pequeño contenedor negro de plástico. C oloque el chip (SIM) e insértelo de nuevo en el compartimento (ver fotos).


3

3. Atornille la antena en su lugar. 4. Conecte el eliminador. El led rojo al frente del módem deberá

encenderse. Transcurridos unos 15 a 30 segundos, si el módem tiene el SIM insertado, y se encuentra correctament e enlazado con la red GSM, el led rojo deberá parpadear, lo cual i ndica que se encuentra listo para funcionar.

5. Conecte el cable serial (DB15) en la parte poste rior del módem (ver

foto). Conecte la terminal DB9 del cable serial a s u computadora PC, ya sea en forma directa ó a través de un cable USB-Serial. Instructivo aquí: www.puntoflotante.net/CABLEUSBAG.htm


4

6. Una vez realizadas las conexiones entre la PC y el módem, como

se muestra en la foto de abajo, abra en la PC el so ftware Hyperterminal (ó cualquier otro programa emulador d e terminal) con configuración 115,200 bps formato 8,N,1. Una vez dentro del programa, desde la PC realice es tas pruebas. Cada prueba se acompaña de una pantalla ejemplo tom ada de Hyperterminal.


5

Inicie tecleando el comando: at Termine el comando con un <Enter> OK Ésta deberá ser la respuesta del módem Si la respuesta del módem es la indicada, las comun icaciones con el puerto serial están funcionando correctamente. El siguiente comando, verifica que el chip SIM está instalado y ha sido reconocido por la red GSM: at+cpin? +CPIN: READY Si el led al frente del módem está parpadeando, ést o indica que está enlazado correctamente con la red GSM y listo para funcionar. Puede verificarlo con el siguiente comando: at+creg? +CREG: 0,1


6

Continúe probando el módem, tecleando los comandos indicados en la ventana de arriba. Deberá obtener las respuestas mostradas. Con el comando <at+cgmm> se verifica la banda de operac ión del módem. En el caso de México, deberá mostrar 1900 Mhz, como en la imagen de arriba.

***PRUEBAS***

Las pruebas descritas enseguida presuponen que el m ódem se encuentra ya con el chip SIM insertado y que se ha enlazado correcta mente con la red GSM (el led rojo al frente del módem deberá estar parpadeando).


7

PRUEBAS DE INTENSIDAD DE LA SEÑAL DE LA RED GSM

Para verificar la calidad de la señal con la que el módem está comunicándose con la red GSM, use el comando: at+csq Por ejemplo, en la prueba mostrada en la imagen de abajo, el módem respondió: +CSQ: 14,0 en donde 14 es la intensidad de la señal y 0 es e l

promedio de errores en la comunicación. La calidad de la señal en este caso es buena.

La siguiente tabla muestra los rangos de intensidad de la señal:

0-10 INSUFICIENTE 11-31 SUFICIENTE 32-98 NO ASIGNADO

99 NO HAY CONEXIÓN


8

PRUEBAS CON EL MÓDEM RECIBIENDO Y GENERANDO LLAMADA S

DE VOZ: Marque el número del módem desde un teléfono celula r ó local. Al detectar la llamada, el módem enviará el texto “RIN G” hacia la terminal, como se muestra en la imagen. También puede llamar a un teléfono celular ó local con el comando: atdt5556535801; El módem llama al número seleccionado. Para colgar, tecleé el siguiente comando: ath

El módem cuenta con señales, en su conector DB15, p ara la conexión de un micrófono y una bocina para poder realizar la comunicación por voz. Por favor refiérase al manual Fastrack_M1306B_User_Guide.PDF para mayor información al respecto.


9

PRUEBAS DE ENVÍO DE MENSAJE SMS: Escriba el comando mostrado, incluyendo el número d e teléfono al cual desea enviar su mensaje, por ejemplo: at+cmgs=”5530322590” Debe esperar el promp “>” y escribir enseguida el t exto del mensaje y, al final del mensaje un <CTRL Z>. En este ejemplo, el texto enviado es “WAVECOM MODEM MESSAGE”.

El mensaje se envía automáticamente. Momentos despu és, el módem envía el texto “ +CMGS: 27” confirmando que se trata del mensaje enviado número 27. El teléfono celular con el númer o elegido deberá recibir el mensaje, típicamente en cuestión de segu ndos.


10

PRUEBAS DE RECEPCIÓN DE MENSAJE SMS. Primeramente debe inicializarse el módem con los co mandos: at+cmgf=1 at+cnmi=2,1,0,0,0 Una vez inicializado, cada vez que reciba un mensaj e, el módem automáticamente enviará a Hyperterminal el siguient e texto: +CMTI: “SM”,2 Donde 2 es el número de mensajes recibidos hasta es e momento. El buffer del módem puede almacenar hasta 20 mensajes. Más abajo se indica la forma de borrar el buffer. Para recuperar los mensajes: at+cmgl=”all” at+cmgl=”rec unread” En el primer caso, recupera todos los mensajes, en el segundo caso, solamente los no leídos. Cada mensaje contiene el n úmero de teléfono del cuál se envió, la fecha, la hora y en la siguie nte línea, el texto del mensaje.


11

Para leer mensajes individuales: Comando: at+cmgr=1 Recupera el mensaje número 1 at+cmgd=1 Borra el mensaje número 1. (ya no se podrá leer más tarde)


12

Si el buffer de mensajes se llena (el numero máximo de mensajes en el buffer es de 20) el módem ya no podrá recibir ningú n mensaje nuevo. En la ventana de abajo puede verse cómo el buffer e sta lleno de 20 mensajes. Aquí es necesario vaciar el buffer. Para vaciar el buffer se envía: at+cmgd=1,1 (para vaciar todo el buffer) at+cmgl=”all” (para checar de nuevo el buffer) OK (no existe información) CMTI: “SM”,1 CMTI: “SM”,2 Estas 2 líneas de texto las mandó la red y son 2 me nsajes nuevos que, al llenarse el buffer, se quedaron esperando a ser recibidos. Al vaciarse el buffer, llegaron los 2 mensajes pendientes.


13

En esta ventana se recuperan los dos mensajes que l legaron con el comando: at+cmgl=”all”


14

EJEMPLO DE CAMBIO DE LA BANDA DE OPERACIÓN

Ejemplos de comandos para configurar el módem WAVEC OM modelo M1306B en la red a 1900 mhz. El chip (SIM) debe est ar instalado. Inicializar Hyperterminal a 115200 bps, con formato 8,N,1. Todos los comandos deben ser concluídos con un <Enter>.

Vea la ventana mostrada abajo. Inicie con el comand o <at+cgmm > y verifique la banda en la que se encuentra operando el módem. En este ejemplo, el módem se encuentra inicialmente configurado para operar en las bandas de 900 y 1800 Mhz. Al terminar la configuración, estará operando en las bandas de 850 y 1900 Mhz. Si ga los comandos como se muestra en la imagen:


15

En este otro ejemplo, el módem se encuentra inicial mente configurado para operar en las bandas de 850 y 1900 Mhz. Al ter minar la configuración, estará operando en las bandas de 900 y 1800 Mhz. Siga los comandos como se muestra en la imagen:

EJEMPLO DE CAMBIO DE VELOCIDAD EN EL PUERTO SERIAL Ejemplo de cambio de velocidad a 9600 bps. Supongam os que el módem está inicialmente configurado para 115200 bps . Con el comando: at+ipr=9600 (aquí se cambia la velocidad del módem. Cambie la velocidad en Hyperterminal de 115200 a 9600) at&w (guarda la velocidad en EEPROM. La sig uiente vez que encienda el módem, la velocidad inicial será de 960 0 bps)


16

Confirme el cambio de velocidad con el comando: at+ipr? El módem responde: +ipr: 9600 La velocidad de operación ha sido cambiada. El comando: at+icf? Verifica paridad y bits de paro +ICF: 3,4 Significa 8 bits de datos, 1 bit de paro, sin paridad


17

RESUMEN DE ALGUNOS COMANDOS AT PARA MÓDEM WAVECOM

M1306B

Todos los comandos deben antecederse con “at+” y de ben concluirse con un <Enter> CSQ CALIDAD DE LA SEÑAL CFUN=1 REINICIA OPERACIÓN DEL MODEM CREG? CREG=0,1 (MÓDEM CONECTADO A LA RED GSM, EL LE D ROJO FLASHEA) COPS? 0,2,334020 ID. DE LA RED (334020 ES EL ID. DE TELCEL) CPIN? “READY” (SIM INSERTADO Y LISTO) CGMM G850 1900 (BANDA DE OPERACION) WHWV “HARDWARE V3.05” WDOP “PRODUCTION DATE 15/2008” CGMI “WAVECOM MODEM” (MARCA DEL MÓDEM) CGMR SOLICITA DATOS DE FABRICACIÓN CGSN SOLICITA NÚMERO DE SERIE COPS=? SOLICITA LOS DATOS DEL OPERADOR DE LA RED:

“TELCEL GSM 334020” (DEMORA 15 SEGUNDOS APROX. EN R ESPONDER) WOPN=0,334020 “TELCEL GSM” WIND=255 COMANDO PARA HABILITAR MENSAJES AUTOMÁTIC OS

CUALQUIER DUDA:

[email protected] (0155) 5653-5801

Education

Alarma arduino wavecom programa y esquema numeros borrados 48 pag