Manejo de perifericos para microcontroladore

MICROCONTROLADORES II
MANEJO DE PERIFÉRICOSMANEJO DE PERIFÉRICOS
(DISPLAYS, LCD , TECLADO Y EEPROM)
PROF. LUIS ZURITA

DISPLAYS
• Existe otra forma de trabajar con los displays 7
segmentos sin necesidad de utilizar un
decodificador BCD-7segmentos, como los
ejercicios mostrados en el tema 1 del presente
curso.curso.
• Al igual que en lenguaje ensamblador se
requiere el uso de una tabla para que se
pueda manipular directamente los 7
segmentos con el uso de un puerto.
Prof. Luis Zurita Microcontroladores II

• En lenguaje C la estructura equivalente a una tabla se
representa con un arreglo (array) de datos en un
formato similar al siguiente:
byte CONST DISPLAY[10] = { 0x3F, 0x06, 0x5b, 0x4f,
0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };
DISPLAYS
0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };
byte= define que el dato que se extraerá del array
“DISPLAY” será de este tipo.
CONST= define que será un valor constante
DISPLAY= es el nombre que el usuario le coloca al array
[10]= define la cantidad de elementos que contendrá el
array.

• Ahora, ¿Qué son estos valores que se encuentran
dentro del array?
• Tomemos el primero= 0x3F, en binario= 00111111
• Observemos el circuito interno de un display cátodo
común:
DISPLAYS
común: a
f
b
g
e
c
d
CATODO COMUNProf. Luis Zurita Microcontroladores II

• Si colocamos el dato 00111111 a los segmentos a-g
del display observaremos que se formará el dígito
cero (0).
• El resto de los códigos que se muestran en el array
corresponde a los dígitos restantes (1 al 9).
• El programa que se muestra a continuación permite
DISPLAYS
• El programa que se muestra a continuación permite
realizar un conteo de manera automática desde 00
hasta 99, mediante el uso de los bucles for
estudiados en el tema 1.
• A manera de ejercicio, usted puede modificar el
siguiente programa para que ejecute la cuenta de
forma manual.

Ejemplo 1. Realice un contador desde 00 hasta 99 y
reinicie su cuenta
#include <16f877.h>
#use delay(clock=4000000)
#use fast_io(B)
#use fast_io(C)
// Inicialización de variables, todas globales
byte CONST DISPLAY[10] = { 0x3F, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d,
0x07, 0x7f, 0x6f };
byte uni=0;
byte dec=0;byte dec=0;
void mostrar (void) //Función o subrutina mostrar
{ output_c(0x02);
output_b(DISPLAY[uni]);
delay_ms(50);
if (dec==0) output_c(0x03);
else output_c(0x01);
output_b(DISPLAY[dec]);
delay_ms(50);}

void main ( void ) // Programa principal
{
set_tris_b(0);
set_tris_c(0);
output_b(0);
for (;;){ // Programa de usuario
Ejemplo 1. Realice un contador desde 00 hasta 99 y
reinicie su cuenta
for (dec=0;dec<10;dec++){
for (uni=0;uni<10;uni++){
delay_ms(500);
mostrar();
}
}
}
}

Programa simulado en Proteus

CONTADORES CON DECODIFICADOR
• En el ejercicio anterior se utilizó el uso de arrays
(tablas en .asm) para el manejo de los displays 7
segmentos. Para el manejo de estos a través de
decodificadores BCD a 7 segmento con los circuitos
integrados 7447 o 7448, se debe implementar una
función o rutina para tal fin, permitiendo mostrar losfunción o rutina para tal fin, permitiendo mostrar los
datos mediante los decodificadores.

CONTADORES CON DECODIFICADOR
DATO
(3 cifras)
Centena Decena Unidad
Ingresa= 328
Sale = 8Sale = 2Sale = 3
void bin_bcd(){ // Rutina de conversión de binario a BCD
uni=0;uni=0;
dec=0;
cen=0;
copia=conta; //Registro a ser convertido
cen=copia/100;
copia= copia%100;
dec= copia/10;
copia= copia%10;
uni=copia;
}

Realizar un contador ascendente – descendente de 0 a 750
utilizando un decodificador BCD a 7 segmentos
#include <16F873A.h>
#fuses XT,NOWDT,NOLVP
#use delay (clock=4000000)
#BYTE TRISA=0x85
#BYTE PORTA=0x05
#BYTE TRISB=0x86
#BYTE PORTB=0x06
#BYTE TRISC=0x87
#BYTE PORTC=0x07
#BYTE OPTION_REG=0x81
void bin_bcd(){
// Rutina de conversión de binario a BCD
uni=0;
dec=0;
cen=0;
copia=conta; //Registro a ser convertido
cen=copia/100;
copia= copia%100;
dec= copia/10;
copia= copia%10;#BYTE OPTION_REG=0x81
int uni;
int16 dec;
int16 cen;
int16 conta;
int16 copia;
copia= copia%10;
uni=copia;
}
void mostrar(){
// Función de multiplexación de displays
bin_bcd();
bit_set(PORTB,4);
bit_set(PORTB,5);
bit_set(PORTB,6);
delay_ms(5);

bit_clear(PORTB,4);
bit_set(PORTB,5);
bit_set(PORTB,6);
PORTA=uni;
delay_ms(5);
bit_set(PORTB,4);
bit_clear(PORTB,5);
bit_set(PORTB,6);
PORTA=dec;
delay_ms(5);
while (1){
if (bit_test(PORTC,1)==0){ //se pulsó +1?
while (bit_test(PORTC,1)==0){
mostrar();} //cerrojo antirrebote
if(conta<750){
conta++;
}
else{
conta=0;
}delay_ms(5);
bit_set(PORTB,4);
bit_set(PORTB,5);
bit_clear(PORTB,6);
PORTA=cen;
delay_ms(5);
}
void main ( ) {
bit_clear (OPTION_REG,7);
TRISB=0x00;
TRISA=0X00;
TRISC=0XFF;
conta=0;
}
}
else if (bit_test(PORTC,0)==0){ //se pulsó -1?
while (bit_test(PORTC,0)==0){
mostrar();} //cerrojo antirrebote
if(conta<=0){
conta=0;}
else{
conta--;}
}
mostrar();
}
}

Pantalla LCD
• Las pantallas LCD (Liquid Cristal Display) sirven para
representar letras, números y caracteres presentes en el
código ASCII.
• En la actualidad las pantallas LCD incorporan internamente un
microcontrolador (Driver) encargado del manejo de los
diferentes comandos que permiten su escritura y lectura; así
como facilitar la comunicación con el mundo exterior.como facilitar la comunicación con el mundo exterior.
• Existen diversos fabricantes y modelos, siendo los más
comunes los de 16x2, 20x2 y 20x4, donde el primer número
indica los caracteres máximos que se pueden escribir en una
línea y el segundo número significa las líneas de las que
dispone una pantalla LCD. Por ejemplo 16x2 significa que se
pueden escribir 16 caracteres por 2 líneas.

• Una de las pantallas LCD más populares entre los
técnicos e ingenieros es la LCD del tipo HD44780 (Ver
www.electronica.com.ve)
• Así como se han estandarizado los segmentos de los
displays a nivel mundial, en las pantallas LCD, se ha
buscado unificar los criterios en cuanto a la
Pantalla LCD
buscado unificar los criterios en cuanto a la
identificación de los pines de conexión.
16x2
20x4

• Siendo estos:
1. Vss (Tierra)
2. Vcc (Alimentación entre 2.7 a 5.5 v)
3. Ajuste de contraste (entre 0 a 5 v)
4. RS (selección de registro)
5. R/W (Lectura/Escritura)
6. E (Enable)
7. D0 (Dato menos significativo [LSB])
Pantalla LCD
7. D0 (Dato menos significativo [LSB])
8. D1
9. D2
10. D3
11. D4
12. D5
13. D6
14. D7 (Dato más significativo [MSB])
15. Ánodo
16. Cátodo (estos dos últimos sirven para activar la luz interna de la pantalla
LCD)

• Los tres pines de control (RS, R/W y E) permiten
seleccionar y habilitar la pantalla LCD con la que
se está trabajando, así como escribir (aplicación
más típica) en ella.
• Los restantes pines (D0 a D7) sirven para enviar el
dato que se desea mostrar y/o el comando que
permitirá desplazar la posición del cursor, borrar
Pantalla LCD
permitirá desplazar la posición del cursor, borrar
la pantalla LCD, cambiar de línea y posición
dentro de la misma entre otros.
• Generalmente por ahorro de pines del
microcontrolador, se trabaja con el bus de datos
de 4 bits en la pantalla LCD (Desde D4 hasta D7).

Pantalla LCD con lenguaje C
• El compilador CCS, y en general cualquier
compilador, incorpora un fichero (driver) para
manejar fácilmente una pantalla LCD.
• El archivo es nuestro caso es LCD.c y debe
llamarse con un #include:llamarse con un #include:
#include LCD.c
• Este archivo tiene varias funciones ya
definidas.

lcd_init ( );
Es la primera función que debe ser llamada.
Borra la pantalla LCD y lo configura en formato de 4
bits, con dos líneas y con caracteres de 5x8 puntos,
modo encendido, cursor apagado y sin parpadeo.
Configura el LCD con un autoincremento del puntero
Configura el LCD con un autoincremento del puntero
de direcciones y sin desplazamiento del display real.
lcd_gotoxy (byte x, byte y);
Indica la posición de acceso al LCD. Por ejemplo:
lcd_gotoxy (1,2) indica la primera posición de la
segunda línea.
lcd_getc(byte x, byte y);
Lee el carácter de la posición (x,y).

lcd_putc (char s);
S es una variable de tipo char. Esta función escribe la
variable en la posición correspondiente. Si además se
indica:
f = se limpia la LCD
n= el cursor va a la posición (1,2)
n= el cursor va a la posición (1,2)
b= el cursor retrocede una posición.
El compilador de C ofrece una función más práctica para
trabajar con la LCD:
printf (string);
printf (cstring, values…)
printf (fname, cstring, values…)

• Donde string es una cadena o un arreglo
(array) de caracteres y values es una lista de
variables separadas por comas y fname es una
función.
• Adicional a esto, el formato a utilizar es %nt,
donde n es opcional y puede ser:
donde n es opcional y puede ser:
– 1-9 : para especificar cuántos caracteres se deben
especificar.
– 01-09: para indicar la cantidad de ceros a la
izquierda.
– 1.1-9.9 : para coma flotante.

t puede indicar:
c Carácter
s Cadena o carácter
u Entero sin signo
d Entero con signo
Lu Entero sin signo
Ld Entero largo con signo
Ld Entero largo con signo
x Entero hexadecimal (minúscula)
X Entero hexadecimal (mayúscula)
Lx Entero largo hexadecimal (minúscula)
LX Entero largo hexadecimal (mayúscula)
f Flotante con truncado
g Flotante con redondeo
e Flotante en formato exponencial
w Entero sin signo con decimales insertados. La 1ra cifra
indica el total, la 2da el número de decimales.

• Veamos algunos ejemplos de los distintos
formatos:
Formato Valor = 0xFE
%03u 254
%u 254
%d -2
%x fe
%X FE
%4X 00FE
%3.1w 25.4

• Otros ejemplos de aplicación:
byte x,y,z;
printf (“Micro”)
printf (“Valor=>%2xnr” , get_rtcc( ) );
printf (“Valor=>%2xnr” , get_rtcc( ) );
printf (“%2u % X %4Xnr”, x,y,z);
printf (LCD_PUTC, “n=%u”,n);

• El driver LCD.C trabaja con el Puerto D o el Puerto B. Por
defecto trabaja con el Puerto D.
• Sin embargo podemos modificarlo para que trabaje con el
Puerto C (no con el Puerto A ni el Puerto E, por no tener 7 bits
mínimos para manejar la pantalla LCD), mediante la
modificación del fichero LCD.c como se muestra a
continuación en dos partes del mismo:
continuación en dos partes del mismo:
1
2

• Luego de modificar el fichero podemos elegir entre el puerto
C o D mediante el uso de las directivas:
#define use_portc_lcd false
#define use_portd_lcd true
#include <lcd.c>
• O mediante el uso de la siguiente directiva:
#define LCD_DATA_PORT getenv("SFR:PORTC")
La cual debe estar colocada antes de declarar el driver de la
pantalla LCD.
Ejemplo:
#include LCD.c
Si la colocamos en orden inverso, trabajará por defecto con el
Puerto D.

• Veamos un ejemplo sencillo para el manejo de
una pantalla LCD.
1. Se pide que si un pulsador está en 1, se muestre
un mensaje en una pantalla LCD que indique:
“PRESIONE TECLA” y muestre en la segunda
línea el valor de un registro llamado “Dato1”, así
como tener activado un led en RC0.
como tener activado un led en RC0.
2. Cuando se presione el pulsador (pasa a 0), se
pide que se muestre un mensaje que indique
“PULSADOR EN 0” y muestra el valor del registro
“Dato1” que se incrementa en uno, así como
tener desactivado el led RC0.
3. Dato1 inicia en 0.

#include <16F877A.h>
#fuses XT,NOWDT,NOPROTECT,PUT
#use delay(clock=4000000)
#use standard_io(C)
#use standard_io(A)
#use standard_io(B)
#include <lcd.c>
Ejercicio de pantalla LCD
#include <lcd.c>
int DATO1=0;
void main(){
lcd_init( );
while (true){

if (input(PIN_A0)==1){
output_high(PIN_C0);
delay_ms(5);
lcd_gotoxy(1,1);
printf(lcd_putc,"PRESIONE TECLA");
delay_ms(50);
lcd_gotoxy(1,2);
printf(lcd_putc,"DATO1=%d",DATO1);
delay_ms(50);
if (input(PIN_A0)==0)
{
output_low(PIN_C0);output_low(PIN_C0);
lcd_gotoxy(1,1);
printf(lcd_putc,"PULSADOR EN 0 ");
delay_ms(50);
lcd_gotoxy(1,2);
DATO1++;
printf(lcd_putc,"DATO1=%d",DATO1);
delay_ms(50);
}
}
}
}Prof. Luis Zurita Microcontroladores II

Sin presionar el pulsador

Al presionar el pulsador

• Otro de los periféricos especiales que se utilizan en
los proyectos con microcontroladores es el teclado
matricial.
• Vienen generalmente en dos presentaciones: 3x4 y
4x4. Donde el primer número indica las cantidades
de columnas y el segundo las cantidades de filas. Por
Teclado Matricial
de columnas y el segundo las cantidades de filas. Por
ejemplo 3x4 significa 3 columnas por 4 filas, para un
total de 12 teclas.

• Esta es una conexión típica entre un teclado y un
microcontrolador:
Teclado Matricial

• Sin embargo si se activan las resistencias pull-ups del
puerto B no se hace necesario la conexión de las
resistencias en el circuito anterior:
port_b_pullups(TRUE);
• Los microcontroladores PICs han dispuesto de una
interrupción por cambio de nivel en cualquiera de los
Teclado Matricial
interrupción por cambio de nivel en cualquiera de los
pines RB4 a RB7, lo cual resulta ideal para conectarse
con un teclado matricial, ya que se puede preparar
una función(subrutina) de interrupción por esta
causa.

• El compilador de C posee el driver KBD.c para
manejar un teclado 3x4. Las funciones que
incorporan son las siguientes:
kbd_init ( )
Inicializa el sistema para manejo del teclado.
Teclado Matricial con lenguaje C
Inicializa el sistema para manejo del teclado.
Debe ser la primera función en el programa.
kbd_getc ( )
Devuelve el valor de la tecla pulsada en
función de la tabla que tiene programada.

• Extracto del fichero KBD.c en donde se muestran los
valores de las teclas:
• Esta tabla puede ser modificada para adecuar el
resultado del programa a las distintas presentaciones
del teclado.

• El archivo KBD.c está pensado para trabajar con el Puerto B o
el Puerto D. Basta activar o no la siguiente directiva:
#define use_portb_kbd true o
#define use_portb_kbd false
Fichero KBD.c
Microcontroladores II

• Las conexiones vienen dadas en el fichero y se
pueden modificar:
Fichero KBD.c

• Se puede trabajar con la pantalla LCD y el teclado a
través de puertos separados.

• Realicemos un ejercicio básico para el manejo del
teclado. Introduzca un dato mediante el teclado y
visualícelo en una pantalla LCD. Si se presiona “*”
aparecerá en la pantalla el mensaje: “TECLA=???”
• Para cualquier otra tecla que se presione aparecerá
en la pantalla el mensaje:“TECLA= Nro de la tecla que
Ejercicio 1 de Teclado y LCD.
en la pantalla el mensaje:“TECLA= Nro de la tecla que
se presionó”.
• El mensaje inicial será: “PRESIONE TECLA”
• Utilizar el Puerto B para el manejo del teclado y el
Puerto D para el manejo de la pantalla LCD.

#include <16f877a.h>
#use delay (CLOCK = 4000000)
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use standard_io(b)
#use standard_io(d)
#define use_portb_kbd TRUE // Se define al Puerto B para
#define use_portb_kbd TRUE // Se define al Puerto B para
//manejar el teclado. Por defecto el puerto D manejará la pantalla LCD
#include <lcd.c> // Se incluye el driver para la pantalla LCD
#include <kbd.c> // Se incluye el driver para el teclado 3x4

void main() {
char k; // Se declara k como un dato tipo char o carácter
int x;
lcd_init();
kbd_init();
lcd_putc("fPRESIONE TECLAn"); // Mensaje inicial antes de entrar en bucle
while (TRUE) {
k=kbd_getc();
Ejercicio 1 de Teclado y LCD. Continuación.
k=kbd_getc();
x=k-48; // Con esta resta se lleva un dato tipo carácter (ASCII) a
decimal.
if(k!=0){
if(k=='*') // Si se presiona “*”
lcd_putc("f TECLA=???"); // muestra este mensaje
else
printf(lcd_putc,"f TECLA=%u",x); //Caso contrario muestra el valor de la
// tecla presionada.
delay_ms(1000);
}
}
} Microcontroladores II

• Realicemos un ejercicio de selección de funciones en base a
la tecla que se haya presionado. El mensaje inicial será:
“PRESIONE FUNCION”.
• Si la tecla presionada es 1: Se activa el led rojo y se muestra
en la pantalla LCD: “FUNCION 1”
• Si la tecla presionada es 3: Se activa el led amarillo y se
muestra en la pantalla LCD: “FUNCION 2”
• Si la tecla presionada es 5: Se activa el led verde y se
• Si la tecla presionada es 5: Se activa el led verde y se
muestra en la pantalla LCD: “FUNCION 3”
• Si la tecla presionada es 8: Se activa el led azul y se muestra
en la pantalla LCD: “FUNCION 4”
• Si se presiona cualquier otra tecla, los leds se prenden
secuencialmente y luego se apagan con un intervalo de 500
ms y se muestra en la pantalla LCD: “TODOS OFF”

#use standard_io(b)
#use standard_io(d)
#use fast_io(c)
#define use_portb_kbd TRUE
#define use_portd_lcd TRUE
#include <lcd.c>
#include <lcd.c>
#include <kbd.c>
void main() {
set_tris_c(0x00);
char k;
int x;
lcd_init();
kbd_init();
printf(lcd_putc,"fPRESIONE FUNCION");
OUTPUT_C(0x00);

while (TRUE) {
k=kbd_getc();
x=k-48; // Con esta resta se lleva
//un dato tipo carácter (ASCII) a
//decimal.
if (k!=0) {
if (x==1)
{OUTPUT_C(0x01);
printf(lcd_putc,"fFUNCION 1");}
OUTPUT_C(0x01);
delay_ms(500);
OUTPUT_C(0x03);
delay_ms(500);
OUTPUT_C(0x07);
delay_ms(500);
OUTPUT_C(0x0f);
delay_ms(500);
OUTPUT_C(0x07);
else if (x==3)
{OUTPUT_C(0x02);
else if (x==5)
{OUTPUT_C(0x04);
else if (x==8)
{OUTPUT_C(0x08);
else
{printf(lcd_putc,"fTODOS OFF");
OUTPUT_C(0x07);
delay_ms(500);
OUTPUT_C(0x03);
delay_ms(500);
OUTPUT_C(0x01);
delay_ms(500);
OUTPUT_C(0x00);
delay_ms(500);
}
}
}
}
Nota: También
aplica la estructura
case

Ejercicio 2 de Teclado y LCD. Al iniciar

Ejercicio 2 de Teclado y LCD. Función 1

Ejercicio 2 de Teclado y LCD. Función “TODOS OFF”

• La EEPROM (Electrically Erasable Programmable
Reading Only Memory) o Memoria de Sólo Lectura
Borrable Eléctricamente, de un microcontrolador de
la familia PIC16F87X varia entre 128 a 256 bytes x 8
bits de capacidad, según la siguiente tabla:
Manejo de la EEPROM de un Microcontrolador
EEPROM Data PIC16F873 PIC16F874 PIC16F876 PIC16F877
• Estas permiten almacenar datos de importancia para
su posterior procesamiento y/o comparación, como
por ejemplo valores patrones o claves que se desean
mantener almacenados indefinidamente.
EEPROM Data
Memory
PIC16F873 PIC16F874 PIC16F876 PIC16F877
128 128 256 256

• El manejo de la EEPROM resulta muy sencillo de
llevar a cabo, pues sus operaciones se reducen a
escribir en ella, con una dirección(es) específica(s) o
a leer lo que hay en ella, con una dirección(es)
específica(s).
• Para leer en la EEPROM se utiliza:
EEPROM con lenguaje C
• Para leer en la EEPROM se utiliza:
read_eeprom( )
Sintáxis: valor= read_eeprom(address,[N]) ó
valor= read_eeprom(address,variable) ó
valor=read_eeprom(address,pointer,N)

Parámetros:
• address es un entero de 8 bits y especifica la dirección a leer.
• N especifica el número de bytes de la EEPROM a leer. Por defecto si
se omite, se leerá un byte.
• Variable es una ubicación especificada para guardar el dato leido de
la EEPROM
La directiva ejecutada devuelve un valor de 8 bits.
Por defecto la función lee una palabra de la EEPROM de la dirección
especificada. El número de bytes para leer puede definirse
Por defecto la función lee una palabra de la EEPROM de la dirección
especificada. El número de bytes para leer puede definirse
opcionalmente por el argumento N. Si una variable se usa como un
argumento, entonces la EEPROM se lee y los resultados se ponen
en la variable hasta que el tamaño de los datos de la variable esté
lleno. Finalmente, si un indicador se usa como un argumento,
entonces se leen los n bytes de la EEPROM a la dirección dada al
indicador.
Ejemplo:
#define ULTIMO_VALOR 10
valor=read_EEPROM (ULTIMO_VALOR)

• Para escribir en la EEPROM se utiliza:
write_eeprom( )
Sintáxis: write_eeprom(address,value) ó
write_eeprom(address,pointer,N)
Parámetros:
• address es la ubicación de la EEPROM a escribir.
address es la ubicación de la EEPROM a escribir.
• N especifica el número de bytes de la EEPROM a escribir.
• Value es una constante o variable a escribir en la EEPROM.
Ejemplo:
#define ULTIMO_VALOR 10 //Ubicación en la EEPROM
valor++;
write_eeprom (ULTIMO_VALOR , valor);

Directiva #ROM
• Sintaxis: # rom address = {list};
• Elementos: address es una palabra de dirección de la ROM,
list es una lista de palabras separadas por las comas .
• Propósito: Permite la inserción de datos en el archivo .HEX.
En particular, esto puede usarse para programar los datos
de la EEPROM, como es mostrado en el siguiente ejemplo :
de la EEPROM, como es mostrado en el siguiente ejemplo :
• Note que este directiva no previene el área de la ROM a
usarse.
La directiva #ORG sirve para reservar posiciones de la ROM.
Ejemplo:
#rom 0x2100={1,2,3,4,5,6,7,8} Asigna los valores que se
encuentran dentro de los corchetes {}, a las posiciones
0,1,2,3,4,5,6,7 y 8 de la EEPROM.

• Realizar un programa que escriba en la posición 23 de la
EEPROM un dato que se incrementa de uno en uno. Leer la
posición 10 y guardar su valor en un registro llamado “copia”.
Ejercicio 1 con la EEPROM
void main(void){void main(void){
byte dato=10; //define el valor inicial del dato
byte copia=0; //define el valor inicial del registro copia
byte direccion=23; //define el valor de la dirección de la EEPROM
while (true){
dato++; //dato=dato+1
write_eeprom(direccion,dato); // escribe en la dirección el dato
copia=read_EEPROM(direccion); // lee la dirección y lo guarda en
copia
}
}

Ejercicio 1 con la EEPROM.
Antes de ejecutarse la escritura.
Posición 23 dePosición 23 de
la EEPROM sin
valor grabado

Posición 23 de
Luego de ejecutarse la escritura.
Posición 23 de
la EEPROM con
valor grabado

Luego de ejecutarse la lectura.
Registro “copia” con el
valor leído de la EEPROM

• Diseñar un sistema básico para un control de
acceso. Mediante un teclado 3x4 introducir una
clave de 4 dígitos. Si la clave es correcta indicar
mediante un led verde y abrirse una cerradura
eléctrica por 2 segundos, así como mostrarse en
una pantalla LCD el mensaje “PUERTA ABIERTA”.
Si la clave es incorrecta se debe mantener un led
Ejercicio 2 con la EEPROM, TECLADO Y LCD
Si la clave es incorrecta se debe mantener un led
rojo indicando que la puerta también se
mantiene cerrada, así como mostrarse en una
pantalla LCD el mensaje “PUERTA CERRADA”.
• A medida que se vayan presionando las teclas se
irá mostrando dicha información en la pantalla
LCD.

#use standard_io(a)
#use standard_io(b)
#use standard_io(d)
#use fast_io(c)
// respectivamente
void main() {
char k;
int i;
char data[4], clave[4];
//Matrices para guardar clave y datos
#use fast_io(c)
#define use_portb_kbd TRUE
#define use_portd_lcd TRUE
#include <lcd.c>
#include <kbd.c>
#include <stdlib.h>
#rom 0x2100={'2','0','1','1'}
//Posición 0,1,2 y 3 de la EEPROM
//Con los datos 2,0,1, y 1
//Matrices para guardar clave y datos
lcd_init();
kbd_init();
output_low(PIN_A0);
output_low(PIN_A2);
//Led verde=off
output_high(PIN_A1);
//Led rojo=onProf. Luis Zurita Microcontroladores II

while (TRUE) {
i=0; //posición de la matriz
printf(lcd_putc,"fPULSAR TECLA 1n"); //Primer dato
while(i<=3){ //Para cuatro datos
k=kbd_getc(); //Lee el teclado
if (k!=0) //Si se ha pulsado alguna tecla
if (k!=0) //Si se ha pulsado alguna tecla
{data[i]=k; //se guarda en la posición correspondiente
i++; //de la matriz
printf(lcd_putc,"fPULSAR TECLA %un",i+1); //Siguiente dato
}
}
for (i=0;i<=3;i++) { //Pasa datos de eeprom a la matriz clave
clave[i]=read_eeprom(i);}

if ((data[0]==clave[0])&&(data[1]==clave[1])&&(data[2]==clave[2])&&(data[3]==clave[3]))
//compara digito a digito los valores almacenados en la EEPROM y la clave
// introducida
{ printf(lcd_putc,"fPUERTA ABIERTA"); //Compara los datos con la clave
output_low(PIN_A1); //Led Rojo=off
output_high(PIN_A0);//Abre la cerradura con pulso al relé
output_high(PIN_A2);//Led Verde=on
delay_ms(2000);
delay_ms(2000);
output_low(PIN_A0);//Cierra la cerradura con pulso al relé
output_low(PIN_A2);//Led Verde=off
output_high(PIN_A1);}//Led Rojo=on
else printf(lcd_putc,"fPUERTA CERRADA"); //Clave errónea
delay_ms(1000);
}
}

Luego de presionar una clave errada

Luego de presionar la clave correcta

Manejo de perifericos para microcontroladore

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Manejo de perifericos para microcontroladore

Semelhante a Manejo de perifericos para microcontroladore (20)

Mais de Luis Zurita

Mais de Luis Zurita (20)

Último

Último (20)

Manejo de perifericos para microcontroladore