TET523-CONTROL CON MICROS

INFORME N5
BUSES DE COMUNICACIN/ LECTURA DE PROCESAMIENTO DE DATOS
PARA PRESENTARLOS EN UN LCD/ CALCULADORA DIGITAL

AZAA TOAPANTA CRISTIAN ROBERTO

CAIZA TIPAN MARCO AURELIO
CARDENAS QUINAPAXI ANGEL FERNANDO
29 JUNIO 2015
RESUMEN:

La presente prctica desarrolla el diseo, ensamblaje y programacin de

un circuito

capaz de simular una calculadora numrica con las operaciones bsicas como son suma
resta multiplicacin y divisin

donde utilizaremos el puerto c

del pic 16f870 para

conectar un teclado numrico y en el prtico b nos servir para conectar un lcd para
mostrar resultados

ABSTRACT

Teclado Matricial con PIC

This practice develops the design, assembly and
programming a circuit able to of simulating a numerical
calculator with basic operations such as addition
subtraction multiplication and division where we use port c
of pic 16F870 to connect a numeric keypad on the porch
and we will por b for connecting a lcd next show results
I Marco

Terico

LCD

Un mtodo para

conectar un teclado matricial tipo

membrana a un microcontrolador. El mtodo que

proponemos permite conectar a nuestro microcontrolador
16 teclas usando solamente 8 pines. El cdigo debera
ser vlido para cualquier microcontrolador, incluso de
otras marcas, aunque siempre habr que revisarlo y
posiblemente realizar algunas adaptaciones si se migra a

El LCD(Liquid Crystal Dysplay) o pantalla de cristal

lquido es un dispositivo empleado para la visualizacin
de contenidos o informacin de una forma grfica,
mediante caracteres, smbolos o pequeos dibujos
dependiendo del modelo. Est gobernado por un
microcontrolador el cual dirige todo su funcionamiento.

otra plataforma, sin embargo, el algoritmo permanece

En este caso vamos a emplear un LCD de 16x2, esto

quiere decir que dispone de 2 filas de 16 caracteres cada
una. Los pxeles de cada smbolo o carcter, varan en
funcin de cada modelo.

que haramos para multiplexar leds o diplays de 7

igual con cualquier microcontrolador.

Cmo funciona un teclado matricial?

El principio de funcionamiento es sencillo y es similar a lo

segmentos. El programa configura el puerto B del PIC de

la siguiente forma: RB4 a RB7 funcionan como salidas
y la otra mitad (RB0-RB3) como entradas. Las filas
(horizontal) del teclado matricial se conectan a los bits
ms significativos que funcionan como salidas, mientras

TET523-CONTROL CON MICROS

que las columnas (vertical) se conectan a los bits menos
significativos del puerto que funcionan como entradas
con resistencias pull-down. Cualquier tecla que se oprima
en una columna causar que uno de los bits menos
significativos del puerto (RB0 RB3) cambie de un
estado lgico bajo a un estado alto.
La siguiente imagen muestra las conexiones del teclado
al puerto c del microcontrolador. La imagen muestra el
teclado en reposo (sin teclas oprimidas).

De esta manera el microcontrolador sabe que se ha

oprimido una tecla al detectar un cambio de nivel en
Qu pasa cuando se oprime una tecla en un teclado
matricial?
la corriente puede fluir a travs del switch y el voltaje de
los pines conectados a las filas del teclado (5 V o nivel
alto) aparece ahora tambin en alguno de los pines RB0
a RB3 segn la columna en la que se encuentra la tecla
oprimida. La siguiente imagen ilustra lo que sucede al
oprimir una tecla: al oprimir el botn 6 provocamos un
cambio en el PIN RB2 que ahora recibe un 1 o estado
alto. Sabemos entonces que se ha pulsado un botn en
la segunda columna y se muestra como un nivel lgico
alto aparece en los bits menos significativos del puerto B,
especficamente en RB2.

los bits menos significativos. Hasta el momento, se

sabe que se ha oprimido una tecla en alguna columna
(dependiendo del bit activo RB3 a RB0), sin embargo, no
sabemos en cual fila. Para resolver en que fila se oprimi
una tecla, hay que realizar un proceso de escaneo del
teclado. En este proceso, colocaremos en secuencia un
1 lgico (estado alto) en los 4 bits ms significativos del
puerto y leeremos el estado de los 4 bits menos
significativos. Sigamos con el ejemplo en el que se ha
oprimido la tecla 6 pero ahora vindolo grficamente en
una animacin:

TET523-CONTROL CON MICROS

pulsada, sino una cadena de bits que representan las
teclas, es posible detectar cuando se presiona ms de
una tecla de forma simultnea. El cdigo de esta
funcin es el siguiente

El microcontrolador escanea en forma sucesiva los pines

de salida, mientras lee las entradas en la parte baja del
puerto, de manera que puede detectar que teclas estn
oprimidas en cada fila. Ahora solo falta escribir nuestro
codigo en C que implemente los procedimientos
mencionados anteriormente y nos devuelva un valor de
la tecla oprimida, por ejemplo, mediante un nmero
binario.
Programa en C para teclado matricial
El programa es bastante sencillo e implementa todos los
procesos

que

describimos

en

la

teora

vista

anteriormente. El cdigo se ha mantenido simple

intencionalmente para que se pueda apreciar el
funcionamiento de la manera ms obvia posible. La
funcin keypad_read() es la encargada de realizar la
mayor parte de las tareas para determinar que tecla ha
sido pulsada. El valor que retorna es una palabra de 16
bits en la cual, cada uno de los bits representa una tecla,
en donde un bit en estado alto representa una tecla
oprimida. Como la funcin no retorna como tal la tecla

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

Procesa las entradas del teclado matricial y determina la tecla que

esta
siendo oprimida. Retorna una palabra binaria de 16 bits en la cual
los bits
que se encuentran en estado alto representan teclas oprimidas.
*
Esta funcin esta diseada para poder detectar cuando se oprimen
varias
teclas sin embargo, debido a limitantes de la forma de conexin
del teclado
matricial, no se deben esperar resultados correctos al oprimir
varias teclas
*
@return Retorna una palabra de 16 bits, cada bit representa una
tecla.
*/
uint16_t keypad_read()
{
unsigned char count = 0;
unsigned char bitmask = 0x10;
// Valor de retorno de la funcion keypad_read() entero de 16 bits
uint16_t keys =0;
// Revisamos si alguna de las lineas en la parte baja esta en estado
alto
// debido a que se ha cerrado un switch en el teclado.
if( PORTB & 0x0F )
{
// Escaneamos las filas una por una para
determinar la tecla oprimida
do
{
// Apagamos todas las filas
(parte alta)
PORTB &= 0x0F;
// Seleccionamos solo una como
salida (bit del registro tris = 0)
TRISB &= ~bitmask;
// Y colocamos el pin en estado
alto
PORTB |= bitmask;
// Esperamos unos cuantos
milisegundos y leemos las
columnas
delay_ms(100);
// Guardamos las columnas en
una variable de 16 bits
keys |= (PORTB & 0x0F);
// Si ya hemos leido 4 columnas,
las siguientes instrucciones no
son
// necesarias, por lo que salimos
del ciclo
if( count == 3 )
break;
// Recorremos la lectura a la
izquierda para hacer espacio

TET523-CONTROL CON MICROS

keys = keys<<4;
// Recorremos el bitmask de la
fila a leer
bitmask = bitmask<<1;
// Incrementar el contador de
filas
count ++;

48
49
50
51
52
53
54
55
56

} while(1);
// Mantenemos parte alta = salidas y parte
baja = entradas
TRISB = 0x0F;
// Mantenemos los bits mas significativos
del puerto en estado alto
PORTB = 0xF0;
return keys;
}
return 0;
}

Detalles de la implementacin

16x2-2x16-con-el-hd44780-en-mikroc-pro/. [ltimo
acceso: 15 06 2015].
[2] geekfactory, Teclado Matricial con PIC, 2010. [En
lnea]. Available:
http://www.geekfactory.mx/tutoriales/tutorialespic/teclado-matricial-con-pic/. [ltimo acceso: 28
06 2015].
[3] t. micko, Teclado matricial 4x4 con los
microcontroladores PIC, 2009. [En lnea].
Available:
http://programarpicenc.com/articulos/tecladomatricial-4x4-con-los-microcontroladores-pic/.
[ltimo acceso: 28 junio 2015].

En nuestra implementacin del hardware, todos los pines

tienen conectada una resistencia pull-down, por lo que
se mantienen en estado bajo (0) cuandoel teclado esta
en reposo. Cuando se presiona un botn, el estado del
pin cambia a estado alto (1). Esto puede hacerse de

CIRCUITOS IMPLEMENTADOS

manera inversa, utilizando las resistencias pull-up

incluidas internamente en el puerto B de muchos PIC que
estn diseadas para este tipo de aplicaciones. En
nuestro caso, la tarjeta que utilizamos tiene resistencias
pull-down previamente conectadas en los pines, por lo
que decidimos aprovecharlas.
Es un buen ejercicio invertir la lgica del cdigo para
permitir que este funcione con resistencias pull-up, por
lo que te recomendamos que realices al menos este

Bibliografa
Simulacin proteus

[1] tecmicko, Display LCD 16x2 (2x16) con el HD44780

en mikroC PRO, tecmocko, 2009-2915. [En lnea].
Available:
http://programarpicenc.com/articulos/display-lcd-

ANALISIS DE RESULTADOS
Para el funcionamiento de la calculadora realizamos la
implementacin del circuito de la figura; el cual consta de
un visualizador y un dispositivo de entrada de datos los
cuales en conjunto con el PIC16F870 y algunas funciones

TET523-CONTROL CON MICROS

nos presentan el funcionamiento de una calculadora con
sus operaciones bsicas.
Es necesario crear variables enteras (int) para
almacenar las unidades, decenas y centenas.
Es necesario tambin crear variables tipo carcter
(char) para representar el texto en su funcionamiento y
una variable bit para almacenar el bit en la memoria del
lcd e introducir el siguiente valor de la cifra a calcular.
Al igual que el LCD, el teclado tambin necesita
variables y sentencias de inicializacin para realizar su
funcionamiento.

CUESTIONARIO
1.

Para el funcionamiento del LCD hay que escribir las

variables de inicializacin con su respectivos pines y
sentencias.
El funcionamiento de la aplicacin de una calculadora
es representado con la funcin SWITCH con sus
respectivos casos.

Escriba las variables de inicializacin para el

teclado.
kp = Keypad_Key_Press();
kp = Keypad_Key_Click();
Keypad_Init();
2.

Ingrese primer nmero.

Ingrese operacin.
Ingrese segundo nmero.
Ingrese igual.

Para representar las operaciones a realizar es

necesario colocar el cdigo ASCII de los respectivos
smbolos.

Suma +.
Resta -.
Multiplicacin *.
Divisin /.
Igual =.

Describa el funcionamiento de la funcin SWITCH

en MIkRO C.

La sentencia switch() en Lenguaje C es una sentencia de

seleccin. Esta sentencia permite seleccionar las acciones
a realizar de acuerdo al valor que tome una variable.
Si el valor que toma la variable no coincide con los valores
especificados en los casos, se realizarn las acciones
definidas en la etiqueta default.
3.

De que esta compuesto el KEYPAD usado en la

prctica.

El teclado matricial 4x4 est constituido por una matriz de

pulsadores dispuestos en filas (A,B,C,D) y columnas
(1,2,3,4), con la intencin de reducir el nmero de pines
necesarios para su conexin. Las 16 teclas necesitan slo 8
pines del microcontrolador, en lugar de los 16 pines que se
requeriran para la conexin de 16 teclas independientes.

TET523-CONTROL CON MICROS

CONCLUSIONES Y RECOMENDACIONES
Al almacenar las cifras a ser operadas en la
calculadora es necesario crear variables para cada cifra a
ser introducida en el programa.
El cdigo ASCII nos es de gran ayuda para realizar la
correcta codificacin de los nmeros y caracteres a ser
usados en la programacin del circuito
Para que el nmero o el carcter aparezcan en el lcd
es necesario cambiar al cdigo del lcd, esto se logra con
la funcin:

Tener a la mano el datasheet del PIC a utilizar para

ubicar correctamente los bits de los diferentes registros a
utilizarse en el funcionamiento del programa.
Utilizar el icono de AYUDA presente en MICROC para
solucionar las diferentes incgnitas que surgen durante la
programacin.
Conectar los pines del PIC a su respectivo dispositivo
electrnico adicional para observar el correcto
funcionamiento de nuestro circuito implementado.

BIBLIOGRAFIA

El teclado es un dispositivo de entrada, el mismo que

nos sirve para introducir los diferentes datos necesarios
para realizar algn propsito en comn.
Una interrupcin consiste en un mecanismo por el cual
un evento interno o externo puede interrumpir la ejecucin
del programa en cualquier momento.

PIC16F870 Datasheet.
Apuntes de clase CONTROL CON MICROPROCESADORES.
Ayuda de MIKROC.

TET523-CONTROL CON MICROS

ANEXOS

TET523-CONTROL CON MICROS

Programacin en micko c
//CALCULADORA COMPLETA
unsigned short kp, cnt, oldstate = 0;
char txt[3];
// sacar datos lcd
int uni,dec,cent,oper;
//variables para almacenar el primer #
int uni2,dec2,cent2;
//variables para almacenar el segundo #
char struni[7], strdec[7], strcent[7],strnum[2]; //variables tipo char
char struni2[7], strdec2[7], strcent2[7], strresultado[7]; //variables tipo char de 7 valores
bit primero;
int num, num2;
//variables para guaradar uni,dec,cent uni2,dec2,cent2
int resultado;
//variable para guardar resultado
// Keypad module connections
char keypadPort at PORTC;
// End Keypad module connections
// LCD module connections
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D4 at RB0_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// End LCD module connections
void main() {
cnt = 0;
// Reset counter
Keypad_Init();
// Initialize Keypad
primero=1;
//asignamos valor de inicializacion de primero
Lcd_Init();
// Initialize LCD
Lcd_Cmd(_LCD_CLEAR);
// Clear display
Lcd_Cmd(_LCD_CURSOR_OFF);
// Cursor off
Lcd_Out(1, 6, "CALC");
ByteToStr(uni, txt); //Conversin de entero a texto.
Lcd_Out(2,13,txt); //Visualizacin del valor retornado por el teclado.
do {
kp = 0;

//haga una vez y luego compare

// Reset key code variable variable va a recibir lo del taclado

// Wait for key to be pressed and released

do
// kp = Keypad_Key_Press();
// Store key code in kp variable
kp = Keypad_Key_Click();
// Store key code in kp variable
while (!kp);

//cuando sae diferente de cero sale funcion

TET523-CONTROL CON MICROS

// Prepare value for output, transform key to it's ASCII value
switch (kp) {
case 1: kp = 1; break; // 1
// Uncomment this block for keypad4x4
case 2: kp = 2; break; // 2
case 3: kp = 3; break; // 3
case 4: kp = 10; break; // /
case 5: kp = 4; break; // 4
case 6: kp = 5; break; // 5
case 7: kp = 6; break; // 6
case 8: kp = 11; break; // X
case 9: kp = 7; break; // 7
case 10: kp = 8; break; // 8
case 11: kp = 9; break; // 9
case 12: kp = 12; break; // case 13: kp = 15; break; // ON/C
case 14: kp = 0; break; // 0
case 15: kp = 14; break; // =
case 16: kp = 13; break; // +
}
if(primero==1 && kp<10) {
//ingresamos el primer # y vrfificamod que sea un numero menor que 10
Lcd_Cmd(_LCD_CLEAR);
cent=dec;
//para no perder la variable dec
dec=uni;
//para no perder la variable uni
uni=kp;
//lo de kp 1,2,3 se asigan a la varible uni
Inttostr(uni,struni);
Lcd_Out(1, 3, struni);

//trasformar de entero a tipo char para lcd

// Display counter value on LCD

if (dec!=0 || (cent!=0) &&( dec==0)) {

Inttostr(dec,strdec) ; //trasformar de entero a tipo char para lcd
Lcd_Out(1, 2,strdec); // Display counter value on LCD
}
if(cent!=0){
Inttostr(cent,strcent);
Lcd_Out(1,1,strcent);
}
}
if(primero==0 && kp<10) {
cent2=dec2;
dec2=uni2;
uni2=kp;

//ingresamos el segundo # y vrfificamod que sea un numero menor que 10

//para no perder la variable dec

//para no perder la variable uni
//lo de kp 1,2,3 se asigan a la varible uni
Inttostr(uni2,struni2);
Lcd_Out(1, 11, struni2);

//trasformar de entero a tipo char para lcd

// Display counter value on LCD

TET523-CONTROL CON MICROS

if (dec2!=0 || (cent2!=0) &&( dec2==0)) {

Inttostr(dec2,strdec2) ; //trasformar de entero a tipo char para lcd
Lcd_Out(1, 10,strdec2); // Display counter value on LCD
}
if(cent2!=0){
Inttostr(cent2,strcent2);
Lcd_Out(1,9,strcent2);
}
}
//operaciones
if(kp==10 ){ //para que ingrese cuando son mayores de 10
oper=kp;
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,8,"-");
primero=0 ;
kp=0;
}

//asdigna kp en variable operacion

//asignando 0 a la variable primero

if( kp==11 ){ //para que ingrese cuando son mayores de 10

oper=kp;
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,8,"x");
primero=0 ;
kp=0;
}

//asdigna kp en variable operacion

//asignando 0 a la variable primero

if( kp==12 ){ //para que ingrese cuando son mayores de 10

oper=kp;
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,8,"/");
primero=0 ;
kp=0;
}

//asdigna kp en variable operacion

//asignando 0 a la variable primero

if(kp==13 ){ //para que ingrese cuando son mayores de 10

oper=kp;
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,8,"+");
primero=0 ;
kp=0;
}

//asdigna kp en variable operacion

//asignando 0 a la variable primero

TET523-CONTROL CON MICROS

if(kp==14){
//acceso a variable =
num=100*cent+10*dec+uni;
num2=100*cent2+10*dec2+uni2;
switch (oper) {
case
case
case
case

10: resultado=num-num2 ;break; // 11: resultado=num*num2; break; // X

12: resultado=num/num2; break; // /
13: resultado=num+num2; break; // +

}
WordToStr(num,strnum) ; //trasformar de entero a tipo char para lcd
Lcd_Out(1, 1,(strnum)); // Display counter value on LCD
/*Inttostr(num2,strnum2) ; //trasformar de entero a tipo char para lcd
Lcd_Out(1, 11,strnum2); // Display counter value on LCD
*/
Inttostr(resultado,strresultado) ; //trasformar de entero a tipo char para lcd
Lcd_Out(2, 8,strresultado); // Display counter value on LCD
Lcd_Out(2, 6,"=") ;
}
if(kp==15){
cent=0;
dec=0;
uni=0;
cent2=0;
dec2=0;
uni2=0;
primero=1;
Lcd_Cmd(_LCD_CLEAR);
ByteToStr(uni, txt); //Conversin de entero a texto.
Lcd_Out(2,13,txt); //Visualizacin del valor retornado por el teclado.
}
} while (1);
}