4° UNIDAD 2 SALUD,ALIMENTACIÓN Y DÍA DE LA MADRE 933623393 PROF YESSENIA CN.docx
MANEJO DE PERIFERICOS PARA MICROCONTROLADORES EN C
1. IUT Cumaná
MICROCONTROLADORES II
MANEJO DE PERIFÉRICOS
(DISPLAYS, LCD , TECLADO Y EEPROM)
PROF. LUIS ZURITA
2. DISPLAYS IUT Cumaná
• 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.
• 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
3. DISPLAYS IUT Cumaná
• 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 };
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.
Prof. Luis Zurita Microcontroladores II
4. DISPLAYS IUT Cumaná
• 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: a
f
b
g
e
c
d
Prof. Luis Zurita CATODO COMUN Microcontroladores II
5. DISPLAYS IUT Cumaná
• 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
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.
Prof. Luis Zurita Microcontroladores II
6. Ejemplo 1. Realice un contador desde 00 hasta 99 y
reinicie su cuenta
IUT Cumaná
#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;
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);}
Prof. Luis Zurita Microcontroladores II
7. Ejemplo 1. Realice un contador desde 00 hasta 99 y
reinicie su cuenta
IUT Cumaná
void main ( void ) // Programa principal
{
set_tris_b(0);
set_tris_c(0);
output_b(0);
for (;;){ // Programa de usuario
for (dec=0;dec<10;dec++){
for (uni=0;uni<10;uni++){
delay_ms(500);
mostrar();
}
}
}
}
Prof. Luis Zurita Microcontroladores II
9. Pantalla LCD IUT Cumaná
• 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.
• 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.
Prof. Luis Zurita Microcontroladores II
10. Pantalla LCD IUT Cumaná
• 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
identificación de los pines de conexión.
16x2
20x4
Prof. Luis Zurita Microcontroladores II
11. Pantalla LCD IUT Cumaná
• 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])
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)
Prof. Luis Zurita Microcontroladores II
12. Pantalla LCD IUT Cumaná
• 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
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).
Prof. Luis Zurita Microcontroladores II
13. Pantalla LCD con lenguaje C IUT Cumaná
• 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:
#include LCD.c
• Este archivo tiene varias funciones ya
definidas.
Prof. Luis Zurita Microcontroladores II
14. Pantalla LCD con lenguaje C IUT Cumaná
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
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).
Prof. Luis Zurita Microcontroladores II
15. Pantalla LCD con lenguaje C IUT Cumaná
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)
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…)
Prof. Luis Zurita Microcontroladores II
16. Pantalla LCD con lenguaje C IUT Cumaná
• 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:
– 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.
Prof. Luis Zurita Microcontroladores II
17. Pantalla LCD con lenguaje C IUT Cumaná
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
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.
Prof. Luis Zurita Microcontroladores II
18. Pantalla LCD con lenguaje C IUT Cumaná
• 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
Prof. Luis Zurita Microcontroladores II
19. Pantalla LCD con lenguaje C IUT Cumaná
• Otros ejemplos de aplicación:
byte x,y,z;
printf (“Micro”)
printf (“Valor=>%2xnr” , get_rtcc( ) );
printf (“%2u % X %4Xnr”, x,y,z);
printf (LCD_PUTC, “n=%u”,n);
Prof. Luis Zurita Microcontroladores II
20. Pantalla LCD con lenguaje C IUT Cumaná
• 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:
1
2
Prof. Luis Zurita Microcontroladores II
21. Pantalla LCD con lenguaje C IUT Cumaná
• 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:
#define LCD_DATA_PORT getenv("SFR:PORTC")
#include LCD.c
Si la colocamos en orden inverso, trabajará por defecto con el
Puerto D.
Prof. Luis Zurita Microcontroladores II
22. Pantalla LCD con lenguaje C IUT Cumaná
• 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.
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.
Prof. Luis Zurita Microcontroladores II
23. Ejercicio de pantalla LCD IUT Cumaná
#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>
int DATO1=0;
void main(){
lcd_init( );
while (true){
Prof. Luis Zurita Microcontroladores II
24. if (input(PIN_A0)==1){
output_high(PIN_C0); IUT Cumaná
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);
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
25. Sin presionar el pulsador IUT Cumaná
Prof. Luis Zurita Microcontroladores II
26. Al presionar el pulsador IUT Cumaná
Prof. Luis Zurita Microcontroladores II
27. Teclado Matricial IUT Cumaná
• 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
ejemplo 3x4 significa 3 columnas por 4 filas, para un
total de 12 teclas.
Prof. Luis Zurita Microcontroladores II
28. Teclado Matricial IUT Cumaná
• Esta es una conexión típica entre un teclado y un
microcontrolador:
Prof. Luis Zurita Microcontroladores II
29. Teclado Matricial IUT Cumaná
• 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.
• Los microcontroladores PICs han dispuesto de una
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.
Prof. Luis Zurita Microcontroladores II
30. Teclado Matricial con lenguaje C IUT Cumaná
• 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.
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.
Prof. Luis Zurita Microcontroladores II
31. Teclado Matricial con lenguaje C IUT Cumaná
• 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 carátulas del
teclado.
Prof. Luis Zurita Microcontroladores II
32. Teclado Matricial con lenguaje C IUT Cumaná
• 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
33. Teclado Matricial con lenguaje C IUT Cumaná
• Las conexiones vienen dadas en el fichero y se
pueden modificar:
Fichero KBD.c
Prof. Luis Zurita Microcontroladores II
34. Teclado Matricial con lenguaje C IUT Cumaná
• Se puede trabajar con la pantalla LCD y el teclado a
través de puertos separados.
Prof. Luis Zurita Microcontroladores II
35. Ejercicio 1 de Teclado y LCD. IUT Cumaná
• 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
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.
Prof. Luis Zurita Microcontroladores II
36. Ejercicio 1 de Teclado y LCD. IUT Cumaná
#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
//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
Prof. Luis Zurita Microcontroladores II
37. Ejercicio 1 de Teclado y LCD. Continuación. IUT Cumaná
void main() {
char k; // Se declara k como un dato tipo char o carácter
int x;
lcd_init();
kbd_init();
port_b_pullups(TRUE);
lcd_putc("fPRESIONE TECLAn"); // Mensaje inicial antes de entrar en bucle
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(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
38. Ejercicio 2 de Teclado y LCD. IUT Cumaná
• 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
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”
Prof. Luis Zurita Microcontroladores II
39. Ejercicio 2 de Teclado y LCD. IUT Cumaná
#include <16f877a.h>
#use delay (CLOCK = 4000000)
#fuses XT,NOWDT,NOPROTECT,NOLVP
#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 <kbd.c>
void main() {
set_tris_c(0x00);
char k;
int x;
lcd_init();
kbd_init();
port_b_pullups(TRUE);
printf(lcd_putc,"fPRESIONE FUNCION");
OUTPUT_C(0x00);
Prof. Luis Zurita Microcontroladores II
40. Ejercicio 2 de Teclado y LCD. IUT Cumaná
while (TRUE) { delay_ms(500);
k=kbd_getc(); OUTPUT_C(0x03);
x=k-48; delay_ms(500);
if (k!=0) { OUTPUT_C(0x07);
if (x==1) delay_ms(500);
{OUTPUT_C(0x01); OUTPUT_C(0x0f);
printf(lcd_putc,"fFUNCION 1");} delay_ms(500);
else if (x==3) OUTPUT_C(0x07);
{OUTPUT_C(0x02); delay_ms(500);
printf(lcd_putc,"fFUNCION 2");} OUTPUT_C(0x03);
else if (x==5) delay_ms(500);
{OUTPUT_C(0x04); OUTPUT_C(0x01);
printf(lcd_putc,"fFUNCION 3");} delay_ms(500);
else if (x==8) OUTPUT_C(0x00);
{OUTPUT_C(0x08); delay_ms(500);
printf(lcd_putc,"fFUNCION 4");} }
else } Nota: También
{printf(lcd_putc,"fTODOS OFF"); }
aplica la estructura
OUTPUT_C(0x01); }
case
Prof. Luis Zurita Microcontroladores II
41. Ejercicio 2 de Teclado y LCD. Al iniciar IUT Cumaná
Prof. Luis Zurita Microcontroladores II
42. Ejercicio 2 de Teclado y LCD. Función 1 IUT Cumaná
Prof. Luis Zurita Microcontroladores II
43. Ejercicio 2 de Teclado y LCD. Función 2 IUT Cumaná
Prof. Luis Zurita Microcontroladores II
44. Ejercicio 2 de Teclado y LCD. Función 3 IUT Cumaná
Prof. Luis Zurita Microcontroladores II
45. Ejercicio 2 de Teclado y LCD. Función 4 IUT Cumaná
Prof. Luis Zurita Microcontroladores II
46. Ejercicio 2 de Teclado y LCD. Función “TODOS OFF” IUT Cumaná
Prof. Luis Zurita Microcontroladores II
47. Ejercicio 2 de Teclado y LCD. Función “TODOS OFF” IUT Cumaná
Prof. Luis Zurita Microcontroladores II
48. Manejo de la EEPROM de un Microcontrolador IUT Cumaná
• 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:
EEPROM Data PIC16F873 PIC16F874 PIC16F876 PIC16F877
Memory 128 128 256 256
• 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.
Prof. Luis Zurita Microcontroladores II
49. EEPROM con lenguaje C IUT Cumaná
• 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:
read_eeprom( )
Sintáxis: valor= read_eeprom(address,[N]) ó
valor= read_eeprom(address,variable) ó
valor=read_eeprom(address,pointer,N)
Prof. Luis Zurita Microcontroladores II
50. EEPROM con lenguaje C IUT Cumaná
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
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)
Prof. Luis Zurita Microcontroladores II
51. EEPROM con lenguaje C IUT Cumaná
• 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.
• 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);
Prof. Luis Zurita Microcontroladores II
52. EEPROM con lenguaje C IUT Cumaná
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 :
• 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.
Prof. Luis Zurita Microcontroladores II
53. Ejercicio 1 con la EEPROM IUT Cumaná
• 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”.
#include <16f877a.h>
#use delay (CLOCK = 4000000)
#fuses XT,NOWDT,NOPROTECT,NOLVP
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
}
}
Prof. Luis Zurita Microcontroladores II
54. Ejercicio 1 con la EEPROM. IUT Cumaná
Antes de ejecutarse la escritura.
Posición 23 de
la EEPROM sin
valor grabado
Prof. Luis Zurita Microcontroladores II
55. Ejercicio 1 con la EEPROM. IUT Cumaná
Luego de ejecutarse la escritura.
Posición 23 de
la EEPROM con
valor grabado
Prof. Luis Zurita Microcontroladores II
56. Ejercicio 1 con la EEPROM. IUT Cumaná
Luego de ejecutarse la lectura.
Registro “copia” con el
valor leído de la EEPROM
Prof. Luis Zurita Microcontroladores II
57. Ejercicio 2 con la EEPROM, TECLADO Y LCD IUT Cumaná
• 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
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.
Prof. Luis Zurita Microcontroladores II
58. Ejercicio 2 con la EEPROM, TECLADO Y LCD IUT Cumaná
#include <16f877a.h> // respectivamente
#use delay (CLOCK = 4000000)
#fuses XT,NOWDT,NOPROTECT,NOLVP void main() {
#use standard_io(a) char k;
#use standard_io(b) int i;
#use standard_io(d) char data[4], clave[4];
#use fast_io(c) //Matrices para guardar clave y datos
#define use_portb_kbd TRUE
#define use_portd_lcd TRUE lcd_init();
#include <lcd.c> kbd_init();
#include <kbd.c> port_b_pullups(TRUE);
#include <stdlib.h> output_low(PIN_A0);
#rom 0x2100={'2','0','1','1'} output_low(PIN_A2);
//Posición 0,1,2 y 3 de la EEPROM //Led verde=off
//Con los datos 2,0,1, y 1 output_high(PIN_A1);
Prof. Luis Zurita //Led rojo=on Microcontroladores II
59. Ejercicio 2 con la EEPROM, TECLADO Y LCD IUT Cumaná
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
{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);}
Prof. Luis Zurita Microcontroladores II
60. Ejercicio 2 con la EEPROM, TECLADO Y LCD IUT Cumaná
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);
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);
}
}
Prof. Luis Zurita Microcontroladores II
61. Ejercicio 2 con la EEPROM, TECLADO Y LCD IUT Cumaná
Luego de presionar una clave errada
Prof. Luis Zurita Microcontroladores II
62. Ejercicio 2 con la EEPROM, TECLADO Y LCD IUT Cumaná
Luego de presionar la clave correcta
Prof. Luis Zurita Microcontroladores II