MANEJO DE PERIFERICOS PARA MICROCONTROLADORES EN C

IUT Cumaná

MICROCONTROLADORES II
MANEJO DE PERIFÉRICOS
(DISPLAYS, LCD , TECLADO Y EEPROM)

PROF. LUIS ZURITA

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


• 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.


• 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


• 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.

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);}


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();
}
}
}
}


Programa simulado en Proteus IUT Cumaná


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.



• 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


• 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)


• 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).


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.



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).


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…)



• 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.



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.


• 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 (“%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:

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:
#define LCD_DATA_PORT getenv("SFR:PORTC")
#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.
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.


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){


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

Sin presionar el pulsador IUT Cumaná


Al presionar el pulsador IUT Cumaná


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.



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



• 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.


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.



• 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.



• 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.


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.



#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


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


• 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”



#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);


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

Ejercicio 2 de Teclado y LCD. Al iniciar IUT Cumaná


Ejercicio 2 de Teclado y LCD. Función 1 IUT Cumaná


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


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.


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)



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)


• 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);



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.

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”.

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. IUT Cumaná

Antes de ejecutarse la escritura.

Posición 23 de
la EEPROM sin
valor grabado



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


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.



#include <16f877a.h> // respectivamente
#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


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);}



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);
}
}



Luego de presionar una clave errada



Luego de presionar la clave correcta


MANEJO DE PERIFERICOS PARA MICROCONTROLADORES EN C

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a MANEJO DE PERIFERICOS PARA MICROCONTROLADORES EN C (20)

Más de Luis Zurita (20)

Último (20)

MANEJO DE PERIFERICOS PARA MICROCONTROLADORES EN C