Proyecto
Alarma "SOFTWARE AND HARDWARE"
Alexander
Rodriguez cod 80006851
Richard Alain Heredia Puello
cod:73006628
Universidad Nacional Abierta y A Distancia
Bogotá, Colombia
RESUMEN:
Continuando con
el desarrollo de las guías colaborativas, se ingresa al espacio de parámetros,
proyección y producción primaria del proyecto de una alarma para el hogar.
Como primer paso
queremos exponer el código desarrollado para la manipulación de esa
inteligencia artificial mediante un pic 16f877a, el cual conectado a un sistema
eléctrico y mecánico con respuesta en base de datos y los parámetros dados en
programación assembler, escritos en software Mplab, darán un vistazo general al modelo a escala de diseño que
nos hemos planteado como grupo.
Seguido a ello,
se plantea los materiales de hardware a ser usado y su ensamblado, al igual que
su conexión, no representada mediante un diagrama, sino mediante una
explicación precisa, donde se resalta las consideraciones a tenerse y sus
argumentos.
Por último se
expone el personal, insumos en término monetarios, tiempo de trabajo y
responsabilidades generadas para la producción del trabajo.
Palabras
Claves: alarma, Hardware, software, assembler, programación.
ABSTRACT: Continuing development of collaborative guides, Entering
parameter space, projection and primary production of the alarm’s home. While
it is known that they are intelligent house.
As a first step we want to expose developed for
handling the artificial intelligence code using a pic 16f87a7, which connected
to an electrical and mechanical system response database and the parameters
given in assembler programming, written in MPLAB software, will be given an
overview scale model of the design that we have considered as a group.
Followed this, hardware materials to be used and assembled,
like connection arises not represented by a diagram, but by a precise
explanation, where the considerations and arguments to be highlighted.
Finally the staff inputs in monetary terms, working
time and responsibilities generated for producing the work is published.
KEYWORDS: Alarm’s home, Hardware, software, assembler
programming.
OBJETIVO GENERAL
Realizar
la fase
de diseño de la propuesta de software y hardware para la solución del proyecto
planteado en el anterior trabajo.
Presentar
mediante un documento escrito el diseño de software dado en términos de
solución, el hardware empleado y los recursos necesitados para el empleo de la
construcción de una casa domótica a escala.
OBJETIVOS ESPECIFICOS
· Programación
en assembler para PIC18F877A·
·
Proyectar recursos y necesidades en términos de materiales
· Presentar
los conocimientos adquiridos durante el desarrollo del curso académico.
MARCO REFERENCIAL
El lenguaje
ensamblador, o assembler (assembly language en inglés), es un lenguaje de programación
de bajo nivel para
los computadores, microprocesadores, microcontroladores y
otros circuitos integrados
programables. Implementa una representación simbólica de los códigos de máquina binarios
y otras constantes necesarias para programar una arquitectura dada
de CPU y constituye la representación más directa
del código máquina específico
para cada arquitectura legible por un programador. Esta representación es
usualmente definida por el fabricante de hardware,
y está basada en los mnemónicos que
simbolizan los pasos de procesamiento (las instrucciones),
los registros del
procesador, las posiciones de memoria y
otras características del lenguaje. Un lenguaje ensamblador es por lo tanto
específico de cierta arquitectura de computador física
(o virtual). Esto está en contraste con la mayoría de los lenguajes de
programación de alto nivel,
que idealmente son portátiles.
Los componentes
electrónicos son aquellos dispositivos que forman parte de un circuito electrónico. Se suelen encapsular, generalmente en un material cerámico, metálico o plástico, y terminar en dos o más terminales o patillas metálicas. Se diseñan para ser
conectados entre ellos, normalmente mediante soldadura, a un circuito
impreso, para formar el mencionado circuito.
Hay que diferenciar
entre componentes y elementos. Los componentes son dispositivos físicos,
mientras que los elementos son modelos o abstracciones idealizadas que
constituyen la base para el estudio teórico de los mencionados componentes.
Así, los componentes aparecen en un listado de dispositivos que forman un
circuito, mientras que los elementos aparecen en los desarrollos matemáticos de
la teoría de circuitos.
I.
INTRODUCCIÓN
El
set de instrucciones de un microprocesador es el set de entradas binarias que
producen acciones definidas durante un ciclo de instrucción. Un set de
instrucciones es para el microprocesador lo mismo que una tabla de verdad es
para una compuerta lógica, un registro de desplazamiento o un circuito sumador.
Por supuesto, las acciones que realiza un microprocesador con cada instrucción,
son más complejas que las que realizan los dispositivos y compuertas antes
mencionados.
.
Se
pretende exponer los componentes, funcionabilidad, características y parámetros
de funcionamiento planteando Manejo de puertos de entrada/salida (I/O),
utilización de Temporizadores o módulos internos al micro controlador (ADC,
PWM, UART/USART, USB,
RJ45,
IIC, etc.), manejo de interrupciones internas o externas y periféricos externos al microcontrolador (teclados
matriciales, display 7-segmentos, display LCD, display GLCD, memorias, ADC,
transistores, relevos o indicadores, etc.)
Dentro
de los periféricos externos al micro ser Incluye:
·
Una interfaz humana mediante display LCD o y
pulsadores.
·
Una interfaz de control con los correspondientes
sensores encargados de enviar la información del exterior al micro y actuadores
encargados de ejercer control sobre la
planta o sistema a controlar.
II.
JUSTIFICACION
En
un mundo donde las comunicaciones y el precio de la energía marcan la pauta
resulta imprescindible disponer de un mejor control sobre los elementos
de nuestros hogares tales como la seguridad.
La
inseguridad que día a día crece en la ciudad, nos hace reflexionar sobre qué
tan protegido esta nuestro hogar ante un intento de robo o la intrusión de
extraños.
Pues bien la mayoría de hogares no cuenta
con ningún tipo de sistema que ayude a
que nuestra residencia sea segura, esos sistema de alarma son muy poco
utilizados ya que sus costos son muy altos, con este proyecto se pretende
realizar un sistema más asequible.
III.
CUERPO
DEL INFORME
En
primera medida de selección al lenguaje programador que más se acomode a las
expectativas del proyecto, igualmente se selecciona el software daño como
resultado el uso de leguaje assembler como lenguaje de bajo nivel y el programa
MPLAB como compilador de
desarrollador del código.
Figura No. 1 Ventana Principal
Software MPLAB
Acto
seguido se relaciona los materiales o insumos a ser empleados en la construcción
del proyecto así:
|
ITEM
|
ELEMENTO
|
Valor en pesos
|
|
1
|
Pic
16f877A
|
9000
|
|
2
|
Led
verde 5mm (10)
|
100
|
|
3
|
Led
rojo 5mm
|
100
|
|
4
|
Teclado
4X4
|
9000
|
|
5
|
Cristal
4Mhz
|
1000
|
|
6
|
Regulador
7805
|
1500
|
|
7
|
Portabateria
mas bater a3v
|
3000
|
|
8
|
Bornera
azul mediana (2)
|
300
|
|
9
|
Reloj
tiempo real Di1307
|
2000
|
|
10
|
Regleta
40 pines macho
|
2000
|
|
11
|
Regleta
4º pines hembra
|
2000
|
|
12
|
Base
40 pines
|
500
|
|
13
|
Base
8 pines
|
500
|
|
14
|
Lcd
4X208LMB204BPC)
|
30000
|
|
15
|
Resistencias (20)
|
30
|
|
16
|
Condensadores
(3)
|
50
|
|
17
|
Rele
5v
|
1000
|
Tabla No. 1 Proyección Elementos a
Utilizar
Figura No. 2 distribución teclado 4x4
Figura No. 3 diagrama pic 18f44
50/55
Detalles de los elementos a
utilizar:
Teclado Matricial:
Un teclado matricial es un
simple arreglo de botones
conectados en filas y columnas, de modo que se pueden leer
varios botones con el mínimo número de pines requeridos. Un teclado matricial
4×4 solamente ocupa 4 líneas de un puerto para las filas y otras 4 líneas para
las columnas, de este modo se pueden leer 16 teclas utilizando solamente 8
líneas de un microcontrolador. Si asumimos que todas las columnas y filas
inicialmente están en alto (1 lógico), la pulsación de un botón se puede
detectar al poner cada fila a en bajo (0 lógico) y checar cada columna en busca
de un cero, si ninguna columna está en bajo entonces el 0 de las filas se
recorre hacia la siguiente y así secuencialmente.
Microcontrolador 16f877A: Este
microcontrolador es fabricado por MicroChip familia a la cual se le denomina PIC. El modelo 16F877 posee varias
características que hacen a este microcontrolador un dispositivo muy versátil,
eficiente y practico para ser empleado en la aplicación que posteriormente será
detallada.
Algunas de
estas características se muestran a continuación:
·
Soporta modo de comunicación serial, posee dos
pines para ello.
·
Amplia memoria para datos y programa.
·
Memoria reprogramable: La memoria en este PIC
es la que se denomina FLASH;
este tipo de memoria se puede borrar electrónicamente (esto corresponde a la
"F" en el modelo).
·
Set de instrucción es reducido (tipo RISC),
pero con las instrucciones necesarias para facilitar su manejo.
Cristal de Cuarzo
El cristal de
cuarzo es utilizado como componente de control de la frecuencia de circuitos
osciladores convirtiendo las vibraciones mecánicas en voltajes eléctricos a una
frecuencia específica.
RTC DS1307: El DS1307 de Dallas Semiconductor
(Maxim) es una solución muy interesante cuando necesitamos trabajar con eventos
que requieren puntualidad y exactitud
a lo largo del tiempo. Este pequeño circuito integrado es uno de los más
populares relojes RTC (Real Time Clock)
del mercado por su sencillez de uso y por su confiabilidad a largo plazo.
Preparado para ofrecer la hora hasta el año 2100.
Figura
No 4 diagrama del RTC DS1307
Seguidamente
se realiza la proyección de personal y tiempo a emplearse, así:
|
# Personas
|
Tarea
|
Tiempo
|
|
3
|
Selección
Proyecto
|
1 semana
|
|
3
|
Proyección
Necesidades
|
1 semana
|
|
1
|
Diseño algoritmo
|
1 día
|
|
1
|
Consecución
Materiales
|
1 día
|
|
1
|
Diseño Software
|
2 meses
|
|
3
|
Montaje Circuito
|
1 semana
|
|
3
|
Prueba
|
1 día
|
Tabla No. 2 Proyección de Personal
III.I DESARROLLO
El
software se desarrolla en base a los ciclos formales de programación
estructurada, basándose en la arquitectura presentada por el pic, así pues se
inicia la construcción del código planteándose según las necesidades de
comportamiento seleccionadas en la proyección de proyecto.
IV DISEÑO DE SOFTWARE
PAUTAS DE MONTAJE
#include
<16f877A.h> // definimos el pic a usar
#fuses
XT,NOWDT,NOPROTECT
#use
delay(clock=4000000) // velocidad del cristal 4 mega hertz
#use
standard_io(D)
#use
standard_io(A)
#use
standard_io(B)
#use
standard_io(C)
#use
i2c(master, sda=PIN_C4, scl=PIN_C3)
#include
<E:\LCD4x20.c>
#include
<E:\KBD4x4.c>
#include
<E:\ds1307.c>
//PINES
LCD // PINES TECLADO //PINES DS1307
//
RW ---> B5 FILA1 --->
D3 SDA ---> C4
//
RS ---> B6 FILA2 --->
D2 SCL ---> C3
//
E ---> B4 FILA3 ---> D1
//
D4 ---> B3 FILA4 ---> D0
//
D5 ---> B2 COL1
---> D7
//
D6 ---> B1 COL2 ---> D6
//
D7 ---> B0 COL3 ---> D5
// COL4 ---> D4
#define
SENSOR1 PIN_C1
#define
SENSOR2 PIN_C0
#define
POWER_LED PIN_C2
#define
STATUS_LED PIN_C5
#define
S1_LED PIN_C6
#define
S2_LED PIN_C7
#define
BUZZER PIN_A0
///////
VARIABLES Y INICIALIZACION RTC //////
byte
day,mth,year,dow,hour,min,sec,temp_sec,hr_en=0,hr_ap=6;
char
ampm, am_pm;
/////////////////////////////////////////////
//////
CARACTERES ESPECIALES LCD ///////////
int
const c0_dr[8]={0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47};
int
const c0_dt[8]={0b00100,0b00100,0b00100,0b00111,0b00000,0b00000,0b00000,0b0};
int
const c1_dr[8]={0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f};
int
const c1_dt[8]={0b00100,0b00100,0b00100,0b11100,0b00000,0b00000,0b00000,0b0};
int
const c2_dr[8]={0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57};
int
const c2_dt[8]={0b00000,0b00000,0b00000,0b00111,0b00100,0b00100,0b00100,0b0};
int
const c3_dr[8]={0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f};
int
const c3_dt[8]={0b00000,0b00000,0b00000,0b11100,0b00100,0b00100,0b00100,0b0};
int
const c4_dr[8]={0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67};
int
const c4_dt[8]={0b00100,0b00110,0b00111,0b00100,0b00100,0b11100,0b11100,0b0};
int
const c5_dr[8]={0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f};
int
const c5_dt[8]={0b00100,0b10110,0b01111,0b00100,0b00110,0b11101,0b11100,0b0};
int
const c6_dr[8]={0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77};
int
const c6_dt[8]={0b00000,0b00100,0b01110,0b11111,0b00000,0b00000,0b00000,0b0};
int
const c7_dr[8]={0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f};
int
const c7_dt[8]={0b00000,0b00000,0b00000,0b11111,0b01110,0b00100,0b00000,0b0};
////////////////////////////////////////////
int
flag=5, parp=0, alarma=0, parp2=0, pag=1, ajpag=1, xpos=14, ypos=1;
int
pass1, pass2, pass3, pass4, pass_v1, pass_v2, pass_v3, pass_v4;
int
flg=0, cambiar=0, activada=0, registro=8, num_min=1;
char
k;
int16
cuenta=0, cuenta_act=0;
byte
get_number() { //////////////////
TOMA DOS CARACTERES NUMERICOS
char first,second;
do {
first=readkey();
delay_ms(100);
} while ((first<'0') || (first>'9'));
lcd_putc(first);
first-='0';
do {
second=readkey();
delay_ms(100);
} while ((second<'0') || (second>'9'));
lcd_putc(second);
second-='0';
return((first*10)+second);
}
byte
get_dow() { //////////////////
TOMA UN CARACTER NUMERICO (1-7)
char num;
do {
num=readkey();
delay_ms(100);
} while ((num<'1') || (num>'7'));
lcd_putc(num);
num-='0';
return(num);
}
char
get_ampm() { //////////////////
TOMA SI ES AM o PM EN EL RELOJ
do {
ampm=readkey();
delay_ms(100);
} while ((ampm<'A') || (ampm>'B'));
lcd_putc(ampm);
return(ampm);
}
void
set_clock(){ ////////////////// AJUSTAR EL RELOJ
lcd_gotoxy(3,1);
lcd_putc("\fAjuste de Fecha");
lcd_gotoxy(2,2);
lcd_putc("Año 20:");
year=get_number();
lcd_gotoxy(12,2);
lcd_putc("Mes:");
mth=get_number();
lcd_gotoxy(2,3);
lcd_putc("Dia:");
day=get_number();
lcd_gotoxy(2,4);
lcd_putc("Dia Semana(1-7):");
dow=get_dow();
lcd_gotoxy(3,1);
lcd_putc("\fAjuste de Hora");
lcd_gotoxy(2,2);
lcd_putc("Hora: ");
hour=get_number();
lcd_gotoxy(2,3);
lcd_putc("Min: ");
min=get_number();
lcd_gotoxy(2,4);
lcd_putc("AM=A PM=B: ");
am_pm=get_ampm();
if (am_pm=='B'){
hour=hour+12;}
else if (am_pm=='A' && hour ==12){
hour=00;}
ds1307_set_date_time(day,mth,year,dow,hour,min,0);
delay_ms(500);
lcd_putc("\f");
lcd_gotoxy(4,2);
lcd_putc("Hora y fecha \3 Ajustada");
delay_ms(1000);
lcd_putc("\f");
}
void
print_clock(){
////////////////// IMPRIME EL
RELOJ
if (flag==5)
{
temp_sec = sec;
ds1307_get_time(hour,min,sec);
if (hour==hr_en && min==0) alarma=1; ///// ACTIVAR ALARMA A LAS
12:00 AM (POR DEFECTO)
if (hour==hr_ap && min==0)
alarma=0; ///// DESACTIVAR ALARMA A LAS 6:00 AM (POR DEFECTO)
if (hour >= 12){
hour = hour-12;
if (hour==0) hour = 12;
lcd_gotoxy(xpos,ypos);
if (parp==0){
printf(lcd_putc,"%02u %02uPM",hour,min);
parp=1;
}
else {
printf(lcd_putc,"%02u:%02uPM",hour,min);
parp=0;
}
}
else if (hour == 0){
lcd_gotoxy(xpos,ypos);
if (parp==0){
printf(lcd_putc,"12 %02uAM",min);
parp=1;
}
else {
printf(lcd_putc,"12:%02uAM",min);
parp=0;
}
}
else {
lcd_gotoxy(xpos,ypos);
if (parp==0){
printf(lcd_putc,"%02u %02uAM",hour,min);
parp=1;
}
else {
printf(lcd_putc,"%02u:%02uAM",hour,min);
parp=0;
}
}
flag=0;
}
}
void
teclado(){
////////////////// LLAMADA A
TECLADO IMPRIMIENDO RELOJ
print_clock();
flag = flag+1;
delay_ms(1);
k=readkey();
}
void
caracter_LCD() { ///////////////// GUARDA LOS CARACTERES CREADOS EN LA LCD
int contador;
for(contador=0;contador<8;contador++){
lcd_send_byte(0,c0_dr[contador]); //modo comando
lcd_send_byte(1,c0_dt[contador]); // modo dato
lcd_send_byte(0,c1_dr[contador]); //modo comando
lcd_send_byte(1,c1_dt[contador]); // modo dato
lcd_send_byte(0,c2_dr[contador]); //modo comando
lcd_send_byte(1,c2_dt[contador]); // modo dato
lcd_send_byte(0,c3_dr[contador]); //modo comando
lcd_send_byte(1,c3_dt[contador]); // modo dato
lcd_send_byte(0,c4_dr[contador]); //modo comando
lcd_send_byte(1,c4_dt[contador]); // modo dato
lcd_send_byte(0,c5_dr[contador]); //modo comando
lcd_send_byte(1,c5_dt[contador]); // modo dato
lcd_send_byte(0,c6_dr[contador]); //modo comando
lcd_send_byte(1,c6_dt[contador]); // modo dato
lcd_send_byte(0,c7_dr[contador]); //modo comando
lcd_send_byte(1,c7_dt[contador]); // modo dato
}
}
void
led_alarma(){
////////////////// PONE A
PARPADEAR EL LED DE ESTADO
if (parp2==5 && alarma == 1 ){
output_toggle(STATUS_LED);
parp2=0;
}
else if (alarma ==1) parp2=parp2+1;
else if (parp2>5) parp2=0;
}
void
act_des(){
////////////////// PARA
ACTIVAR/DESACTIVAR ALARMA Y CAMBIAR CLAVE
iniact:
char p1,p2,p3,p4;
lcd_putc("\f");
if (cambiar==0){
lcd_gotoxy(4,2);
lcd_putc("Ingrese
Clave:");}
else if (cambiar ==1) {
lcd_gotoxy(1,2);
lcd_putc("Ingrese Clave
Vieja:");}
else if (cambiar ==2) {
lcd_gotoxy(1,2);
lcd_putc("Ingrese Clave Nueva:");}
else if (cambiar ==3) {
lcd_gotoxy(1,2);
lcd_putc("Ingresela Otra vez:");}
lcd_gotoxy(8,3);
lcd_putc("[____]");
lcd_gotoxy(18,4);
lcd_putc("B:");
lcd_gotoxy(20,4);
lcd_send_byte(1,0x7F);
/////////////////////////////CARACTER 1
CONTRASEÑA
caract1:
do {
p1=readkey();
led_alarma();
cuenta_act = cuenta_act + 1;
///////////// TANTOS MINUTOS PARA PONER
if (cuenta_act == num_min*600) goto finact; // CLAVE SINO SE SALE
delay_ms(100);
if (p1=='B'){ flg=1; goto finact; }
} while ((p1<'0') || (p1>'9'));
lcd_gotoxy(9,3);
lcd_putc('*');
p1-='0';
/////////////////////////////CARACTER 2
CONTRASEÑA
caract2:
do {
p2=readkey();
led_alarma();
delay_ms(100);
if (p2=='B'){
lcd_gotoxy(9,3);
lcd_putc("_");
goto caract1;
}
} while ((p2<'0') || (p2>'9'));
lcd_gotoxy(10,3);
lcd_putc('*');
p2-='0';
/////////////////////////////CARACTER 3
CONTRASEÑA
caract3:
do {
p3=readkey();
led_alarma();
delay_ms(100);
if (p3=='B'){
lcd_gotoxy(10,3);
lcd_putc("_");
goto caract2;
}
} while ((p3<'0') || (p3>'9'));
lcd_gotoxy(11,3);
lcd_putc('*');
p3-='0';
/////////////////////////////CARACTER 4
CONTRASEÑA
caract4:
do {
p4=readkey();
led_alarma();
delay_ms(100);
if (p4=='B'){
lcd_gotoxy(11,3);
lcd_putc("_");
goto caract3;
}
} while ((p4<'0') || (p4>'9'));
lcd_gotoxy(12,3);
lcd_putc('*');
p4-='0';
///////////////////////////////
VERIFICAR CLAVE
if(cambiar==2){
write_eeprom(0x00, p1);
write_eeprom(0x01, p2);
write_eeprom(0x02, p3);
write_eeprom(0x03, p4);
}
pass1 = read_eeprom(0x00);
pass2 = read_eeprom(0x01);
pass3 = read_eeprom(0x02);
pass4 = read_eeprom(0x03);
///////////////////////////////////////////////////////////////////////////////
if(p1==pass1 && p2==pass2
&& p3==pass3 && p4==pass4){
if (cambiar ==0){ // NO CAMBIAR
CLAVE
if (alarma==0){
alarma = 1;
lcd_putc("\f");
lcd_gotoxy(8,2);
lcd_putc("ALARMA");
lcd_gotoxy(7,3);
lcd_putc("ACTIVADA");
delay_ms(2000);
lcd_putc("\f");}
else if (alarma==1){
alarma = 0;
lcd_putc("\f");
lcd_gotoxy(8,2);
lcd_putc("ALARMA");
lcd_gotoxy(6,3);
lcd_putc("DESACTIVADA");
output_low(STATUS_LED);
delay_ms(2000);
lcd_putc("\f");}
}
else if (cambiar==1) { // INGRESAR CLAVE
VIEJA
cambiar = 2;
pass_v1 = read_eeprom(0x00);
pass_v2 = read_eeprom(0x01);
pass_v3 = read_eeprom(0x02);
pass_v4 = read_eeprom(0x03);
goto iniact;
}
else if (cambiar==2) { // CAMBIAR CLAVE
cambiar = 3;
goto iniact;
}
else if (cambiar==3) { // CONFIRMAR CLAVE
cambiar = 0;
lcd_putc("\f");
lcd_gotoxy(8,2);
lcd_putc("CLAVE");
lcd_gotoxy(7,3);
lcd_putc("CAMBIADA");
delay_ms(2000);}
}
else {
if (cambiar ==0 || cambiar ==1){
lcd_putc("\f");
lcd_gotoxy(6,2);
lcd_putc("Contraseña");
lcd_gotoxy(6,3);
lcd_putc("Incorrecta");
delay_ms(1000);
goto iniact;
}
else if (cambiar ==3){
lcd_putc("\f");
lcd_gotoxy(6,2);
lcd_putc("Contraseñas");
lcd_gotoxy(6,3);
lcd_putc("No
iguales");
delay_ms(1000);
goto iniact;
}
}
finact:
delay_ms(1);
}
void
sensores(){
////////////////// VERIFICA
SENSORES, REGISTRA Y ACTIVA/DESACTIVA SIRENA
if (alarma==1){
if (input(SENSOR1)==1){
output_high(S1_LED);
output_high(BUZZER);
activada=1;
goto activado;
}
if (input(SENSOR2)==1){
output_high(S2_LED);
output_high(BUZZER);
activada=1;
goto activado;
}
activada=0;
}
else if (alarma==0){
output_low(BUZZER);
output_low(S1_LED);
output_low(S2_LED);
activada=0;
}
activado:
if(activada==1){ //////////// REGISTRAR
EVENTO DE ALARMA //////////
if (registro==56){
int a; /// SI EL REGISTRO ESTA LLENO
for (a=8;a<=127;a++){ /// LO BORRA
write_eeprom(a, 0);
}
registro=8;
}
ds1307_get_date(day,mth,year,dow);
ds1307_get_time(hour,min,sec);
write_eeprom(registro,day);
write_eeprom(registro+1,mth);
write_eeprom(registro+2,year);
write_eeprom(registro+3,hour);
write_eeprom(registro+4,min);
registro = registro+8;
cuenta_act = 0;
act_des();
lcd_putc('\f');
output_low(BUZZER);
}
finsens:
delay_ms(1);
}
void
modo_reloj(){
////////////////// MUESTRA EN
PANTALLA UN MODO DE REPOSO
lcd_putc("\f");
xpos=8; ypos=2;
lcd_gotoxy(18,4);
lcd_putc("B:");
lcd_gotoxy(20,4);
lcd_send_byte(1,0x7F);
ds1307_get_date(day,mth,year,dow);
lcd_gotoxy(6,3);
printf(lcd_putc,"%02u/%02u/20%02u",day,mth,year);
reloj:
k=readkey();
while(k=='x'){
lcd_gotoxy(1,1);
if (alarma==0) lcd_putc("DES");
else lcd_putc("ACT");
flag = flag+1;
print_clock();
k=readkey();
led_alarma();
sensores();
if (activada==1){ activada=0; goto
finreloj;}
delay_ms(100);
}
if (k!='B') goto reloj;
finreloj:
xpos=14;
ypos=1;
}
void
hr_en_ap(){
////////////////// CAMBIAR LA
HORA AUTOMATICA ENCENDIDO/APAGADO
lcd_putc("\f");
lcd_gotoxy(4,1);
lcd_putc("HORA ENC/APAG");
lcd_gotoxy(1,2);
lcd_putc("Hora Encendido: ");
hr_en = get_number();
hr_en = hr_en + 12;
lcd_gotoxy(1,3);
lcd_putc("Hora Apagado: ");
hr_ap = get_number();
delay_ms(500);
lcd_putc("\f");
lcd_gotoxy(2,1);
lcd_putc("HORA ENC/APAG");
lcd_gotoxy(4,2);
lcd_putc("CAMBIADAS");
delay_ms(2000);
}
void
password(){
////////////////// CAMBIAR
CONTRASEÑA
lcd_putc("\f");
lcd_gotoxy(1,2);
lcd_putc("Cambiar Contraseña");
delay_ms(1000);
cambiar=1;
passwrd:
act_des();
if (flg==1 && cambiar==3){
write_eeprom(0x00, pass_v1);
write_eeprom(0x01, pass_v2);
write_eeprom(0x02, pass_v3);
write_eeprom(0x03, pass_v4);
lcd_putc("\f");
lcd_gotoxy(4,2);
lcd_putc("La Contraseña");
lcd_gotoxy(3,3);
lcd_putc("No fue cambiada");
delay_ms(1000);
}
}
void
ajustes(){
////////////////// MUESTRA MENU
DE AJUSTES DE LA ALARMA
ajpag=1;
iniaj:
lcd_putc("\f[ AJUSTES ]");
inicio2:
if (ajpag==1){
lcd_gotoxy(1,2);
lcd_putc("1.Hora y Fecha ");
lcd_gotoxy(1,3);
lcd_putc("2.Hora Enc/Apa ");
lcd_gotoxy(1,4);
lcd_putc("3.Contraseña ");
lcd_gotoxy(20,2);
lcd_send_byte(1,0x20);
lcd_gotoxy(20,4);
lcd_send_byte(1,0x07);
}
else if (ajpag==2){
lcd_gotoxy(1,2);
lcd_putc("2.Hora Enc/Apa
");
lcd_gotoxy(1,3);
lcd_putc("3.Contraseña ");
lcd_gotoxy(1,4);
lcd_putc("4.Atras ");
lcd_gotoxy(20,2);
lcd_send_byte(1,0x06);
lcd_gotoxy(20,4);
lcd_send_byte(1,0x20);
}
sigue2:
teclado();
if (ajpag==1){
if (k=='1') {set_clock(); goto finmenu2;}
else if (k=='2') {hr_en_ap(); goto finmenu2;}
else if (k=='3') {
password();
if (flg==1){
flg=0;
goto iniaj;
}
goto finmenu2;}
else if (k=='4') {goto sigue2;}
else if (k=='5') {goto sigue2;}
}
else if (ajpag==2){
if (k=='1') {goto sigue2;}
else if (k=='2') {hr_en_ap(); goto finmenu2;}
else if (k=='3') {
password();
if (flg==1){
flg=0;
goto iniaj;
}
goto finmenu2;}
else if (k=='4') { goto finmenu2;}
}
if (k=='D' && ajpag!=2 ){
ajpag=ajpag+1;
goto inicio2;
}
else if (k=='C' && ajpag!=1){
ajpag=ajpag-1;
goto inicio2;
}
if (k!='x'){
led_alarma();
sensores();
delay_ms(100);
goto sigue2;
}
else if (k=='x'){
led_alarma();
sensores();
delay_ms(100);
goto sigue2;
}
finmenu2:
lcd_putc("\f");
}
void
menu(){
////////////////// MUESTRA MENU
PRINCIPAL ALARMA
pag=1;
inimenu:
lcd_putc("\f[ MENU
]");
inicio:
if (pag==1){
lcd_gotoxy(1,2);
lcd_putc("1.Activar Alarma");
lcd_gotoxy(1,3);
lcd_putc("2.Desactivar Al.");
lcd_gotoxy(1,4);
lcd_putc("3.Modo Reloj ");
lcd_gotoxy(20,2);
lcd_send_byte(1,0x20);
lcd_gotoxy(20,4);
lcd_send_byte(1,0x07);
}
else if (pag==2){
lcd_gotoxy(1,2);
lcd_putc("2.Desactivar Al.");
lcd_gotoxy(1,3);
lcd_putc("3.Modo Reloj ");
lcd_gotoxy(1,4);
lcd_putc("4.Ajustes ");
lcd_gotoxy(20,2);
lcd_send_byte(1,0x06);
lcd_gotoxy(20,4);
lcd_send_byte(1,0x07);
}
else if (pag==3){
lcd_gotoxy(1,2);
lcd_putc("3.Modo Reloj
");
lcd_gotoxy(1,3);
lcd_putc("4.Ajustes ");
lcd_gotoxy(1,4);
lcd_putc("5.Atras ");
lcd_gotoxy(20,2);
lcd_send_byte(1,0x06);
lcd_gotoxy(20,4);
lcd_send_byte(1,0x20);
}
sigue:
teclado();
if (pag==1){
if (k=='1'){
if (alarma==1){
lcd_putc("\f\nAlarma ya Activada");
delay_ms(2000);
goto inimenu;
}
act_des();
if (flg==1){
flg=0;
goto inimenu;
}
else goto finmenu;
}
else if (k=='2') {
if (alarma==0){
lcd_putc("\f\nAlarma ya
Desactivada");
delay_ms(2000);
goto inimenu;
}
cambiar=0;
act_des();
goto finmenu;}
else if (k=='3')
{modo_reloj(); goto finmenu;}
else if (k=='4') {goto sigue;}
else if (k=='5') {goto sigue;}
}
else if (pag==2){
if (k=='1') {goto sigue;}
else if (k=='2') {
if (alarma==0){
lcd_putc("\f\nAlarma ya Desactivada");
delay_ms(2000);
goto inimenu;
}
cambiar=0;
act_des();
goto finmenu;}
else if (k=='3')
{modo_reloj(); goto finmenu;}
else if (k=='4') {ajustes();
lcd_putc("\f[ MENU ]"); goto inicio;}
}
else if (pag==3){
if (k=='1') {goto sigue;}
else if (k=='2') {goto sigue;}
else if (k=='3')
{modo_reloj(); goto finmenu;}
else if (k=='4') {ajustes();
lcd_putc("\f[ MENU ]"); goto inicio;}
else if (k=='5') {goto finmenu;}
}
if (k=='D' && pag!=3 ){
pag=pag+1;
goto inicio;
}
else if (k=='C' && pag!=1){
pag=pag-1;
goto inicio;
}
if (k!='x'){
led_alarma();
sensores();
delay_ms(100);
goto sigue;
}
else if (k=='x'){
led_alarma();
sensores();
delay_ms(100);
goto sigue;
}
finmenu:
lcd_putc("\f");
}
//////////////////// PROGRAMA //////////////////////////////////
//////////////////// PRINCIPAL //////////////////////////////////
void
main(){
set_tris_b(0x00);
output_low(BUZZER);
output_high(POWER_LED);
lcd_init();
kbd_init();
ds1307_init(DS1307_ALL_DISABLED);
caracter_LCD();
///////////////////
GUARDAR LA CLAVE POR PRIMERA VEZ EN LA EEPROM ////////////
////SE
PUEDE HACER TAMBIEN ESCRIBIENDO EN LA EEPROM CON EL PROGRAMADOR ///////
// write_eeprom(0x00, 1);
// write_eeprom(0x01, 9);
// write_eeprom(0x02, 3);
// write_eeprom(0x03, 8);
///////////////////
PONER EN 0 TODAS LAS DIRECCIONES DE LA EEPROM ////////////
// int a;
// for (a=8;a<=127;a++){
// write_eeprom(a, 0);
// }
//////////////////////////////////////////////////////////////////////////////
principal:
while(1){
if (alarma==0){
lcd_gotoxy(3,2);
lcd_putc("ALARMA NO
ACTIVA");
}
else {
lcd_gotoxy(3,2);
lcd_putc("ALARMA ACTIVADA
");}
lcd_gotoxy(4,3);
lcd_putc("A.Abrir Menu");
lcd_gotoxy(4,4);
lcd_putc("D.Ver
Registro");
teclado();
if (k!='x'){
if (k=='A'){ ////////////////////////// ABRIR
MENU PRINCIPAL
cuenta=0;
menu();
cuenta=0;}
else if (k=='*'){ ////////////////////////// BORRAR EL
REGISTRO
int a;
cuenta=0;
lcd_putc("\f");
lcd_gotoxy(2,2);
lcd_putc("Borrando
Registro");
lcd_gotoxy(6,3);
lcd_putc("[ ]");
delay_ms(500);
lcd_gotoxy(7,3);
lcd_send_byte(1,0xFF);
for (a=8;a<=28;a++){ write_eeprom(a, 0);}
lcd_send_byte(1,0xFF);
for (a=29;a<=48;a++){ write_eeprom(a, 0);}
lcd_send_byte(1,0xFF);
for (a=49;a<=68;a++){ write_eeprom(a, 0);}
lcd_send_byte(1,0xFF);
for (a=69;a<=88;a++){ write_eeprom(a, 0);}
lcd_send_byte(1,0xFF);
for (a=89;a<=108;a++){ write_eeprom(a, 0);}
lcd_send_byte(1,0xFF);
for (a=109;a<=127;a++){
write_eeprom(a, 0);}
lcd_send_byte(1,0xFF);
delay_ms(1000);
lcd_putc("\f");
lcd_gotoxy(2,2);
lcd_putc("Registro Borrado");
registro=8;
cuenta=0;
delay_ms(1000);
lcd_putc("\f");}
else if (k=='D'){ ////////////////////////// VER EL
REGISTRO DE EVENTOS
cuenta=0;
int
pagina=1,num=1, reg=8,i;
byte
d,mh,y,h,mn;
lcd_putc("\f");
lcd_gotoxy(7,1);
lcd_putc("REGISTRO");
delay_ms(300);
for (i=1;i<=6;i++){
d
= read_eeprom(reg);
mh = read_eeprom(reg+1);
y
= read_eeprom(reg+2);
h
= read_eeprom(reg+3);
mn = read_eeprom(reg+4);
lcd_gotoxy(1,pagina+1);
printf(lcd_putc, "%u. %02u/%02u/20%02u
%02u:%02u",num,d,mh,y,h,mn);
pagina=pagina+1;
num=num+1;
reg=reg+8;
if (i==3 || i==6){
lcd_gotoxy(20,4);
lcd_send_byte(1,0x7E);
k=readkey();
while((k<'A') || (k>'B')){
k=readkey();
sensores();
led_alarma();
delay_ms(100);
}
if (k=='B') goto finreg;
else pagina=1;
}
}
finreg:
lcd_putc("\f");
/////////////////////////////////////////////////////////////////////////////
cuenta=0;}
else if (k=='#'){ //////////////// CAMBIA EL TIEMPO
QUE SE MANTIENE LA SIRENA ENCENDIDA
lcd_putc("\f\n Digite #Min
Alarma");////// HASTA QUE SE APAGA POR NO PONER LA CLAVE
lcd_gotoxy(3,3);
lcd_putc( "estara
activa:_");
lcd_gotoxy(17,3);
num_min=get_dow();
delay_ms(700);
lcd_putc( "\f");
lcd_gotoxy(7,2);
lcd_putc( "CAMBIADO");
delay_ms(1000);
lcd_putc("\f");
}
}
if (cuenta==1200){ ///////// DOS MINUTOS PARA ENTRAR A MODO
RELOJ CUANDO NO SE PRESIONA TECLA
modo_reloj(); ///////// Y SE ESTA EN EL MENU PRINCIPAL
cuenta=0;
lcd_putc("\f");
}
else cuenta=cuenta+1;
led_alarma();
sensores();
delay_ms(100);
}
}
V.
CONCLUSIONES
Este trabajo está planteado para utilizar los
conceptos aprendidos durante la lectura de las unidades, la aplicación de las
soluciones y la implementación del
hardware y software como propuesta para el trabajo colaborativo a elaborar.
VI.
REFERENCIAS BIBLIOGRAFICAS
1.
http://galia.fc.uaslp.mx/~cantocar/microcontroladores/SLIDES_8051_PDF/20_MATRI.PDF;
El teclado Matricial; M.C. CARLOS E.
CANTO QUINTAL; Pag. 4 - 5.
2.
HUGO MARTIN DOMINGUEZ, FERNANDO
SAEZ VACAS; Centro de Domótica Integral; Fundación Rogelio Segovia para el
Desarrollo de las Telecomunicaciones; Ciudad Universitaria, s/n, 28040-Madrid. 2006.
3.
http://es.wikipedia.org/wiki/Resistencia_el%C3%A9ctrica.
4.
http://fresno.pntic.mec.es/~fagl0000/clasificacion.htm.
5.
Bill Sheets, Rudolf F Graf. Cristal Oscillators and Circuits
6.
http://micropic.wordpress.com/2007/06/13/teclado-matricial-4x4/
7.
http://www.electronicoscaldas.com/switches-teclados/129-teclado-4x4-matricial-membrana-27899.html
8.
http://blog-j.marcano.net.ve/index.php/2010/09/24/puente-h-con-l298-motores-dc-y-algo-de-pwm/
9.
http://www.google.com.co/imgres?imgurl=http%3A%2F%2Fwww.octoplus.com.co%2Ftienda%2Fwp-content%2Fuploads%2F2014%2F02%2Fmt8870p.jpg&imgrefurl=http%3A%2F%2Fwww.octoplus.com.co%2Ftienda%2Ftienda%2Fcircuitos-integrados%2Fmt8870%2F&h=450&w=700&tbnid=eH25AjpDwQs7NM%3A&zoom=1&docid=_HixcCCDvSbRrM&ei=ETFjU5GsOtSoyATI1oHADw&tbm=isch&client=firefox-a&ved=0CFMQMygCMAI&iact=rc&uact=3&dur=353&page=1&start=0&ndsp=15
10.
http://www.ucontrol.com.ar/Articulos/registros_de_desplazamiento_74164_4094/Image10.gif
No hay comentarios:
Publicar un comentario