Teclado Matricial PIC C Compiler

En el compilador hay un driver para manejar un teclado telefónico, que es de gran utilidad
en algunas aplicaciones donde el usuario necesita digitar un número.

Los pasos que se deben seguir para manejar un teclado telefónico son:

Teclado Matricial 4×3

1. Incluir en el encabezado el driver para manejar el teclado telefónico:
#INCLUDE<KBD.C>

2. Por defecto el teclado se conecta al puerto D, como el microcontrolador que se usa no tiene

puerto D se conecta al puerto B y se debe añadir al encabezado la siguiente línea:
#DEFINE USE_PORTB_KBD
3. En el programa principal habilitar las resistencias pullup del puerto B, con esto simplemente
se habilitan internamente unas resistencias del puerto B a +V.
PORT_B_PULLUPS(TRUE);

4. Inicializar el driver del teclado en el programa principal.

KBD_INIT()

5. Llamar la función del teclado y almacenar el valor digitado en una variable tipo carácter. Si
no se oprime ninguna tecla el teclado retorna el carácter nulo.
K=KBD_GETC(); // K debe ser una variable tipo caracter (char)

NOTA: Si se utiliza otro microcontrolador y se conecta el teclado telefónico al puerto D se
debe poner resistencias a +5V en RD1, RD2, RD3 y RD4.
Realizar un programa que muestre en un display 7 segmentos los números presionados en un
teclado matricial de 4×3.

#INCLUDE <16F887.H>

#FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP

#USE DELAY(CLOCK=4000000)

Byte CONST display[10]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67};

#DEFINE USE_PORTB_KBD

#INCLUDE <KBD.C>

#BYTE PORTC= 7

#BYTE PORTB= 6

#BYTE WPUB= 0X95 // declarar registro option

#BYTE OPTION_REG = 0X81

CHAR K;
VOID MAIN()

//PORT_B_PULLUPS(TRUE);

OPTION_REG = 0; //en el MAIN desactivas el registro OPTION

WPUB= 0B11111111;// y seleccionas los pullups q vas a utilizar

KBD_INIT(); //Inicializar la rutina del teclado

SET_TRIS_C(0X00); //Configurar el puerto C como salida

PORTC=(display[0]);//Muestre en el display el número cero

WHILE (TRUE)

K=0; //Ponga la variable K en cero

K=KBD_GETC(); //Captura cualquier tecla oprimida

IF(K=='0') //Si la tecla que se oprime es igual al caracter cero

PORTC=(display[0]);//Muestre en el display el número cero

IF(K=='1') //Si la tecla que se oprime es igual al caracter uno

PORTC=( display [1]);//Muestre en el display el número uno

IF(K=='2') //Tecla que se oprime = al caracter dos

PORTC=( display [2]); //Muestre en el display el número dos

IF(K=='3') // Tecla que se oprime = al caracter tres

PORTC=( display [3]);//Muestre en el display el número tres

IF(K=='4') // Tecla que se oprime = caracter cuatro

PORTC=( display [4]);//Muestre en el display el número cuatro

 IF(K=='5') // Tecla que se oprime = caracter cinco

PORTC=( display [5]);//Muestre en el display el número cinco

IF(K=='6') // Tecla que se oprime = caracter //seis

PORTC=( display [6]);//Muestre en el display el número seis

IF(K=='7') // Tecla que se oprime = caracter

//siete

PORTC=( display [7]);//Muestre en el display el número siete

IF(K=='8') // Tecla que se oprime = caracter

//ocho

PORTC=( display [8]);//Muestre en el display el número ocho

IF(K=='9') // Tecla que se oprime = caracter

//nueve

PORTC=( display [9]);//Muestre en el display el número nueve

TECLADO MATRICIAL (KEYPAD 4x4)

Utilizados en el desarrollo de proyectos con microcontroladores PIC y que tienen su aplicación en el ingreso
de datos de manera manual por parte del usuario, en aquellos casos en que el empleo de pulsadores simples
no es lo más apropiado, ya sea por la presentación final del producto o por la restricción del número de líneas
de entrada de los microcontroladores PIC.

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 intención de reducir el número de pines necesarios para su conexión. Las 16 teclas
necesitan sólo 8 pines del microcontrolador, en lugar de los 16 pines que se requerirían para la conexión de
16 teclas independientes.
LIBRERIA A USAR

El compilador C incluye la librería KBD.c para manejar el teclado 3x4. las funciones que se incorporan son las
siguientes:

Kbd.init();   inicializa el sistema debe ser la primera función a ser llamada

Kbd_getc();  devuelve el valor de la tecla pulsada en función a la tabla que se tiene programada.

En el caso que se quiera utilizar un teclado matricial de 4x4, se tendrá que modificar la librería KBD.c e
incluirse en la carpeta drivers del CCS compiler

///////////////////////////////////////////////////////////////////////////
//// KBD4x4.C ////
//// Generic keypad scan driver ////
//// ////
//// kbd_init() Must be called before any other function. ////
//// ////
//// c = kbd_getc(c) Will return a key value if pressed or /0 if not ////
//// This function should be called frequently so as ////
//// not to miss a key press. ////
//// ////
///////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2003 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS C ////
//// compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, reproduction ////
//// or distribution is permitted without written permission. ////
//// Derivative programs created using this software in object code ////
//// form are not restricted in any way. ////
///////////////////////////////////////////////////////////////////////////

////////////////// The following defines the keypad layout on port D

// Un-comment the following define to use port B

// #define use_portb_kbd TRUE

// Make sure the port used has pull-up resistors (or the LCD) on
// the column pins

#if defined(__PCH__)
#if defined use_portb_kbd
#byte kbd = 0xF81 // This puts the entire structure
#else
#byte kbd = 0xF83 // This puts the entire structure
#endif
#else
#if defined use_portb_kbd
#byte kbd = 6 // on to port B (at address 6)
#else
 #byte kbd = 8 // on to port D (at address 8)
#endif
#endif

#if defined use_portb_kbd

#define set_tris_kbd(x) set_tris_b(x)
#else
#define set_tris_kbd(x) set_tris_d(x)
#endif

//Keypad connection: (for example column 0 is B2)

// Bx:

#ifdef blue_keypad ///////////////////////////////////// For the blue keypad

#define COL0 (1 << 2)
#define COL1 (1 << 3)
#define COL2 (1 << 6)

#define ROW0 (1 << 4)

#define ROW1 (1 << 7)
#define ROW2 (1 << 1)
#define ROW3 (1 << 5)

#else ////////////////////////////////////////////////// For the black keypad

#define COL0 (1 << 4)
#define COL1 (1 << 5)
#define COL2 (1 << 6)
#define COL3 (1 << 7)

#define ROW0 (1 << 0)

#define ROW1 (1 << 1)
#define ROW2 (1 << 2)
#define ROW3 (1 << 3)

#endif

#define ALL_ROWS (ROW0|ROW1|ROW2|ROW3)

#define ALL_PINS (ALL_ROWS|COL0|COL1|COL2|COL3)

// Keypad layout:
char const KEYS[4][4] = {{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}};

#define KBD_DEBOUNCE_FACTOR 33 // Set this number to apx n/333 where

// n is the number of times you expect
// to call kbd_getc each second

void kbd_init() {
}

char kbd_getc( ) {
static BYTE kbd_call_count;
static int1 kbd_down;
static char last_key;
static BYTE col;

BYTE kchar;
 BYTE row;

kchar='\0';
if(++kbd_call_count>KBD_DEBOUNCE_FACTOR) {
switch (col) {
case 0 : set_tris_kbd(ALL_PINS&~COL0);
kbd=~COL0&ALL_PINS;
break;
case 1 : set_tris_kbd(ALL_PINS&~COL1);
kbd=~COL1&ALL_PINS;
break;
case 2 : set_tris_kbd(ALL_PINS&~COL2);
kbd=~COL2&ALL_PINS;
break;
case 3 : set_tris_kbd(ALL_PINS&~COL3);
kbd=~COL3&ALL_PINS;
break;
}

if(kbd_down) {
if((kbd & (ALL_ROWS))==(ALL_ROWS)) {
kbd_down=FALSE;
kchar=last_key;
last_key='\0';
}
} else {
if((kbd & (ALL_ROWS))!=(ALL_ROWS)) {
if((kbd & ROW0)==0)
row=0;
else if((kbd & ROW1)==0)
row=1;
else if((kbd & ROW2)==0)
row=2;
else if((kbd & ROW3)==0)
row=3;
last_key =KEYS[row][col];
kbd_down = TRUE;
} else {
++col;
if(col==4)
col=0;
}
}
kbd_call_count=0;
}
set_tris_kbd(ALL_PINS);
return(kchar);
}

Resistencias PULL UP o PULL DOWN

Lo primero que hay que decir es que no son unas resistencias especiales, se tratan de resistencias
normales pero que están dispuestas en un circuito de una manera determinada. Dependiendo de
la configuración se determinará si la resistencia es pull up o pull down. Como funcionalidad
básica, estas resistencias establecen un estado lógico en un pin o entrada de un circuito lógico
cuando se encuentra en estado reposo. Como bien indica su nombre la resistencia pull up
establece un estado HIGH y las resistencias pull down establecen un estado LOW cuando el pin se
encuentra en reposo. Esto evita los falsos estados que se producen por el ruido generado por los
circuitos electrónicos.

Funcionamiento

Resistencia pull down

En la configuración pull down, cuando el circuito está en reposo como se muestra en la imagen de

arriba, la caída de tensión en  la resistencia es prácticamente 0V (LOW), en cambio si pulsamos P1,
dejará pasar la corriente y tendremos una diferencia de potencial de 5V (HIGH). Este es el uso
normal del estado LOW y HIGH.

Resistencia pull up

Por el contrario, en la configuración pull up, cuando el circuito está en reposo, P1 sin pulsar, la
caída de tensión es de 5V (HIGH), en cambio cuando pulsamos P1 se deriva toda la corriente a
masa y la caída de tensión es 0V (LOW).

Normalmente las resistencias que se utilizan en estos casos son de 10K. Como hemos
comprobado, estas dos configuraciones nos evitarán que en estado de reposo midamos un valor
erróneo eliminando la influencia de factores externos sobre nuestras mediciones como el ruido
eléctrico.