PROYECTO FINAL MICRO CONTROLADORES I:

CERRADURA ELECTRONICA

ESTEBAN BARRERO GUTIERREZ

Cód. 1088326901
JUAN DAVID HERNANDEZ MEJIA
Cód. 1088270060

INGENIERÍA MECATRONICA
FACULTAD DE TECNOLOGIAS
UNIVERSIDAD TECNOLOGICA DE PEREIRA
09/07/2019
 1. INTRODUCCION

Los micro-controladores están conquistando al mundo. Están presentes en nuestro trabajo, en

nuestra casa y en nuestra vida, en general. Se puede encontrar controlando el funcionamiento de
los ratones y teclados de los computadores, en los teléfonos, hornos microondas y los televisores
de nuestros hogares.

Con el propósito de afianzar los conceptos vistos en clase, se realiza una cerradura electrónica la
cual es creada a partir de un micro controlador PIC 16F887, este a su vez nos permite explorar sus
capacidades, esto para realizar la programación propuesta para el proyecto; enfocando el programa
a ciertas condiciones relacionadas con el uso de los periféricos, como los son la pantalla LCD, un
teclado matricial y un banco de relés para trabaja con el actuador.

2. OBJETIVOS

2.1. OBJETIVOS GENERALES

 Desarrollar un sistema de control de una puerta con cerradura electrónica empleando el

micro controlador PIC 16f887A, utilizando como puertos de entrada y salida, teclado
matricial y la pantalla (LCD) respectivamente.

2.2. OBJETIVOS ESPECIFICOS

 Realizar un programa consistente con las restricciones del proyecto.

 Construir y simular en Proteus la construcción eléctrica del prototipo.
 Realizar el montaje eléctrico.
 Construir planta de trabajo.
 Realizar pruebas.
 3. MARCO TEORICO

Para realizar el proyecto se tiene que conocer un poco más sobre sus componentes, dado que sus
características permiten darle usos particulares propuestos por el usuario.

3.1. Micro controlador:

Un micro controlador es un circuito integrado programable, capaz de ejecutar las órdenes grabadas
en su memoria. Está compuesto de varios bloques funcionales, los cuales cumplen una tarea
específica. Un micro controlador incluye en su interior las tres principales unidades funcionales de
una computadora: unidad central de procesamiento, memoria y periféricos de entrada/salida. El
proyecto usa un micro controlador PIC 16f887, el cual posee las siguientes características:

1. Posee 40 pines.
2. Máxima frecuencia con reloj externo de 20 MHz.
3. Oscilador interno programable con un máximo de 8 MHz.
4. 36 pines usados como I/O digites programables.
5. 8K por 14 bits de memoria de programa.
6. Memoria EEPROM de 256 bytes.
7. Memoria RAM 368 bytes.
8. Conversor análogo/digital de 10 bits.
9. 2 temporizadores-contadores internos.
10. 2 módulos de comparación analógica.
11. Salida para PWM.
12. Puertos de comunicación tipo RS232, RS485, SPI y I2 C.
13. Alimentación de 5.5v a 20v.

La configuración de los pines se demuestra en la figura 1, este posee 5 puertos configurables (A, B,
C, D, E) de los cuales uno de ellos tiene pull-ups internos configurables.

Figura 1. Diagrama de configuración de pines.

 3.2. Temporizador/contador Timer 0:

El proyecto usa uno de los temporizadores/contadores internos, en este caso el timer 0. El módulo
Timer0 es un temporizadores/contadores de 8 bits con las siguientes características:

• Registro de temporizadores/contadores de 8 bits (TMR0).

• pre-escalado de 8 bits (compartido con el temporizador de vigilancia).
• Fuente de reloj interna o externa programable.
• Selección de reloj de borde externo programable.
• Interruptor de desbordamiento.

Cuando se usa este módulo, el Timer0 puede ser usado como un temporizador de 8 bits o un
contador de 8 bits.

3.3. Memoria EEPROM:

Para almacenar datos como las contraseñas de usa la memoria EEPROM; Este un tipo de memoria
ROM que puede ser programada, borrada y reprogramada eléctricamente, a diferencia de la EPROM
que ha de borrarse mediante un aparato que emite rayos ultravioleta. Son memorias no volátiles.
En el dispositivo usado PIC 16f887, la memoria de 256 bytes usa espacios de 8 bits, para escribir y
leer, los cuales almacenan información usada por el programa que es necesario almacenar de forma
permanente o temporal, aun si el dispositivo es desenrizado.
 4. Desarrollo del proyecto:

El proyecto consiste en que por medio de una pantalla LCD y un teclado matricial de 4x4, podamos
introducir una clave para abrir una cerradura, en el llegado caso que nos equivoquemos nos indique
que la clave es la incorrecta; adicional a las condiciones anteriores este sistema también debe poder
cambiar clave, y almacenar la clave nueva de forma permanente en la memoria del micro
controlador, asiendo entender que así no haya luz o el sistema re inicie este aun tendrá la
contraseña nueva guardada.

Para el uso del teclado, tenemos que:

 Tecla * Borra en código que se está digitando.

 Tecla # Tecla ENTER. Acepta el código que se encuentra digitado
 Tecla A Modo principal de funcionamiento. En este modo se permite la entrada de la clave
para abrir el cerrojo.
 Tecla B Modo secundario. En este modo el usuario puede realizar el cambio de clave para
el acceso al sistema.
 Teclas 0....9 Números.

4.1. Código:

Para realizar el proyecto de analizaron algunas fuentes con el propósito de conocer una forma
factible de desarrollar el código. Para el trabajo se tenía en cuenta de las estructuras más
importantes era el manejo de memoria, el uso de interrupciones y manejo de temporizadores.

Primero para el código se usa la configuración interna como se muestra en la figura 2, esta muestra
la configuración básica de los fusibles, configuración de puertos, velocidad del reloj interno y
librerías.

Figura 2. Encabezado del programa.

 El programa usa un teclado y una pantalla LCD, usando el teclado para las funciones propuestas en
el principio de este apartado y la pantalla se visualizan los resultados, en este caso se mostraría si
se está escribiendo una clave, si es correcta o se no lo es, además de morar se ha usado la función
de cambio de clave; todo esto lo hace en conjunto con el teclado y por medio de las instrucciones
del programa. El programa usa la siguiente estructura:

Encabezado:
Interrupciones: -Fusibles.
_TIMER0 como temporizador. -librerías.
-Configuración de puertos como I/O.
-Variables Globales.

Programa principal: Ciclo interno:

-Inicializadores Pantalla. -manejo de teclado.
Teclado. -escritura de memoria.
TIMER0. -visualización de resultados atreves de
-Lectura de memoria (si hay la pantalla (escritura de clave y si es
clave o no). correcta o no).

Con el orden del a estructura principal, se puede navegar en el programa; este posee 281 líneas. El
Si hay clave la asigna
Inicio del Programa: como la cave por defecto.
-Verifica si hay clave Bucle principal:
almacenada. -inicia el programa
pidiendo la clave.
Si no la hay pone la - es posible cambiar
clave por defecto que es de modo.
1234.

Si la clave es correcta:
-Activa indicador azul, activa Modo A (Por defecto): Modo B: Cambio
relé para el actuador (3 seg). ingreso de clave. de clave.
-Reinicia variables.

Si no es correcta: Cambio de clave: Verifica clave anterior:

-activa indicador (2 seg). -ingresa nueva clave. -Realiza el mismo
- Reinicia variables. -accede a la eeprom proceso de modo A
escribe la nueva -si es correcta pasa a
clave. cambio de clave
Figura 3. Estructura general del programa.
Con una visión general del se presenta el código, el cual está divido en diferentes secciones de la
siguiente manera:

////////////////////////////////////////////////////////////////////////////////////////////////////////
#INCLUDE <16F887.H>
#FUSES NOWDT, NOPUT, INTRC_IO, NOMCLR, NOPROTECT, NOBROWNOUT, NOWRT
#USE DELAY (clock = 8MHZ)
#INCLUDE <LCD.C>
#INCLUDE <KBD4X4.C>
#USE FAST_IO (B)
#USE FAST_IO(C)
////////////////////////////////////////////////////////////////////////////////////////////////////////
Int tecla=0, Funcion=2, cont=0, sinal;
int16 INClave=0, OutClave=1234, FN=0, FN1=0, tiempo=0;
int1 borrar=false, Marknuevo=false;
/////// Interrupción (temporizador)//////////////////////////////////////////////////////////////////
#int_timer0
Void tiempo0 ()
{
set_timer1 (205);
If (funcion==1) tiempo=tiempo+1;
If (tiempo==7500 && funcion== 1)
{
Tiempo=1;
Tecla=0x65;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
Void main ()
{
/* Arranque de entrada: contiene las funciones con las cuales arranca el
Sistema. Se usa el puerto C como salida final, el puerto B para el teclado,
Y el puerto D para la pantalla LCD. */
kbd_init ();
lcd_init ();
set_tris_C (0x00);
port_b_pullups (255);
output_c (0x00);
 //////////// Configuración del temporizador ///////////////////////////////////////////////////////

/*Se usa el timer 0, para usar el reloj interno, además se configura para
Que cuente 1 siclo luego de 8 tiempos en el reloj interno.*/
setup_timer_0 (RTCC_INTERNAL|RTCC_DIV_8);
enable_interrupts (int_timer0); // se activan las interrupciones para INT_TIMER0.
enable_interrupts (GLOBAL); // se activan las interrupciones de forma global.
set_timer0 (205); // se configura el valor del timer (este calculado para un tiempo
// De 200ms).
///////// Mensaje de entrada ////////////////////////////////////////////////////////////////////////
lcd_gotoxy (3,1);
lcd_putc ("Bienvenido");
delay_ms (1000);
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc ("Ingresar Clave:");
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Función para la lectura de la clave almacenada en la memoria:
Sinal=read_eeprom (0x32);
/* Lee la memora de un espacio de la eeprom destinado para el uso de
Almacenamiento, no es específicamente la memoria que se usa para el programa*/
If (sinal!=0x0C) // verifica si hay una clave guardada.
OutClave=1234; // si no hay nada, pone una clave por defecto (en este caso 1234).
Else// si la hay procede con la lectura.
{
/* La clave al ser de 16bits se divide en dos partes ya que cada espacio de
Memoria solo acepta hasta 8bits por lo que se opta por dividir la clave en
Dos posiciones contiguas, cuando se necesite se reconstruye*/
FN=read_eeprom (0x30); // se realiza la lectura de la primera parte de la clave (mil y cen).
FN1=read_eeprom (0x31); //se realiza la lectura de la segunda parte de la clave (dec y uni).
OutClave= (FN*100)+FN1; // se unen las dos partes.
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
While (true)
{
Tecla = kbd_getc (); // Es leído el teclado
If (tecla!= 0) // Si hay tecla oprimida se procede a identificarla
{
Switch (tecla)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////
Case 'B': // modo cambio de Clave:
Funcion = 1; // bandera para activa este modo.
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc ("Clave Actual:");
tiempo0 ();
Break;
////////////////////////////////////////////////////////////////////////////////////////////////////////
Case 'A': // (Por Defecto) Ingresar clave:
Funcion = 2; // bandera que activa este modo (por defecto activo).
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc ("Ingresar Clave:");
Break;
////////////////////////////////////////////////////////////////////////////////////////////////////////
Case 0x2A: // Ingresar Clave (*):
If ((Marknuevo==true) && (Funcion == 1))
{
FN=INClave/100; // antes de almacenar la clave se saca la parte superior (mil y cen),
FN1=INClave-(FN*100); // luego se saca la parte inferior (dec y uni).
///////////// Proceso de Guardado///////////////////////////////////////////////////////////////////
/* Para el guardado como se mencionó en la parte de lectura, se guarda la clave
En dos registros continuos, 0x30 y 0x31, adicional se pone una vadera que me indica
Si hay una contraseña guardada o no*/
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc (" Guardando ");
delay_ms (200);
write_eeprom (0x30, FN); // guarda la primera parte de la clave.
lcd_putc (" Guardando.");
write_eeprom (0x31, FN1); // guarda la segunda parte de la clave.
lcd_putc (" Guardando...”);
delay_ms (200);
write_eeprom (0x32, 0x0C); // Pone la bandera.
lcd_putc (" Guardando...");
delay_ms (200);
OutClave=INClave;
////////////////////////////////////////////////////////////////////////////////////////////////////////
Marknuevo=false; // Indicador de Clave nueva.
Funcion=3; // Saca del modo actual.
lcd_putc ("\f");
lcd_putc (" Presione A");
lcd_gotoxy (1,2);
lcd_putc (" Para Continuar");
}
// Primer paso para cambio de clave: verificación de la clave.
If ((Funcion == 1) && (Marknuevo==false))
{
// Si la clave es correcta pasa a la ventana de calve nueva
If (INClave==OutClave)
{
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc ("Clave Nueva:");
Marknuevo=true; // Indicador de clave nueva.
}
// Si se equivoca en el primer paso, reinicia pantalla y variables.
Else
{
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc (" Clave");
lcd_gotoxy (2,2);
lcd_putc (" Incorrecta");
delay_ms (2000);
lcd_putc ("\f");
lcd_putc ("Ingresar Clave:");
}
Borrar=true; // indicador para el reinicio de ingreso de clave.
}
//(modo por defecto) Se usa después de ingresar la clave.
If (Funcion == 2)
{
//Si la clave es correcta activa la salida y un LED indicado.
If (INClave==OutClave)
{
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc (" Clave");
lcd_gotoxy (2,2);
lcd_putc (" Correcta");
output_c (0x03); // Salida y LED indicado (pines 0 y 1 puerto C)
delay_ms (3000);
output_c (0x00); // luego del Delay apaga la salida.
lcd_putc ("\f");
 lcd_putc ("Ingresar Clave:");
}
// Si es incorrecta activa led indicador.
Else
{
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc (" Clave");
lcd_gotoxy (2,2);
lcd_putc (" Incorrecta");
output_c (0x04); // LED Indicador de clave incorrecta (pin 3 puerto c).
delay_ms (2000);
output_c (0x00); // apaga salidas luego de Delay.
lcd_putc ("\f");
lcd_putc ("Ingresar Clave:");
}
}
Borrar=true;
Break;
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Borrar Pantalla (#):
Case 0x23:
Inclave=0;
Cont=0;
lcd_gotoxy (1,2);
lcd_putc (" "); // sobre escribe con vacío los *.
Break;
/* Para el la siguiente sección se Usa el default del Switch case
Para realizar las operaciones del teclado numérico */
////////////////////////////////////////////////////////////////////////////////////////////////////////
Default:
/* Se llana dentro del código a "borrar" para reiniciar variables
Importantes en el código */
If (borrar == true)
{
Inclave=0;
Cont=0;
Borrar = false;
}
/* Todas las siguientes condiciones hacen referencia a cada una
De las funcionalidades de la cerradura*/
Tecla = tecla -0x30; // entrega el valor de tecla en decimal.
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Ingreso de clave (Por defecto Activado):
If (Funcion == 2)
{
If ((tecla>=0) && (tecla<=9))
{
INclave= Inclave*10 + tecla*1; //almacena la clave digitada.
Cont=cont+1; // contador (lleva el # dígitos y mueve el *).
lcd_gotoxy (cont, 2);
lcd_putc ("*"); //se visualiza * cuando se presiona tecla.
/*La siguiente condición es para cuando se pone una clave de
Mayor de 4 dígitos*/
If (cont>4)
{
Inclave=0; // reinicio de la clave.
Cont=0; // reinicio contador.
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc ("Clave de 4 dígitos");
lcd_gotoxy (1,2);
lcd_putc (" necesaria");
delay_ms (1000);
lcd_putc ("\f");
lcd_putc ("Ingresar Clave:");
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Esto es para cualquier valor de función que no sea el por defecto.
Else
{
//Para la función de cambio de clave (clave guardada):
If ((tecla>=0) && (tecla<=9))
{
INclave= Inclave*10 + tecla*1;
Cont=cont+1;
lcd_gotoxy (cont, 2);
lcd_putc ("*");
If (cont>4)
{
Inclave=0;
Cont=0;
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc ("Clave de 4 dígitos");
lcd_gotoxy (1,2);
lcd_putc (" necesaria");
delay_ms (1000);
 lcd_putc ("\f");
lcd_putc ("Clave Actual:");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//Para la función Cambio de clave (nueva clave):
If ((Marknuevo==true) && (Funcion == 1))
{
Tecla = tecla -0x30;
If ((tecla>=0) && (tecla<=9))
{
INClave= Inclave*10 + tecla*1;
cont=cont+1;
lcd_gotoxy (cont, 2);
lcd_putc ("*");
If (cont>4)
{
Inclave=0;
cont=0;
lcd_putc ("\f");
lcd_gotoxy (1,1);
lcd_putc ("Clave de 4 dígitos");
lcd_gotoxy (1,2);
lcd_putc (" necesaria");
delay_ms (1000);
lcd_putc ("\f");
lcd_putc ("Clave Nueva:");
}
}
}
}
break;
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
 4.2. Simulación:

Teniendo el código preparado, se usa la plataforma de Proteus para realizar una prueba virtual del
código, esto con el propósito de tener la seguridad de que el programa que es el software funciona
bien en conjunto con el hardware. Para la simulación se usa el teclado matricial, pantalla LCD y dos
indicadores como muestra la siguiente figura.

Figura 4. Plano general simulación.

En el programa se hace uso de 3 puertos, los cuales son el puerto B para el teclado, el puerto D
para la pantalla, el puerto se cómo salida I/O. en las siguientes figuras muestra la correspondencia
que se menciona:

Figura 5. Correspondencia de pines Pantalla.

 Figura 6. Correspodencia pines de teclado

Figura 7 correspondecia pines salidas.

Ya con los perisfericos del micro bien conectados y las salidas definidas, se realizan las prubas
correspondientes. En la figura 7 se muestran la salidas, la cuales son dos indicadores. Apersar de lo
salir marcado en esta figura, e lpin 15 RCO es definido dentro del programa como el pin del actuador.
 4.3. Construcción planta física:

Luego de verificar que la simulación fuera la correcta, basados en los planos de la simulación, se
construye la planta. Para construcción de la planta, esta se realiza en 3 faces: la primera consiste en
el montaje de circuito eléctrico que realizara las funciones, la segunda pasa a la construcción de una
carcasa protectora para el circuito eléctrico y la tercera y última consiste en la construcción de la
puerta y el seguro.

Para el montaje del circuito se usa el plano de la simulación y se monta en una protoboard, usa una
pantalla LCD, PIC 16f887, potenciómetro, resistencia de 1KΩ, teclado matricial 4X4 y cables. El
montaje se muestra en la siguiente figura:

Figura 8. Montaje eléctrico.

Con el montaje eléctrico terminado, se realiza la construcción de la carcasa, la cual va a albergar

este montaje eléctrico y de donde se dará la orden al actuador atreves de los relés. Las siguientes
figuras muestran la carcasa en el proceso de construcción.
 Figura 9. Primera fase de la carcasa.

Luego de contruir la base para la carcasa se añaden detalles, ademas de incluir de manera indirecta
los reles dentro de esta. En la siguentes figuras se muetra el proceso:

Figura 10. Nueva estructura de la cacasa.

 Figura 11. Carcasa terminada con montaje electrónico instalado.

Luego de la terminar el montaje de la carcasa, se procede a construir la planta en escaso se recrea

una puerta, la cual ayudara a demostrar el funcionamiento del actuador. Las siguientes figuras
muestran el proceso:

Figura 12. Puerta en crudo y seguro junto con resorte.

 Figura 13. Puerta terminada con actuador instalado.

4.4. Lista de materiales:

Para la realizacion del proyecto se necesitaron cierta cantidad de materiales, la siguente lista los
numera:

1. PIC 16F887.
2. Pantalla LCD LM016L.
3. Teclado matricial 4x4 (tipo menbrana).
4. Modulo de reles.
5. Ponteciometro de 10KΩ.
6. Resistencia de 1KΩ.
7. Funente de 5v con minimo de corriente de 1800mA.
8. Interrutor de montaje superficial.
9. Cables para protoboard.
10. Cantonera o serradura electrica.
11. Cable de calibre 16.
12. Conector para la cantonera.
13. 4 varas de 1,5X1,5 cm pino.
14. 1/2 de oja de mdf.
15. Cinta aislate y de papel.
16. Pegamento.
17. Puntillas, tornillos y alfileres.
 5. CONCLUCIONES:

Luego de realizar el proceso de contruccion del proyecto y su conclucion con un prototipo funcional,
se pueden hacer las siguentes obcerbaciones:

 Realizando el codigo se observo que el uso apropiado de memoria puede llegar a ser muy
util, en el llegado caso de mejorar el prototipo que se realizo se puede pesar en usar el
espacio de memoria para introducir varios usuario, usando otro medio de entrada como
tarjeta con chip registrado.
 Es combeniete limitar el tamaño de la contraceña resulta comodo para el usuario y el
programador y reduce costo computacional, ademas es preferible definir limites superiores
a inferiores, esto quiere decir que puedo tomas maximo de 4 digitos pero no limitar al
usuaria que no puede poner menos.
 Tener indicadores, ayuda a verificar errores en el funcionamiento electrico permite
visualizar el resultado de una manera mas amigable.
 Las cantoneras son actuadores delicados ya que estos depende de funcionamientos cortos,
en nuestro caso el actuador no resistia mas de 2 seg conectado.

6. BIBLIOGRAFIA:

se uso el siguente material bibligrafico para realizar el proyecto:

 CCS C Compiler Manual, october 2016, Custom Computer Services, inc.

 Compilador C CCS y Simulador PROTEUS para Microcontroladores PIC, Eduardo Garcia
Breijo, Editorial Alfaomega, Mexico, 2008.
 PIC16F882/883/884/886/887 Data Sheet, 28/40/44-Pin, Enhanced Flash-Based 8-Bit CMOS
Microcontrollers with nanoWatt Technology, Microchip Technology INC, 2007.