Archivo+2011

=Bienvenidos al Proyecto Alarma {$team} home page.=

Facundo Ruiz y Tomas Ode Samuel Mendoza y Diego Hernandez Matías Crespo y Federico Rodriguez || En el link esta el informe junto con todos los programas. Aclaración: Faltan todas las imágenes del trabajo practico, en el link esta todo completo. [] media type="file" key="/MOV05931.3GP" width="300" height="300"
 * Grupos :

Proyecto Alarma escolar

Integrantes: Ode Williams, Tomás Ruiz, Facundo Rodríguez, Federico Hernández, Diego Crespo, Matías Mendoza, Samuel En el siguiente informe se describe el proyecto final del Sistema de Alarma Escolar destinado a la protección y seguridad de nuestro laboratorio e instrumental electrónico. A continuación detallaremos lo que creímos más conveniente para el proyecto.
 * INTRODUCCION **
 * Diseño del Hardware: **

La alarma desempeña las siguientes funciones:

•Monitorea el estado de los sensores de seguridad.

•Proporciona la interfaz necesaria para la programación de datos de usuario.

•Suministra la energía requerida para el funcionamiento de los distintos sensores conectados a él. El sistema está compuesto por varios módulos de igual jerarquía, los cuales están constantemente monitoreando el estado en el que se encuentran los sensores de seguridad. En el caso de que se presente la activación de un sensor, se emite un mensaje que es recibido por la central y retransmitido en forma de alerta sonora a través de una sirena o chicharra.
 * Sistema de Alarma: **


 * Diagrama en bloques del Sistema de Alarma: **

Este diagrama de bloques nos muestra brevemente todas las partes que el sistema de alarma tendrá en la finalización del proyecto. Para lograr este objetivo utilizaremos el micro controlador PIC16F877a, que dispone de los requerimientos necesarios para lograr con éxito el proyecto.
 * Sistema de control programado: **

En este bloque se encuentra el “cerebro” del sistema, sonde se encuentra toda la lógica de control, cuentas de usuario, contraseñas, etc. Todos los demás bloques de programación responden o actúan por medio del sistema de control programado. ** Micro Controlador ** ** : ** El objetivo del micro controlador es controlar todo el sistema, su elección se basa en sus características de memoria, numero de puertos y librerías disponibles para su programación. El primer criterio de selección del micro-controlador fue el número de puertos disponibles, debe brindar soporte al bloque de interfaz con el usuario, soporte a los diferentes sensores y contactores de seguridad. Para lo cual se desarrollo una tabla con el mínimo de pines y puertos requeridos:


 * PERIFERICO || PINES || PUETOS REQUERIDOS ||
 * LCD 16 X 2 || 6(RS, E, D1, D2, D3, D4) || 1(8 BITS) ||
 * TECLADO || 8(4 LINEAS,4 FILAS) || 1(8 BITS) ||
 * SENSORES Y CONTACTORES || 8(DIGITALES) || 1(8 BITS) ||
 * SIRENA || 1 || 1(3BITS) ||
 * SIRENA || 1 || 1(3BITS) ||

El siguiente criterio tomado en cuenta fue la capacidad de memoria RAM, flash y memoria EEPROM que se necesitaría tanto para el alojamiento de instrucciones como para datos en el micro controlador. Debido a que la programación se lo desarrollara en un lenguaje de alto nivel, se tomó en cuenta que se añadirán librerías de control de teclado, LCD y USART

En base a los requisitos optamos por utilizar el micro controlador 16f887 que tiene 40 pines. A continuación veremos la distribución y configuración de las patas del micro.

(10) || Salida del oscilador. Este pin debe conectarse al cristal o resonador. En caso de usar una red RC este pin se puede usar como tren de pulsos o reloj cuya frecuencia es 1/4 de OSC1 || THV(1) || Este pin es el reset del micro controlador, también se usa como entrada o pulso de grabación al momento de programar el dispositivo. || T1CKI(11) || Línea digital de E/S o salida del oscilador del timer 1 o como entrada de reloj del timer 1 || CCP2(12) || Línea digital de E/S o entrada al oscilador del timer 1 o entrada al módulo captura 2/salida comparación 2/ salida del PWM 2 || (14) || E/S digital o entrada de reloj serie síncrona /salida de los módulos SP1 e I2C. || (15) || E/S digital o entrada de datos en modo SPI o I/O datos en modo I2C || RD7/PSP7 (19-22, 27-30) || Las ocho patitas de esta puerta pueden actuar como E/S digitales o como líneas para la transferencia de información en la comunicación de la puerta paralela esclava. Solo están disponibles en los PIC 16F874/7. || (8) || E/S digital o señal de lectura para la puerta paralela esclava o entrada analógica canal 5. || (9) || E/S digital o señal de escritura para la puerta paralela esclava o entrada analógica canal 6. ||
 * ** PIN ** || ** DESCRIPCION ** ||
 * OSC1/CLKIN(9) || Entrada para el oscilador o cristal externo. ||
 * OSC2/CLKOUT
 * MCLR/VPP/
 * RA0/AN0(2) || Puede actuar como línea digital de E/S o como entrada analógica del conversor AD (canal 0) ||
 * RA1/AN1(3) || Similar a RA0/AN0 ||
 * RA2/AN2/VREF-(4) || Puede actuar como línea digital de E/S o como entrada analógica del conversor AD (canal 2) o entrada negativa de voltaje de referencia ||
 * RA3/AN3/VREF+(5) || Puede actuar como línea digital de E/S o como entrada analógica del conversor AD (canal 3) o entrada positiva de voltaje de referencia ||
 * RA4/T0CKI (6) || Línea digital de E/S o entrada del reloj del timer 0. Salida con colector abierto ||
 * RA5/SS#/AN4(7) || Línea digital de E/S, entrada analógica o selección como esclavo de la puerta serie síncrona. ||
 * RB0/INT(21) || Puerto B pin 0, bidireccional. Este pin puede ser la entrada para solicitar una interrupción. ||
 * RB1(22) || Puerto B pin 1, bidireccional. ||
 * RB2(23) || Puerto B pin 2, bidireccional. ||
 * RB3/PGM(24) || Puerto B pin 3, bidireccional o entrada del voltaje bajo para programación ||
 * RB4(25) || Puerto B pin 4, bidireccional. Puede programarse como petición de interrupción cuando el pin cambia de estado. ||
 * RB5(26) || Puerto B pin 5, bidireccional. Puede programarse como petición de interrupción cuando el pin cambia de estado. ||
 * RB6/PGC(27) || Puerto B pin 6, bidireccional. Puede programarse como petición de interrupción cuando el pin cambia de estado. En la programación serie recibe las señales de reloj. ||
 * RB7/PGD(28) || Puerto B pin 7, bidireccional. Puede programarse como petición de interrupción cuando el pin cambia de estado. En la programación serie actúa como entrada de datos ||
 * RC0/T1OSO/
 * RC1/T1OSI/
 * RC2/CCP1(13) || E/S digital. También puede actuar como entrada captura 1,/salida comparación 1/ salida de PWM 1 ||
 * RC3/SCK/SCL
 * RC4/SDI/SDA
 * RC5/SDO(16) || E/S digital o salida digital en modo SPI ||
 * RC6/TX/CK(17) || E/S digital o patita de transmisión de USART asíncrono o como reloj del síncrono ||
 * RC7/RX/DT(18) || E/S digital o receptor del USART asíncrono o como datos en el síncrono ||
 * RD0/PSP0-
 * RE0/RD#/AN5
 * RE1/WR#/AN6
 * RE2/CS#/AN7 || E/S digital o señal de activación/desactivación de la puerta paralela esclava o entrada analógica canal 7. ||
 * VSS(8,19) || Tierra. ||
 * VDD(20,32) || Fuente (5V). ||

La siguiente placa se utiliza para colocar el pic 16f877a y obtener un fácil acceso a cada uno de sus pines. Consta con 14 borneras (7 de 2 y 7 de 3), un pulsador para el máster clear, y un cristal de 4Mz

Los módulos LCD (Liquid Crystal Display), son compactos y necesitan muy pocos componentes externos para un funcionamiento correcto. La función principal de estos módulos es la de visualizar los caracteres deseados por el usuario. En la pantalla se pueden visualizar hasta 40 caracteres en sus dos líneas (20 por línea), cada carácter se visualiza en una matriz de 5 x 8 puntos. Este dispositivo dispone de 16 pines de los cuales 2 son para alimentación, 1 para ajuste de contraste, 3 para control los restantes 8 para transmisión/recepción de datos.
 * DISPLAY LCD 16 x 2: **

El controlador permite enviar datos utilizando 4 o 8 de los pines de datos y conectar a tierra uno de los pines de control (específicamente R/W), lo que permite ahorrar el número de pines del micro controlador.


 * CARACTERISTICAS: **
 * NUMERO DE PINES || SIMBOLO || FUNCION ||
 * 1 || Vss || GND ||
 * 2 || Vdd || +3V O +5V ||
 * 3 || Vo || Ajuste de contraste ||
 * 4 || Rs || Seleccionar registro ||
 * 5 || R/W || Señal de leer o escribir ||
 * 6 || E || Habilitar señal ||
 * 7 || DB0 || Bus de datos ||
 * 8 || DB1 || Bus de datos ||
 * 9 || DB2 || Bus de datos ||
 * 10 || DB3 || Bus de datos ||
 * 11 || DB4 || Bus de datos ||
 * 12 || DB5 || Bus de datos ||
 * 13 || DB6 || Bus de datos ||
 * 14 || DB7 || Bus de datos ||
 * 15 || A/Vee || + 4.2 v ánodo de back light ||
 * 16 || k || Cátodo ||

Nuestro programa se divide en declaraciones, funciones y función main.
 * Programación: **

- Char __Pass__ [13]: Buffer de memoria para guardar la contraseña tecleada. - Short __Cont__: Cuenta cuantos caracteres vamos escribiendo. - Char __Rompass__ [13]: Donde guardamos la contraseña de la alarma. - Short __i__: es utilizada exclusivamente para hacer valer un bucle. - Char __kp__: es donde guardamos el valor que devuelve la función de lectura del teclado, la capturamos, y luego la analizamos. - Const Char __Keys[16]__: Es un Array donde le damos un valor a cada botón del teclado, que en este caso es de 4x4 (0, 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , . , # , A , B , C , D).
 * __Declaraciones:__**

- __Bienvenido__: Saluda al usuario a través del display, en el arranque del programa. - __Reposo__: Es un estado de stand by del programa, espera a que una tecla sea presionada, para preguntar si se desea pasar al estado “Alarmante”. - __Alarmante__: Este estado es el que se encarga de sensar todas las zonas protegidas. Si se activa la zona 1, llamará a la función “PedirPass”. Si se activa cualquier otra zona, activará la sirena o el dispositivo de aviso, y luego llamara a la función “PedirPass”, si esta le devuelve un valor distinto de 0, cambiara al estado de Reposo. - __PedirPass__: Utiliza como guía, la función “Intpass” para pedir la contraseña. Si “Intpass“le devuelve un valor verdadero (TRUE), se apaga la sirena y devuelve un valor distinto de 0. - __Intpass:__Pide introducir la contraseña desde el display, leyendo el teclado y compara si pass = contra. Al leer el teclado, utiliza el valor de la tecla (1 a 16) para implementarlo como índice a la hora de leer el array “Const Char Keys [16]” para extraer el código ASCII correspondiente de la tecla presionada. Si el valor en ASCII coincide con algún valor del 0 al 9, Agrega los caracteres tecleados, que luego serán guardados en la variable Pass. De ser un valor “#“o “*” se realizará una acción determinada para cada tecla. (# =Borrar todo (borra todos los caracteres); “*”= Entrar/Comparar (Compara la contraseña marcada con la guardada anteriormente. (pass = contra?).)
 * __Funciones:__**

En esta función especificamos los valores utilizados en los registros **adcon0, adcon1**, **TRISB, TRISC** y **TRISD.** Inicia el programa llamando a la función **Bienvenido**, luego pasa al estado de **Reposo**, el cual espera una a que el teclado sea pulsado para luego preguntar si se desea pasar al estado alarmante. Cuando un sensor es activado (depende en que zona esté), el programa pedirá la password o hará sonar la sirena. De haber una comparación exitosa entre la clave tecleada y la guardada, devuelve por el lcd **“Password ok”**. De haber una comparación errónea, devuelve por el lcd **“Error!! Password**
 * __Función Main:__**
 * Incorrecta!!”.**

Nuestro programa también utiliza librerías, ya incluidas en el MikroC (programa utilizado). Se utiliza una librería llamada **Keypad library** y otra llamada **Lcd (4-bit interface) library.**


 * __Keypad:__** Es una librería con rutinas que se pueden utilizar también en teclados de 4x1, 4x2 4x3 y 4x4.

-Keypad_init: Inicializa el puerto que va a trabajar con el teclado. Esta función debe ser llamada antes de utilizar las demás rutinas. -Keypad_read: Revisa si alguna tecla esta presionada. Esta función devuelve un valor del 1 al 16, dependiendo de la tecla presionada. O un 0 si no hay teclas presionadas. -Keypad_released: Ésta función espera a que la tecla presionada sea liberada. Cuando esto sucede, la función devuelve un valor del 1 al 16 dependiendo de la tecla presionada.
 * __Sus rutinas son:__**
 * o Ejemplo: Keypad_Init(&PORTB);
 * o Ejemplo: kp = keypad_read ;
 * o Ejemplo: kp = Keypad_released;


 * Lcd (4-bit interface):** Es una librería para comunicación con LCDs a través de una interfaz de 4 bits.

__-Lcd_config:__ Inicializa el LCD con el puerto y los pines que el usuario especifique: sus parámetros son RS, EN, WR, D7….D4. Es necesario una combinación de valores entre el 0 al 7.
 * __Sus rutinas son:__**
 * o __Ejemplo:__ Lcd_config(&PORTD, 0, 1, 7, 5, 4, 3, 2);

__-Lcd_init:__ Inicializa el LCD con el puerto que se especifique, con una configuración de pines predeterminada:
 * § D7 = port.7
 * § D6 = port.6
 * § D5 = port.5
 * § D4 = port.4
 * § E = port.3
 * § RS = port.2
 * § RW = port.0
 * o __Ejemplo:__ Lcd_init(&PORTB);

__-Lcd_out:__ Imprime un texto en el LCD en una línea y columna especificada (parámetros fila y columna). Requiere inicializar el puerto con rutina lcd_config o Lcd_init.
 * o __Ejemplo:__ Lcd_out(1, 3, “hola!”);

__-Lcd_out_cp:__ Imprime un texto en el LCD en la posición actual del puntero. Requiere inicializar el puerto con rutina lcd_config o Lcd_init.
 * o __Ejemplo:__ Lcd_out_cp(“Aquí!”);

__-Lcd_chr:__ Imprime un carácter en el LCD en la fila y columna especificada (parámetros fila y columna). Requiere inicializar el puerto con rutina lcd_config o Lcd_init.
 * o __Ejemplo:__ Lcd_chr(2, 3, ‘i’);

__-Lcd_chr_cp:__ Imprime un carácter en el LCD en la posición actual del puntero. Requiere inicializar el puerto con rutina lcd_config o Lcd_init.
 * o __Ejemplo:__ Lcd_chr_cp (‘e’);

__-Lcd_cmd:__ Envía un comando al LCD. Debajo se encuentra la lista de comandos.
 * o __Ejemplo:__ Lcd_cmd(Lcd_clear);


 * __A continuación la lista de comandos disponibles (en ingles):__**


 * **LCD Command** || **Purpose** ||
 * LCD_FIRST_ROW || Move cursor to 1st row ||
 * LCD_SECOND_ROW || Move cursor to 2nd row ||
 * LCD_THIRD_ROW || Move cursor to 3rd row ||
 * LCD_FOURTH_ROW || Move cursor to 4th row ||
 * LCD_CLEAR || Clear display ||
 * LCD_RETURN_HOME || Return cursor to home position, returns a shifted display to original position. Display data RAM is unaffected. ||
 * LCD_CURSOR_OFF || Turn off cursor ||
 * LCD_UNDERLINE_ON || Underline cursor on ||
 * LCD_BLINK_CURSOR_ON || Blink cursor on ||
 * LCD_MOVE_CURSOR_LEFT || Move cursor left without changing display data RAM ||
 * LCD_MOVE_CURSOR_RIGHT || Move cursor right without changing display data RAM ||
 * LCD_TURN_ON || Turn LCD display on ||
 * LCD_TURN_OFF || Turn LCD display off ||
 * LCD_SHIFT_LEFT || Shift display left without changing display data RAM ||
 * LCD_SHIFT_RIGHT || Shift display right without changing display data RAM ||

__Los siguientes pasos para el desarrollo del programa serán:__ - Guardar la contraseña en la memoria EEPROM. - Posibilidad de modificar la contraseña a gusto y comodidad del usuario/administrador. - Tener una contraseña con la cual se pueda acceder a un menú de programación donde podamos agregar y/o borrar usuarios cambiar contraseñas, etc. Fácilmente.


 * __ Programa: __**

//####################################################################\\// //## PIC UTILIZADO = F6F877 ##\\// //## B2 = zona2 ##\\// //## B4 = zona4 ##\\// //## ##\\//
 * 1) PROGRAMA SISTEMA DE ALARMA ##\\
 * 1) B1 = zona1 ##\\
 * 1) B3 = zona3 ##\\
 * 1) B5 = sirena ##\\
 * 1) include <16f877a.h>
 * 2) include 
 * 3) fuses XT,NOLVP,NOPROTECT,NOWDT
 * 4) use delay (clock=4M)
 * 1) use delay (clock=4M)


 * 1) define use_portb_lcd TRUE


 * 1) use standard_io (b)
 * 2) use standard_io (d)


 * 1) include 
 * 2) define EAlarmante 2
 * 3) define EReposo 1
 * 4) define EIntpass 3
 * 5) define EAlarma 4
 * 6) define EBienvenido 0
 * 7) define Sirena PIN_C4
 * 8) define Zona1 PIN_C0
 * 9) define Zona2 PIN_C1
 * 10) define Zona3 PIN_C2
 * 11) define Zona4 PIN_C3

char FLAGS = 0; char estado = EBienvenido; void Bienvenido (void); void main(void); void Reposo (void); char Alarmante (void); char Intpass (void); int Comparar(void); void Alarma (void); char Segundos = 0; int Intentos = 0; int a = 0; int c = 0; int i = 0; int contra[6] = {1,2,3,4,5,6}; //constante contraseña// //int pass[6];// buffer de memoria para guardar contraseña tecleada. int Cp = 0 ; //cuenta cuantos caracteres vamos escribiendos.//
 * 1) bit Sensar = FLAGS.1

//void main(void)// //{// //setup_adc_ports(NO_ANALOGS);// //setup_adc(ADC_OFF);// //setup_psp(PSP_DISABLED);// //setup_spi(FALSE);// //setup_comparator(NC_NC_NC_NC);// //setup_vref(FALSE);// //lcd_init;// //kbd_init;// //port_b_pullups(TRUE);//

//while (true)// //{ switch (estado)// //{// //case EBienvenido://Cartel de bienvenida Bienvenido; estado = EReposo; break; case EReposo://Reposo// //Reposo;// //estado = EAlarmante;// //break;// //case EAlarmante://alarmante //Alarmante devuelve el siguiente estado, que puede ser Alarma o Intpass.// //estado = Alarmante;// //break;// //case EIntpass://Intpass //Intpass devuelve el siguiente estado, puede ser Alarma o Reposo.// //estado = Intpass;// //break;// //case EAlarma://Alarma Alarma; estado = Intpass; break; } } } void Bienvenido (void) { lcd_putc("\fBienveni\ndo"); delay_ms (1000); lcd_putc("\fAlarma"); }

void Reposo (void) { inicio: lcd_putc("\fModo Esp\nera"); do { c = kbd_getc; } while (c == 0); while (kbd_getc != 0) {continue;} lcd_putc("\fDesea ca\nmbiar"); delay_ms (700); lcd_putc("\fActivar \nalarma?"); delay_ms (700); lcd_putc("\f*Si\n#No"); do { c = kbd_getc; } while (c == 0); while (kbd_getc != 0) {continue;} if (c == 10)//*=10 #=11// //{ lcd_putc("\fAbandonar\n salon");// //delay_ms (700);// //lcd_putc("\f");// //i = 0;// //segundos = 10;// //for (i=0;i<10;i++)// 10 Segundos para salir del salon { printf(lcd_putc,"\fEn \n%usegs",(Segundos)); delay_ms (1000); segundos--;

} return; } else { goto inicio; }

}

char Alarmante (void) {/*estado es el que se encarga de sensar todas las zonas protegidas. */

lcd_putc ("\f"); Sensar = 0; while (Sensar == 0) { //si se desea activar las zonas con un 0 de los sensores, cambiar la comparacion en el if.// //if (input(Zona1) == 1)//si se activa un sensor en la zona1 { //Contador + password// //lcd_putc ("zona1");// //Sensar = 1;// //delay_ms (500);// //return EIntpass;// //}// //else// //{// //if (input(Zona2) || input(Zona3) || input(Zona4) == 1)//si se activa el sensor de Zona2..4 { //Alarma + password// //lcd_putc ("zona234");// //Sensar = 1;// //delay_ms (500);// //return EAlarma;// //}// //}// //}// //}// Devuelve reposo o alarma char Intpass (void) { Cp = 0; lcd_putc("\fIntroduz\nca Pass"); delay_ms (600); lcd_putc ("\f");

while(1) { c = 0; do{ c = kbd_getc; }while(c == 0); while(kbd_getc != 0){ delay_ms (400); continue;}

switch(c) { case 10: //Enter caso *// //Intentos++;// //if(Comparar)// //{ lcd_putc ("\fPassword\n OK");// //delay_ms (700);// //output_low(Sirena);// //return EReposo;// //Intentos = 0;// //}// //else// //{ if(Intentos == 3){return EAlarma;}// //else {return EIntpass;}//

//}// //break;// //case 11:// Borra todo Caso # Cp = 0; lcd_putc("\f"); a = 0; c = 0; for (a = 0; a<6; a++) { pass[a] = 0; }

break; default:

//if(c > 47 && c<58)// //if((c >=0) && (c<=9))// //{// AgregarCaracter; pass[Cp] = c; //Caracteres de contraseña!! ;)// //Cp++;// //lcd_putc ("*");//

//}//

//break;// //}//

//}//

//}//

//void Alarma (void)// //{// //lcd_putc ("\fError");// //delay_ms (2000);// //output_high(Sirena);//

//}//

//int Comparar(void)// //{if (Cp != 0)// //{// //if (Cp != 6) {return 0;}//si la contraseña no tiene 6 caracteres devuelve 0 a=0; for(i=0;i<6;i++) { if( contra[i] != pass[i]) //Comparamos todos los caracteres.// //{//

//return 0;// al primer error devuelve 0

} } return 255; //si es correcta devuelve 255

} else { return 0; } }
 * __ Sensores: __**

Los sensores que se utilizarán para el sistema son:

_sensores de movimiento.

_sensores de abertura puertas y rotura de ventanas.

_sensores de humo. Los sensores estarán agrupados de forma tal, que cada grupo pueda censar una zona determinada. Para que el monitoreo sea eficaz se necesitará una cantidad de 4 zonas. De 3 a 4 sensores por zona (dependiendo de cual zona sea).

El siguiente sensor manda al PIC 16F877 un 1(5Vcc) continuamente, cuando nuestra puerta está cerrada. Al abrir la puerta el sensor manda un 0(0Vcc). Este sensor está compuesto por un relé magnético y una resistencia de 100k en serie. Cuando la puerta está abierta el relé se separa del imán el contacto se abre. Y el punto que se conecta al PIC pasa a tener 5Vcc cuya tensión es la de nuestra fuente de tensión. Al cerrarse la puerta el contacto se cierra y se "envía" 0Vcc por la simple razón que se mide la diferencia en el punto que va al PIC y el punto de tensión.
 * __Sensor de puerta__ **

La finalidad de este sensor es detectar el sonido cuando un vidrio de una ventana se rompe. Este sensor está compuesto por tres etapas principales:
 * __Sensor de rotura de vidrio.__ **
 * Filtro Pasa Altos: este filtro nos ayuda a que a la siguiente etapa solo pasen señales de alta frecuencia, ya que una rotura de vidrio es un sonido agudo.


 * Amplificador: esta etapa está compuesta por un amplificador operacional, y su finalidad es amplificar la señal que nos entrega la etapa anterior y la prepara para la etapa siguiente.

Cabe destacar que este circuito se alimenta con +5Vcc. El sensor que se eligió al principio de este proyecto fue el siguiente:
 * Actuador: en esta etapa se hace activar un opto transistor para que una tensión que le colocaremos al colector de nuestro integrado pase hacia el emisor y sea enviado al PIC 16F877 que controla si el sensor envía un “0” o un “1”
 * __ Sensor de humo __**

Es un circuito Simple, consiste en un LED, cuya corriente es limitada con una resistencia de 1K en serie, que ilumina permanentemente al LDR que se ubica en frente. Este LDR junto con la resistencia de 50K forman un divisor de tensión que dispara al 555 (Cuando el LDR está a oscuras). El nivel de disparo se ajusta con esa resistencia de manera que maneja la sensibilidad del Sistema.

El 555 está configurado como Monoestable, permanece en reposo mientras LDR está iluminado, cuando esta situación cambia, el 555 se dispara, y su salida permanece en estado alto en un tiempo determinado por el capacitor electrolítico y la resistencia de 100K.

La Salida del 555, a través de una resistencia de 1.5K excita al transistor 2N3904 que a su vez permite que la bobina del relé se energice. Cuando el 555 vuelve al estado de reposo, el transistor vuelve a bloquearse y el relé se desactiva. El diodo en paralelo con la bobina del relé esta para evitar que la corriente generada en la desconexión dañe al transistor.

El Relé es de tipo inversor, así que podemos elegir el tipo de alerta deseado en el Borne: Normal Abierto o Normal Cerrado.

Luego, se llego a la decisión de quitar el 555 y cambiarlo por un Operacional (TL741), ya que el 555 mandaba constantemente pulsos al activarse, necesitándose que el pulso sea constante, también debido a que el Relé tiene un funcionamiento mecánico y su uso es limitado y poco preciso, se decidió utilizar un foto acoplador.

El nuevo circuito funciona de la siguiente manera:

El Circuito es alimentado por 12 Volt de entrada, contiene un LED Piloto que marca el encendido del sensor. Contiene un LDR que es iluminado constantemente por un LED, una resistencia variable que controla la sensibilidad del LDR, el cual está conectado al TL741 que compara un valor de Referencia que está dado por el divisor de tensión que está constituido por las resistencias que se ubican en la entrada negativa del mismo. El Operacional está conectado a foto acoplador, que funciona como un interruptor cuando recibe el pulso del Operacional. Internamente el foto acoplador contiene un foto diodo y un foto transistor, lo cual cuando es enviado el pulso al mismo el foto diodo se enciende, excitando al foto transistor y mandando un pulso en corriente que va a la salida del circuito, hacia la central de la alarma (Circuito del PIC).

Cuando el sensor detecta el humo mediante el LED y el LDR, este varía su resistencia y forma un divisor de tensión con la resistencia variable que provoca que el Operacional compare ese valor con el de Referencia, que debe ser superado para lograr enviar el pulso al foto acoplador.

En este circuito también puede ser utilizado un Foto Diodo y un Foto Transistor en vez de un LED y un LDR.

Para lograr la detección de personas usaremos un sensor de movimiento, tipo PIR (Pyroelectric infrared sensor). Que cuenta con la capacidad de detectar la energía calórica (infrarroja) que emiten los cuerpos. Los sensores piroeléctricos son construidos con un material cristalino que produce electricidad cuando se expone al calor en forma de radiación infrarroja, esta corriente es producida por un transistor FET muy sensible, ya incluido en el sensor. Nuestro sensor consta del sensor PIR que puede ser alimentado con tenciones desde los 5v hasta 15v, un amplificador operacional (lm 741) que lo utilizamos como una etapa de preamplificación y un filtro pasa bajos.
 * __ Sensor de movimiento __**


 * Diagrama eléctrico:**


 * Circuito en PCB:**


 * Especificaciones y circuito equivalente del PIR.**

Como se muestra en el circuito equivalente del PIR, el sensor es básicamente un transistor FET en modo drenador común, utilizamos la resistencia de 47KΩ para polarizar el transistor. Que entrega una leve señal senoidal de apenas 3mV, montada sobre una continua de 1v CC. ES el divisor resistivo (preset de 10kΩ y resistencia de 680Ω) el que baja el nivel de continua hasta un valor aproximado a 0V, ya que el divisor resistivo es alimentado por la tensión negativa (-12V). La etapa de preamplificación se encarga de aumentar levemente la tensión que nos entrega en PIR. El lm741 está polarizado como un amplificador sumador inversor, de ganancia 11 (G=r3/r2 +1). Y por último la etapa de filtrado que está compuesta por la resistencia de 3.3kΩ y el capacitor de 1uF. La función de esta etapa (filtro pasa bajos) es filtrar todas aquellas molestias eléctricas, ruidos en la línea y cualquier interferencia de baja frecuencia que pueda afectar el funcionamiento del sensor.
 * Principio de funcionamiento:**

Una vez polarizado el sensor PIR. Y si existe la detección del paso de una persona, el sensor genera una señal de salida de la siguiente forma:

Cálculos del filtro pasa bajos: F=1/2Πrc F=50hz C=1uf R=1/2πFC R=3,3kΩ Calculo del divisor resistivo: R1= 10KΩ - VR2= -1V IR.R1+ IR.R2=-12V => IR.10K-1V =-12 => IR= -11/10K = -1.1mA R2= -1V/-1.1mA = 909Ω*
 * Usaremos una resistencia de 680Ω porque de esta forma es más fácil para el preset generar la tensión deseada (-1v), que necesitamos en la pata inversora del amplificador operacional.


 * __Teclado:__**

El teclado que decidimos construir es de 4x3, contiene 12 interruptores, 7 resistencias y 2 borneras de 3 y una de 2 bloques.

El objetivo del teclado es permitir que se coloque el password que pide el programa, para la activación y desactivación del sistema de alarma.

(Sensor de humo) (Teclado) (Programa)
 * __Observaciones:__**
 * Debido a la falta de organización en el proyecto y la falta de comunicación con la comisión, provoco la falta de tiempo para realizar varias de las tareas en cada una de las metas que se generaron en el grupo de trabajo.
 * Debido al material que se dio, como el foto diodo y el foto transistor, no funcionaban se debió usar un LED y un LDR, pero la idea principal fue el material dado.
 * El Circuito Impreso del mismo debe ser modificado, ya que contiene agujeros demás, que el mismo programa utilizado para crear el impreso colocaba para los interruptores.
 * Los Interruptores deben ser cambiados ya que su funcionamiento no es óptimo ni preciso.
 * Tuvimos inconvenientes con el lenguaje de programación, ya que decidimos programar el C. Nunca habíamos visto este lenguaje y nos demoramos en perfeccionar los conocimientos acerca del mismo.
 * Hubieron problemas con el programador del pic, ya que el pudimos conseguir, no lograba grabar bien en el utilizado.
 * En una instancia decidimos cambiar al 16f628 por el hecho de que no podíamos grabar el 16f877. Esto presentaba problemas ya que los puertos no nos alcanzaban para todas las funciones que necesitábamos.
 * Nos notificaron a última hora que nuestro problema se debía al programador que utilizábamos. Y nos ofrecieron prestarnos uno que funcionaba.

(Sensor de rotura de vidrios)
 * Primero quisimos hacer andar el circuito en solo una placa, pero como no pudimos repartimos estas tres etapas en tres placas distintas. Para detectar y solucionar los problemas más fácilmente.

(Sensor de puertas) (Sensor de movimiento)
 * Cuando pasamos el circuito por primera vez a placa, realizamos el circuito mal ya que nos faltaba un punto el cual iba conectado al PIC.
 * Este circuito fue probado acercándole y alejándole un imán al contacto y anduvo perfectamente según queríamos.
 * El sensor no era nuevo y debíamos buscar la correspondiente hoja de datos y hacer distintas pruebas para ver si funcionaba correctamente.

Páginas de este equipo:
include component="pagelist" homeAtTop="true"