Proyecto final:
Sistema de seguridad con alarma y sensor.
Grupo nº 3. Integrantes: Gonzalo Córdoba, Franco Gaurisso, Nicolás Ojeda, Gabriel Cruz.
Proyecto
Cuando hablamos de un proyecto estamos haciendo referencia a una tarea desarrollada con el propósito de solucionar un problema o una necesidad. En este proyecto se aplica una solución a una necesidad cotidiana. Explicada de una manera simple, brindar seguridad a un hogar u otro espacio.
Sin embargo, partiremos de una base, comentando que la idea surge de las ganas de querer hacer uso de los distintos elementos utilizados, y conocimientos adquiridos en el año. Nos referimos a la utilización de microcontroladores, displays LCD, programación de los mismos, sensores, etc. Estos mismos los aplicaremos en un "Sistema de seguridad" que implementa una alarma y un sensor. Como bien se sabe, hoy en día muchas casas cuentan con uno de estos por el simple hecho de querer brindarle seguridad al lugar. En la gran variedad de aplicaciones que se le pueden agregar podemos nombrar algunas como los códigos de seguridad colocados al mismo, con el cual solo aquella persona que sepa tal código, puede activar o desactivar la alarma. Además, se pueden agregar ciertos tiempos que puede demorar la alarma en activarse, luego de ser activado el sistema, etc.
Al
no ser un proyecto a escala, se adaptará cierto ambiente para simular
el lugar a proteger. Luego se le agregarán los distintos
componentes que se desean, ya sea un display LCD, sensor, alarma,
etc. Cada uno de estos será programado o adaptado electrónicamente para que
cumpla sú función en el sistema entero. Por ejemplo, el
display LCD podrá mostrar el código de seguridad. Los
sensores se encargarán de cubrir la zona a proteger, y
finalmente, la alarma sonora, ó en este caso un buzzer, será la
que se activará al haber una penetración no
correspondida en el sistema.
Generalidades:
El sistema de alarma con sensor es un dispositivo capaz de recibir la emisión de radiación infraroja producida por una fuente de calor situada a una distancia inferior a los 6 metros.
La presencia de un cuerpo caliente en movimiento dentro de la zona controlada por el detector, activa una alarma sonora de forma de persuadir al intruso.
Su activación y desactivación se realiza por medio de la escritura de una clave conocida por el usuario.
Instalación:
- No instale la alarma sobre superficies metálicas.
- Coloque el sensor en lugares estratégicos en los cuales pueda caminar el intruso a una altura de 2,4 metros para una cobertura de 12 x 12 metros.
- Coloque el teclado en un lugar accecible para el usuario.
- Coloque la alarma en un sitio en el cual pueda ser escuchada por los habitantes de la propiedad y los vecinos.
- Luego de darle tensión al dispositivo, introduzca la clave para activar la alarma.
- Luego de un tiempo de 20 segundos el sensor pasará a la condición de detección.
- Al detectar la presencia de un cuerpo caliente en la zona cubierta se darán 20 segundos para introducir correctamente la clave, de no hacerlo, sonará la alarma.
Características técnicas:
Imagen del gabinete finalizado con el sensor conectado
Manual para el usuario
Generalidades:
El sistema de alarma con sensor es un dispositivo capaz de recibir la emisión de radiación infraroja producida por una fuente de calor situada a una distancia inferior a los 6 metros.
La presencia de un cuerpo caliente en movimiento dentro de la zona controlada por el detector, activa una alarma sonora de forma de persuadir al intruso.
Su activación y desactivación se realiza por medio de la escritura de una clave conocida por el usuario.
Instalación:
- No instale la alarma sobre superficies metálicas.
- Coloque el sensor en lugares estratégicos en los cuales pueda caminar el intruso a una altura de 2,4 metros para una cobertura de 12 x 12 metros.
- Coloque el teclado en un lugar accecible para el usuario.
- Coloque la alarma en un sitio en el cual pueda ser escuchada por los habitantes de la propiedad y los vecinos.
- Luego de darle tensión al dispositivo, introduzca la clave para activar la alarma.
- Luego de un tiempo de 20 segundos el sensor pasará a la condición de detección.
- Al detectar la presencia de un cuerpo caliente en la zona cubierta se darán 20 segundos para introducir correctamente la clave, de no hacerlo, sonará la alarma.
Características técnicas:
- Tamaño del sensor: 89 x 52 x 39 mm.
- Campo de detección: 12 x 12 metros.
- Angulo de detección horizontal: 90 grados.
- Consumo de corriente: 12mA a 12V.
Para una mayor eficacia guíese por la foto para conocer lugares estrátegicos de instalación de los sensores y el teclado:
Explicación detallada del funcionamiento del programa paso a paso
Luego de haber hecho una breve explicación del fin del proyecto, y haber demostrado un manual básico para el usuario, pasaremos a hacer una explicación más detallada, enfocándonos principalmente en el tema de la programación.
Explicación detallada del funcionamiento del programa paso a paso
Luego de haber hecho una breve explicación del fin del proyecto, y haber demostrado un manual básico para el usuario, pasaremos a hacer una explicación más detallada, enfocándonos principalmente en el tema de la programación.
Al
encender el sistema el LCD nos recibe con un mensaje de bienvenida e
instantáneamente, nos pide que introduzcamos la clave. Debido
a que el programa esta pensado para ser controlado por un usuario que
tenga conocimiento de la clave el programa nos da 3 intentos para
colocar correctamente la misma. De no ser así, significaría
que la persona que está utilizando el aparato no conoce la clave,
entonces automáticamente se enciende la alarma y se bloquea el
sistema. Al suceder esto, el dispositivo queda inutilizable durante
un cierto tiempo, mostrando un mensaje en el LCD que dá aviso de que
el sistema está bloqueado y, a sú vez, la alarma suena. Al pasar el
tiempo estimado el sistema se reestablece y vuelve al punto de inicio
en el cual nos pedía introducir la clave.
En
el caso de que la clave haya sido introducida correctamente el
dispositivo le brinda 20 segundos de demora al usuario para que se
retire del espacio o habitación que esta siendo cubierta por
el sensor. Pasado este tiempo, el sensor comienza a sensar, esperando
detectar un movimiento.
Una
vez que el sensor detecta movimiento en el ambiente se activa un
timer que le da un tiempo de 20 segundos a la persona para que
introduzca la clave de deshabilitación del sistema. Si la
clave fue escrita correctamente antes de que pasen los 20 segundos el
sistema se reinicia y vuelve al punto de comienzo, en donde se queda esperando
que introduzcamos la clave y vuelva a repetirse la secuencia ya
explicada. Pero en el caso de que la clave no haya sido colocada
correctamente dentro de los 20 segundos, automáticamente se
activa la alarma y se bloquea el sistema, quedando inutilizable el
dispositivo y sonando la alarma durante un cierto tiempo hasta que se
reestablece nuevamente y vuelve al punto de inicio. Volviendo a
empezar la secuencia.
Diagrama en bloques de las conexiones.
Este diagrama en bloques muestra como se relacionan entre sí los distinton componentes del sistema de alarma.
// ------------------ Sistema de seguridad con alarma --------------------------
// El sistema cuenta con una clave fija guardada en la memoria eeprom que se
// utiliza para activar y desactivar el sensor y la alarma.
//------------------------------------------------------------------------------
#include "Alarma.h"
#include "KBD.C"
#include "flex_lcd.c"
#include <stdlib.h>
// Declaración de clave en E2PROM ----------------------------------------------
#rom 0x2100={'7','4','5','2'}
#DEFINE T_CLAVE 76 // Tiempo para ingresar clave. 20 segundos = 76
#DEFINE T_SONANDO 171 // Tiempo en que suena la alarma. 45 segundos = 171
// Variables Globales ----------------------------------------------------------
int contador = 0;
int contador2 = 0;
int intentos = 0;
char tecla;
// Interrupción por Timer------------------------------------------------------------------------
#int_TIMER1
void TIMER1_isr(void)
{
contador++; // Variables que simulan la cuenta de segundos para que la persona
contador2++; // introduzca la clave correcta.
if(contador==T_CLAVE||intentos==3){ // Marca el tope de segundos o intentos.
printf(lcd_putc,"\f****SISTEMA****"); // Muestra un mensaje en el display LCD.
lcd_gotoxy(1,2);
printf(lcd_putc,"\***BLOQUEADO***");
output_toggle(ALARMA); // Activa la alarma.
}
if(contador2>=T_SONANDO){ // Marca el tope de tiempo que suena la alarma.
output_low(ALARMA); // Apaga la misma y reinicia el sistema.
contador=0;
contador2=0;
intentos=0;
printf(lcd_putc,"\fReinicia...");
delay_ms(500);
printf(lcd_putc,"\fIntroduzca clave");
disable_interrupts(INT_TIMER1);
}
}
// Menu de configuración y punto de inicio ---------------------------------------------
void config()
{
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_CLOCK_DIV_2);
setup_spi(SPI_SS_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
disable_interrupts(INT_TIMER1);
setup_oscillator(OSC_8MHZ);
kbd_init();
lcd_init();
output_low(ALARMA);
output_high(BACKLIGHT);
}
// Función que compara los digitos oprimidos con la clave correcta ----------------------
int1 convalidacion_clave(){
int1 convalidacion; // Declara las variables a usar en la función.
char data[4];
char clave[4];
int posicion;
posicion=0;
printf(lcd_putc,"\fIntroduzca clave");
while(posicion<=3){
tecla = kbd_getc(); // Instrucción que obtiene la tecla presionada.
if(tecla!=0){
data[posicion]=tecla; // La guarda en una variable para luego compararla.
posicion++;
lcd_gotoxy(posicion,2);
lcd_putc('*');
delay_ms(200);
}
}
for(posicion=0;posicion<=3;posicion++){ // Compara las teclas oprimidas con la clave
clave[posicion]=read_eeprom(posicion); // guardada en la eeprom.
}
if((data[0]==clave[0])&&(data[1]==clave[1])&&(data[2]==clave[2])&&(data[3]==clave[3])){
convalidacion=1; // Si la clave fue correcta, retorna un valor
return (convalidacion); // positivo.
}
else{
convalidacion=0; // Si no lo fue, retorna un valor negativo.
return (convalidacion);
}
}
// Programa principal ----------------------------------------------------------
void main(){
config(); // Llama al menu de configuración.
enable_interrupts(GLOBAL);
printf(lcd_putc,"\fBienvenido");
delay_ms(1000);
while(TRUE){
if(convalidacion_clave()){ // Si la función "convalidacion_clave" retornó
printf(lcd_putc,"\fCorrecto"); // un valor positivo, ejecuta esta serie
delay_ms(1000); // 20seg de pasos.
printf(lcd_putc,"\fSensando...");
output_low(DEBUG);
while(input(SENSOR)); // Comienza a sensar, hasta que detecte
output_high(DEBUG); // una interrupción y pida la clave.
enable_interrupts(INT_TIMER1);
if(convalidacion_clave()){
contador=0;
intentos=0;
disable_interrupts(INT_TIMER1);
printf(lcd_putc,"\fReinicia...");
delay_ms(500);
}
}
else{ // Si la función "convalidacion_clave" retornó
intentos++; // un valor negativo, ejecuta esta serie de
printf(lcd_putc,"\fIncorrecta"); // pasos hasta que llegue a los 3 intentos.
delay_ms(500);
if(intentos==3){
enable_interrupts(INT_TIMER1);
}
}
}
}
Header del programa:
#include <16F887.h>
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES INTRC_IO //Internal RC Osc, no CLKOUT
#FUSES NOPUT //No Power Up Timer
#FUSES NOMCLR //Master Clear pin used for I/O
#FUSES NOPROTECT //Code not protected from reading
#FUSES NOCPD //No EE protection
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOIESO //Internal External Switch Over mode disabled
#FUSES NOFCMEN //Fail-safe clock monitor disabled
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOWRT //Program memory not write protected
#FUSES BORV40 //Brownout reset at 4.0V
#use delay(clock=8000000)
#DEFINE ALARMA PIN_A0
#DEFINE BACKLIGHT PIN_A1
#DEFINE DEBUG PIN_A2
#DEFINE SENSOR PIN_B0
Librería del Display LCD:
flex_lcd.c
Pagina para descargar la librería:
http://picmania.garcia-cuervo.net/picc.php#FLEXLCD
// Librería del display LCD: "flex_lcd.c"
// Define los pines en los cuales está conectado el display LCD.
#define LCD_DB4 PIN_C4
#define LCD_DB5 PIN_C5
#define LCD_DB6 PIN_C6
#define LCD_DB7 PIN_C7
//
#define LCD_RS PIN_C0
#define LCD_RW PIN_C1
#define LCD_E PIN_C2
#define USE_LCD_RW 1
//========================================
#define lcd_type 2 // Marca que el LCD es de 2 lineas.
#define lcd_line_two 0x40 // Posición que marca la segunda linea del LCD.
int8 const LCD_INIT_STRING[4] =
{
0x20 | (lcd_type << 2), // Func set: 4-bit, 2 lines, 5x8 dots
0xc, // Enciende display
1, // Limpia el display
6 // Incrementa el cursor
};
//-------------------------------------
void lcd_send_nibble(int8 nibble)
{
// Note: !! converts an integer expression
// to a boolean (1 or 0).
output_bit(LCD_DB4, !!(nibble & 1));
output_bit(LCD_DB5, !!(nibble & 2));
output_bit(LCD_DB6, !!(nibble & 4));
output_bit(LCD_DB7, !!(nibble & 8));
delay_cycles(1);
output_high(LCD_E);
delay_us(2);
output_low(LCD_E);
}
//-----------------------------------
// Sub-rutina llamada a través de "lcd_read_byte()".
// El pin R/W se pone en 1 cuando se llama esta sub-rutina
#ifdef USE_LCD_RW
int8 lcd_read_nibble(void)
{
int8 retval;
// Crea variables de bit para que podamos setear facilmente bits individuales.
#bit retval_0 = retval.0
#bit retval_1 = retval.1
#bit retval_2 = retval.2
#bit retval_3 = retval.3
retval = 0;
output_high(LCD_E);
delay_cycles(1);
retval_0 = input(LCD_DB4);
retval_1 = input(LCD_DB5);
retval_2 = input(LCD_DB6);
retval_3 = input(LCD_DB7);
output_low(LCD_E);
return(retval);
}
#endif
//---------------------------------------
// Lee un byte del LCD y lo retorna.
#ifdef USE_LCD_RW
int8 lcd_read_byte(void)
{
int8 low;
int8 high;
output_high(LCD_RW);
delay_cycles(1);
high = lcd_read_nibble();
low = lcd_read_nibble();
return( (high<<4) | low);
}
#endif
//----------------------------------------
// Envía un byte al LCD.
void lcd_send_byte(int8 address, int8 n)
{
output_low(LCD_RS);
#ifdef USE_LCD_RW
while(bit_test(lcd_read_byte(),7)) ;
#else
delay_us(60);
#endif
if(address)
output_high(LCD_RS);
else
output_low(LCD_RS);
delay_cycles(1);
#ifdef USE_LCD_RW
output_low(LCD_RW);
delay_cycles(1);
#endif
output_low(LCD_E);
lcd_send_nibble(n >> 4);
lcd_send_nibble(n & 0xf);
}
// Función que configura el inicio del display LCD ----------------------------
void lcd_init(void)
{
int8 i;
output_low(LCD_RS);
#ifdef USE_LCD_RW
output_low(LCD_RW);
#endif
output_low(LCD_E);
delay_ms(15);
for(i=0 ;i < 3; i++)
{
lcd_send_nibble(0x03);
delay_ms(5);
}
lcd_send_nibble(0x02);
for(i=0; i < sizeof(LCD_INIT_STRING); i++)
{
lcd_send_byte(0, LCD_INIT_STRING[i]);
// Si la señal R/W no es usada, el bit ocupado no puede ser poleado. Uno de los comandos de
// iniciación tarda más del delay estipulado de 60us, por lo tanto colocamos un delay de 5ms.
#ifndef USE_LCD_RW
delay_ms(5);
#endif
}
}
// Función que nos lleva a la posición en la que deseamos escribir ----------------------------
void lcd_gotoxy(int8 x, int8 y)
{
int8 address;
if(y != 1)
address = lcd_line_two;
else
address=0;
address += x-1;
lcd_send_byte(0, 0x80 | address);
}
// Función hecha para escribir un mensaje en el LCD -----------------------------
void lcd_putc(char c)
{
switch(c)
{
case '\f':
lcd_send_byte(0,1);
delay_ms(2);
break;
case '\n':
lcd_gotoxy(1,2);
break;
case '\b':
lcd_send_byte(0,0x10);
break;
default:
lcd_send_byte(1,c);
break;
}
}
//------------------------------
#ifdef USE_LCD_RW
char lcd_getc(int8 x, int8 y)
{
char value;
lcd_gotoxy(x,y);
// Espera mientras el flag ocupado esta en posición baja.
while(bit_test(lcd_read_byte(),7));
output_high(LCD_RS);
value = lcd_read_byte();
output_low(lcd_RS);
return(value);
}
#endif
void lcd_setcursor_vb(short visible, short blink) {
lcd_send_byte(0, 0xC|(visible<<1)|blink);
}
Librería del teclado matricial de 3x4:
La librería del teclado que se utilizó es la que viene incluida con el CCS.
Esta libreria cuenta con una serie de funciones que toman el dato que el teclado envía al oprimir una tecla. Esto lo hace a través de un escaneo que realiza cada cierta cantidad de segundos (que nosotros podemos configurar) en sus 3 columnas (conectadas a RD5, RD6 y RD7) por un lado, y en sus 4 filas (conectadas a RD1, RD2, RD3 y RD4) por otro. Luego por una serie de define que nombra, nosotros en nuestro programa principal podemos llamarlos para lograr imprimir el dato obtenido en el display LCD. Para utilizarlo se deben connectar reciscentencias de pull-up en cada pin o utilizar la resistencias de pull-up internas del puerto del microcontrolador si este las posee.
KBD.C
// Descomentar la siguiente linea para usar el teclado en el puerto B.
//#define use_portb_kbd TRUE
// Asegúrese que el puerto usado tenga resistores de pull-up (ó el LCD).
#if defined(__PCH__)
#if defined use_portb_kbd
#byte kbd = 0xF81 // Coloca la estructura entera.
#else
#byte kbd = 0xF83 // Coloca la estructura entera.
#endif
#else
#if defined use_portb_kbd
#byte kbd = 6 // Al puerto B (dirección 6)
#else
#byte kbd = 8 // Al puerto D (dirección 8)
#endif
#endif
#if defined use_portb_kbd
#define set_tris_kbd(x) set_tris_b(x)
#else
#define set_tris_kbd(x) set_tris_d(x)
#endif
// Conexión del teclado: (por ejemplo la columna 0 es B2)
// Bx:
#ifdef blue_keypad ///////////////////////////////////// Pines para el teclado azul.
#define COL0 (1 << 2)
#define COL1 (1 << 3)
#define COL2 (1 << 6)
#define ROW0 (1 << 4)
#define ROW1 (1 << 7)
#define ROW2 (1 << 1)
#define ROW3 (1 << 5)
#else ////////////////////////////////////////////////// Pines para el teclado negro.
#define COL0 (1 << 5)
#define COL1 (1 << 6)
#define COL2 (1 << 7)
#define ROW0 (1 << 1)
#define ROW1 (1 << 2)
#define ROW2 (1 << 3)
#define ROW3 (1 << 4)
#endif
#define ALL_ROWS (ROW0|ROW1|ROW2|ROW3)
#define ALL_PINS (ALL_ROWS|COL0|COL1|COL2)
// Diseño del teclado:
char const KEYS[4][3] = {{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}};
#define KBD_DEBOUNCE_FACTOR 33 // Setear este número hacia aprox n/333
// donde n es el número de veces que esperás para llamar
// kbd_getc en cada segundo
// Función de inicio del teclado ----------------------------------------------------
void kbd_init() {
}
// Función para la obtencion de la tecla pulsada ------------------------------
char kbd_getc( ) {
static BYTE kbd_call_count;
static int1 kbd_down;
static char last_key;
static BYTE col;
BYTE kchar;
BYTE row;
kchar='\0';
if(++kbd_call_count>KBD_DEBOUNCE_FACTOR) {
switch (col) {
case 0 : set_tris_kbd(ALL_PINS&~COL0);
kbd=~COL0&ALL_PINS;
break;
case 1 : set_tris_kbd(ALL_PINS&~COL1);
kbd=~COL1&ALL_PINS;
break;
case 2 : set_tris_kbd(ALL_PINS&~COL2);
kbd=~COL2&ALL_PINS;
break;
}
if(kbd_down) {
if((kbd & (ALL_ROWS))==(ALL_ROWS)) {
kbd_down=FALSE;
kchar=last_key;
last_key='\0';
}
} else {
if((kbd & (ALL_ROWS))!=(ALL_ROWS)) {
if((kbd & ROW0)==0)
row=0;
else if((kbd & ROW1)==0)
row=1;
else if((kbd & ROW2)==0)
row=2;
else if((kbd & ROW3)==0)
row=3;
last_key =KEYS[row][col];
kbd_down = TRUE;
} else {
++col;
if(col==3)
col=0;
}
}
kbd_call_count=0;
}
set_tris_kbd(ALL_PINS);
return(kchar);
}
Detalles técnicos
Sensor
Foto del circuito interno del sensor
| Cobertura a una altura de 2.4m: | 12m X 12m |
| Voltaje de operación: | 9 a 16V regulados |
| Consumo de corriente: | 12mA a 12V |
| Contacto de Alarma: | 50mA, 24V, N.C |
| Tiempo de Alarma: | Mínimo: 2,2 Segundos |
| Temperatura de operación: | -5 to 50°C (23 a 122°F) |
| Filtrado óptico: | Protección contra luz blanca, Lentes pigmentados |
Microcontrolador PIC16F884
Disposición de los pines
Especificaciones eléctricas
Ambient temperature under bias............................................... -40° to +125°C
Storage temperature ...... ......................................................... -65°C to +150°C
Voltage on VDD with respect to VSS ........................................ -0.3V to +6.5V
Voltage on MCLR with respect to Vss........................................ -0.3V to +13.5V
Voltage on all other pins with respect to VSS ........................... -0.3V to (VDD + 0.3V)
Total power dissipation(1) ........................................................ 800 mW
Maximum current out of VSS pin .............................................. 95 mA
Maximum current into VDD pin.................................................. 95 mA
Input clamp current, IIK (VI < 0 or VI > ...................................... ± 20 mA
Output clamp current, IOK (Vo < 0 or Vo .................................. ± 20 mA
Maximum output current sunk by any I/O................................... 25 mA
Maximum output current sourced by any I/O pin........................ 25 mA
Maximum current sunk by all ports (combined)(2) .................... 90 mA
Maximum current sourced by all ports (combined) ................... 90 mA
Circuito esquemático del sistema de seguridad con alarma y sensor realizado en kicad
Diseño de la placa final realizado en kicad
Descripción de la placa:
La placa esta diseñada de manera que el display lcd de 16x2 y el teclado matricial de 4x3 queden ubicados arriba de la placa de manera que los demás componentes queden debajo de la misma. También cuenta con un conector RJ12 para realizar la programación in-circuit del uC, cuenta con un preset para controlar el contraste del lcd, un led de debug (para realizar pruebas previas de funcionamiento) y un buzzer que simula la alarma y un conector molex para conectar el sensor a la misma.
Esta placa se alimenta con 5v d.c. regulados.
Placa lado cobre para planchar
Lista de materiales:
| cantidad | materiales |
| 1 | PIC16F887 |
| 1 | LCD 16x2 con backlight |
| 1 | teclado matricial 4x3 |
| 1 | conector RJ12 |
| 1 | molex |
| 1 | borenera de 2 |
| 1 | buzzer con oscilador |
| 1 | tira de pines hembra para placa |
| 1 | led 3mm |
| 2 | transistores BC548 |
| 2 | capacitores de 100nF |
| 1 | preset de 10k |
| 1 | resistencia de 4k7 |
| 1 | resistencia de 82 ohm |
| 1 | resistencia de 390 ohm |
| 9 | resistencias de 10k |
Fuente de alimentacion
La fuente de alimentación entrega 5 y 12 volts de corriente continua, con una corriente máxima de 300mA dados por el transformador de 12v. Para regular la tensión de salida se ultilizaron dos reguladores de tesión LM78XX.
Circuito esquemático de la fuente de alimentación.
Diseño de la placa final realizado en kicad
Placa lado cobre para planchar
Lista de matriales de la fuente:
| |||||||||||||||||||
Circuito en Proteus:
Explicación del Proteus:
Para
la simulación de las distintas pruebas que hemos ido
realizando durante la programación del proyecto hemos
utilizado el Proteus. Con él podemos verificar prácticamente
el funcionamiento del programa.
En
el circuito se puede observar los distintos componentes: PIC16F887,
display LCD, pulsadores, resistencias y finalmente, leds. Cada uno de
estos tiene su función especifica. El PIC16F887 es el
microcontrolador al cual le cargamos el programa realizado y el que
se encarga de enviar los datos al LCD, prender la alarma y/o el
sensor en su debido momento, etc. El display LCD, conectado al puerto
C del uC, es el que se encarga de mostrar los mensajes enviados por
el PIC, tales como “Introduzca clave”, “Sistema Bloqueado”,
etc. Los pulsadores del puerto D simulan al teclado matricial de 3x4,
y los mismos están conectados con sus respectivas resistencias
de pull-up. Por otro lado encontramos un pulsador en el pin RB0 que
fue colocado para simular al sensor. Y finalmente, tenemos conectado
en el pin RA0 un led que reemplaza al buzzer en el circuito real y
junto a él, en el pin RA1, se encuentro otro led utilizado
para simulación. Este mismo se enciende mientras que el sensor
esta esperando detectar un movimiento, una vez que lo hace, este led
se apaga.
