Ayuda para Proyecto Alarma Casera.

El material lo puedes comprar en cualquier tienda especializada (si tienes prisa) o por internet a precios muchisimo más economicos.

Aquí te dejo un proveedor, en el cual compre los PIR, Sirenas Exteriores (Ojo se pide la base + Electronica por un lado y el resto de la caja por otro), Detector de Humo... (www.securitywarehouse.co.uk) los precios muy buenos, pero tambien te digo que te armes de paciencia, mi pedido tardó casi 45 dias en llegar!!! pero cuando lo hizo todo en perfecto estado...

Con respecto al sistema RFID, yo compre este (http://iteadstudio.com/store/index.php?main_page=product_info&cPath=16&products_id=7) despues de tenerlo en mis manos me di cuenta que el protocolo que utiliza es "Wiegand", al principio me parecia complicadisimo... nada mas lejos de la realidad, es de lo mas sencillo del mundo... lee y envia el codigo del llavero / Tarjeta, dicho sea de paso, un codigo de 26 bits... más que suficiente para considerarlo de "seguridad"...

prisa de momento no tengo, estoy pillando material, el tema del RFID me resulta muy interesante, ya que seria pillar una llave por cada mienbro de la familia q va al chalet y al cercar la llave se activa y desactiva la alarma, me parece super comodo y encima es barato.

voy a seguir pillando material, a ver como creo la barrera de manera que no se vea el laser....

Imagina:
flypycfv,

El tema de montar una alarma en casa se puede hacer tan sencillo / complicado como uno quiera... yo empecé provando un sensor PIR y ahora tengo 7 repartidos por la casa + 1 detector de humos (lo añadiria a tu proyecto, funciona igual que un PIR), 2 sirenas exteriores (Standar , se controlan sin problemas), Aviso por SMS o llamadas (GPRS Module), Activacion / Desactivacion por RFID + Señal sonora (Radiofrecuencias, vamos, los tipicos llaveritos), alimentado todo por un SAI (el tipico de los ordenadores) y es capaz de mantener todo el sistema en marcha casi un mes despues de un corte de luz... ahora quiero añadir los detectores magneticos... Por cierto todo controlado con una duemilanove (y todavia me sobran pins!!!)

Te recomendaria que empezases con un par de PIRs y un sistema de aviso que no arme mucho ruido... y poco a poco ir ampliando el sistema hasta que tu quieras...

Buenas imagina, podrias pasar el codigo para el duemilanove? para ver como usar el RFID y demas. Me parece interesante el tema, incluso para usarlo de "llave" para garaje o puerta de casa aparte del llave normal o interfono y telefono movil :stuck_out_tongue:

Te dejo el codigo para el ID12

http://www.arduino.cc/playground/Code/ID12

o tambien la de parallax

Code
http://www.arduino.cc/playground/Learning/PRFID

Comeollas, deberías hacer honor a tu nombre y acerlo tu solito!!! jeje...

Aquí tienes el codigo que utilizo con el RFID comendato anteriormente (Protocolo Wiegand)

Lo tienes enterito... quiero decir que este codigo aparte de comunicarse con el RFID puede gestionar hasta 10 usuarios (facilmente modificable) dandolos de alta, o baja y guardando los datos en la EEPROM.

La forma de gestionar los usuarios es a traves de una llave maestra, pasas esta seguida de otra llave (en menos de 1 segundo), si no existe, la autoriza, si ya existe la desautoriza... tanto en un caso, como en el otro, actualiza la EEPROM.

/////////////////////////////////////////////////////////////////////////////////////////
// 2010-11-01 - IMAGINA                                                                //
//                                                                                     //
//                                                                                     //
// EEPROM_writeAnything y EEPROM_readAnything  (Modified by IMAGINA) - Author Unknown  //
/////////////////////////////////////////////////////////////////////////////////////////

#include <EEPROM.h>

#define Master 12345678                   // Codigo Maestro

struct config_t {
    long Log[11];                         // Array para guardar los codigos en la EEPROM (10 usuarios)
} configuration;

volatile long Cod_Bin = 0;                // Codigo Leido
volatile long Ant_Cod_Bin = 0;            // Codigo Anterior

volatile int Num_bit = 0;                 // Contador para los 26 bits - Codigo Wiegand RDFI

long Tiempo = 0;                          // Utilizado para evitar repeticiones muy continuas

template <class T> int EEPROM_writeAnything(int ee, const T& value)
{
    const byte* p = (const byte*)(const void*)&value;
    for (int i = 0; i < sizeof(value); i++)
	  EEPROM.write(ee++, *p++);
}

template <class T> int EEPROM_readAnything(int ee, T& value)
{
    byte* p = (byte*)(void*)&value;
    for (int i = 0; i < sizeof(value); i++)
	  *p++ = EEPROM.read(ee++);
}

void Cod_Bin_1() {                        // Si la señal entra por este pin - Añade un 1 al codigo Binario
  Num_bit++;
  Cod_Bin = Cod_Bin << 1;
  Cod_Bin |= 1;
}

void Cod_Bin_0() {                        // Si la señal entra por este pin - Añade un 0 al codigo Binario
  Num_bit++;
  Cod_Bin = Cod_Bin << 1;  
}

void setup()
{
  Serial.begin(115200);
  attachInterrupt(0, Cod_Bin_0, FALLING);                    // DATA0 - pin 2
  attachInterrupt(1, Cod_Bin_1, FALLING);                    // DATA1 - pin 3
  EEPROM_readAnything(0, configuration);                     // Cargamos la Configuración de la EEPROM
  configuration.Log[0]=Master;                               // Obligamos a que el primer Registro del Array sea el Master (por si acaso...)
}

void loop() {
  if(Num_bit >= 26){                                         // Si se ha recibido un codigo completo...
    if (Cod_Bin != Ant_Cod_Bin){                             // Evita lecturas Repetitivas
      if (Log_Correcto() || Ant_Cod_Bin==Master){            // Si es Correcto o (Master + Codigo Nuevo)
        if (Cod_Bin==Master) Tiempo=millis() + 1000;         // Solo se dispone de este tiempo para Registrar / Eliminar a un Usuario (un Segundo)
        if (Ant_Cod_Bin==Master && Cod_Bin!=Master) Nuevo(); // Si Codigo Master + Otro Codigo --> Decide si Registrarlo o Eliminarlo...
        else Serial.println("REGISTRADO");                   // Aquí lo que tenga que hacer el registrado
       }
       else Serial.println("NO REGISTRADO");                 // Aquí lo que tenga que suceder si no se está registrado
      }   
   Ant_Cod_Bin = Cod_Bin;
   Cod_Bin = 0;
   Num_bit = 0;
  }    

  if (millis() >= Tiempo) {  
    Ant_Cod_Bin = 99999999;
    Tiempo = millis() + 5000;                                // Una lectura cada 5 segundos (Excepto si es Master)
    }  
}

void Nuevo() {
  if (!Log_Correcto()){
    for (int i=0; i<10; i++)
      if (configuration.Log[i]<=0){  
        configuration.Log[i]=Cod_Bin;                       // Si No Esta Registrado Busca el primer Espacio Disponible en el Array y Registra el Nuevo Codigo
        i=999;                                              // Una vez encuentra el primero, Obliga a salir
        }
      }
  else {
    for (int i=0; i<10; i++)  
      if (configuration.Log[i]==Cod_Bin) configuration.Log[i]=0;    // Si Esta Registrado - Lo Elimina 
    } 

  EEPROM_writeAnything(0, configuration); // Guardamos la nueva Configuración en la EEPROM
    
}

int Log_Correcto()
  {
   for (int i=0; i<10; i++) 
     if (configuration.Log[i]==Cod_Bin) return(1); // 1 = Registrado
   return(0);                                      // 0 = NO Registrado
  }

Por cierto, para mi gusto, pidiendo los codigos se le quita toda la gracia que tiene Arduino!!! jajaja... eso si, para aprender vienen genial... :wink:

Un Saludo...

Muchas gracias Imagina, si que quita gracia :stuck_out_tongue: pero no sabia ni que es el wiegand (ni aun ahora, despues de escrivir esto me piro a la wikipedia a informarme xD) tocara entender porque hace lo que hace tu codigo y intentar hacerlo a mi modo para ver si lo he entendido jajaja.

Compre en la web el modulo y unos llaberos, haber si tengo suerte y en el sistema domotico le implemento tambien apertura de puertas y otros.

Hola de nuevo,

Al principio da la sensacion que en este codigo no exista ningun protocolo de comunicacion, como dije en un post anterior dicho protocolo es tremendamente sencillo. Si tienes problemas con el te lo explico...

Por cierto, a este codigo le falta una especie de filtro, por lo menos en mi caso, me explico... Al cablear la casa tuve que pasar los cables cerca de unos de luz, como veras este codigo se limita a recoger los datos que entran por dos cables y cada 26 bits chequea si es correcto o no, da la casualidad que si enciendo una de las luces de la casa un numero de veces, las interferencias producidas son recogidas por este codigo, y logicamente no coinciden con ninguna llave registrada, por lo tanto se escuchan unos BIP, BIP, BIIIP por toda la casa!!! jajaja... solución, controlar que los 26 bits sean recibidos en un periodo de tiempo, por ejemplo medio segundo, si no es así, se descartan como basura...

me llego el lector RFID de la web que comentaste imagina, he puesto el codigo en el arduino y veo que tengo un problemilla...

Los llaberos tienen 10 digitos en lugar de 8 y el arduino si pongo los 10 digitos y tienen un numero superior al 7 me dice que "invalid digit "9" in octal constant" nueve por ejemplo es el ultimo numero de uno de los llaberos que quiera ponerlo de master.

Alguna idea de como podria usarlos estos llaberos?

de paso alguien tiene el codigo mas sencillo posible que solo sirva para leer con el RDM630 Wiegand los llaberos y que lo muestre por serial lo leido, solo que lea que no haga nada de nada mas, para yo comprender como funciona, con el codigo completo me vuelvo loco xDDDD

Te explico un poco, el código que llevan los llaveros por detrás hay que calcularlo partiendo del código binario (el que nosotros recibimos) quitandole el numero de fabricante, el código de inicio y final de transmisión, etc... vamos que en principio no nos interesa, por lo menos a mi lo único que me interesa es que el código de cada llave sea UNICO (Ni siquiera necesito saber que código es).

Este programita lee el código RFID y lo imprime por puerto Serie... ( el código que necesitas para el otro programa "Código Maestro")

No lo he probado pero en principio tiene que funcionar... :wink:

volatile long Cod_Bin = 0;
volatile int Num_bit = 0;

void Cod_Bin_1() {
  Num_bit++;
  Cod_Bin = Cod_Bin << 1;
  Cod_Bin |= 1;
}

void Cod_Bin_0() {
  Num_bit++;
  Cod_Bin = Cod_Bin << 1; 
}

void setup(){
  Serial.begin(9600);
  attachInterrupt(0, Cod_Bin_0, FALLING);                    // DATA0 - pin 2
  attachInterrupt(1, Cod_Bin_1, FALLING);                    // DATA1 - pin 3
}

void loop() {
  if(Num_bit >= 26){
   Serial.println(Cod_Bin);
   Cod_Bin = 0;
   Num_bit = 0;
  }   
}

Probe el codigo para leer el codigo , siempre me da 0.

Amph que rabia no entiendo ni por donde empiezas jajajaja

Comeollas, te dejo este enlace del proyecto de los chicos de tronixstuff. Creo que había una función para comparar los tags que te vendra bien para tu casita domotica.

Enlace.
http://tronixstuff.wordpress.com/2010/12/16/project-the-kid-e-log/

Saludos.

Ademas estos ejemplos te vendran bien para entenderlo mejor.
URL
http://tronixstuff.wordpress.com/2010/08/18/moving-forward-with-arduino-–-chapter-15-– rfid-introduction/

Saludos.

Gracias Flico voy a mirarmelos por la mañana, haber si consigo entender el "porque", esque de los codigos que he visto tan siquiera entiendo las variables del principio :stuck_out_tongue: se me hace duro jejejej

Acabo de ver un fallo gordo mio tenia un cable suelto en la proto y el pin 3 no hacia buen contacto, ahora me acepta la que uso de master y me dice, registrado!! xD

Me pongo a indagar haber jejeje

Perdonaddddd si os aveis roto la cabeza mirando el porque fallaba :blush:

yo he repasado el codigo una y otra vez... y no encontraba nada!!!

Te ha funcionado el segundo codigo??

Te explico un poco como funciona el codigo sencillo...

El protocolo Wiegand, es muy simple, si entra un dato (5v.) por el Pin 2 (Data0) añade un 0 a Cod_Bin, si el dato entra por el Pin 3 (Data1) añade un 1 a Cod_Bin.

La forma sencilla de hacer esto es con Interrupciones (las dos lineas que ves en el "setup()") que llaman a las dos funciones que tienes justo encima de dicho "setup()". Te recomiendo que te informes un poco del uso de las interrupciones.

La otra "cosa rara" que puedes ver en este codigo es el uso de "bitshift (<<)" es una forma muy sencilla, una vez sabes como funciona, de añadir bits a una cadena, en este caso es la forma más sencilla de ir acumulando los datos que nos entran por Data0 y Data1. Busca informacion de este tambien "bitshift left (<<)".

Y aquí de forma más visual, lo que hacen las interrupciones, y como van almacenando los datos que entran por Data0 y Data1

01 --- Data0 ----> Cod_Bin<<1; // binario: 00000000000000000000000000
02 --- Data1 ----> Cod_Bin<<1; // binario: 00000000000000000000000001
03 --- Data1 ----> Cod_Bin<<1; // binario: 00000000000000000000000011
04 --- Data0 ----> Cod_Bin<<1; // binario: 00000000000000000000000110
05 --- Data1 ----> Cod_Bin<<1; // binario: 00000000000000000000001101
06 --- Data0 ----> Cod_Bin<<1; // binario: 00000000000000000000011010
07 --- Data1 ----> Cod_Bin<<1; // binario: 00000000000000000000110101
08 --- Data0 ----> Cod_Bin<<1; // binario: 00000000000000000001101010


25 --- Data0 ----> Cod_Bin<<1; // binario: 00110101000111001011010010
26 --- Data1 ----> Cod_Bin<<1; // binario: 01101010001110010110100101 // decimal: 27846053

Una Vez tenemos los 26 bits este es el codigo utilizado como identificador, para que resulte más sencillo de ver, recordar o guardar lo represento en decimal.

Espero que de esta forma te resulte más sencillo de entender... :wink:

ha esto le llamo una classe magistral jajaja

Ya entiendo ahora como funcina un RFID Wiegand!!! claro mi problema es que creia que funcionava como el UART/TTL y este no funciona asi necesitando usar los dos data (en el datasheet vi que el uart ponia pin 1 TX pin RX y en el wie data0 y data1 pero yo me dije a mi mismo... "es lo mismo!!" xDDD

Ahora me liare a integrarlo con el maximo de cosas posibles que tengo preparadas (meter en un solo arduino control de persianas, puertas, Lm35's, humos, visualizacion en LCD y Led matrix 8x32, LDR's para saber si es de dia o noche, webserver para control remoto, simulacion de presecia con leds...)

Por ahora todo esto lo tengo todo por separado echo y algunos ya estan juntados, ahora a intentar usar el minimo de arduinos UNO/Mega possibles jejejej

GRACIAS A TODOS!!!

De nada... y animo que para implementar todo eso en un codigo te vas a divertir un rato!!! jajaja...

Los cacharros estos son ideales para puertas, ventanas y persianas. Y nada caros.

También busco un interruptor económico para monitorizar si alguien tensa o corta el alambre de espino de la alambrada.
¿Alguna idea?

Un saludo.