TODOPIC

Microcontroladores PIC => Todo en microcontroladores PIC => Mensaje iniciado por: RedPic en 10 de Octubre de 2007, 16:34:39

Título: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 10 de Octubre de 2007, 16:34:39
Objetivo: Leer un teclado matricial de 4 x 4 teclas mediante un único pin del PIC.

Conceptos involucrados: Suma de resistencias en serie, divisor de tensión y conversión Analógico-Digital del PIC.

Necesitamos: Un teclado matricial de 4 x 4 teclas, 9 resistencias y un PIC.

Antecedentes: En el documento "Hardware Techniques for PICmicro Microcontrollers" AN234 (http://ww1.microchip.com/downloads/en/AppNotes/00234a.pdf) de Microchip se describe someramente lo que vamos a intenta realizar. De ahí he sacado la idea y a continuación os describiré lo que he desarrollado a partir de ella.

Desarrollo: Como todos sabéis, y si no lo sabéis este es un buen momento para aprenderlo, un teclado matricial 4 x 4 es un artilugio compuesto por 4 x 4 teclas con 4 + 4 lineas que conectan entre si las teclas, una linea por cada fila de teclas mas una linea por cada columna de teclas. Al ser pulsada una cualquiera de ellas une entre sí una de las lineas, la de su columna, con otra de ellas, la de su fila. Así al pulsar una tecla quedan unidas solo dos de las ocho que tiene.

Tradicionalmente se ha conectado un teclado de estos a un PIC usando 8 pines de éste, 4 para las filas y 4 para las columnas y se leían poniendo en alto las filas, o las columnas, y leyendo las columnas, o las filas, para detectar qué tecla se había pulsado. Esta técnica es muy fácil de implementar pero tiene el costo de usar muchos pines del PIC.

Lo que aquí vamos a desarrollar es la idea de poder hacer esto mismo pero haciendo uso de un solo pin del PIC, pero que tenga la especial función de Conversor Analógico a Digital. Para ello tenemos que conseguir que al pulsar cada una de las teclas obtengamos un voltaje distinto en una única línea. Leyendo este voltaje con el Conversor AD del PIC podemos llegar a saber qué tecla es la que se ha pulsado.

Una imagen vale mas que mil palabras:

(http://picmania.garcia-cuervo.net/images/trucos_switches_3.jpg)

Como veis en ella cada círculo en la rejilla central del teclado del dibujo representa una de las teclas, que al pulsar une una de las resistencias de R1 a R4 conectadas a VDD con otra de R5 a R8 conectadas al PIC. Así si pulsamos en la tecla situada en la esquina superior izquierda tendremos que VDD le llega al PIC tras atravesar R1+R5. Si por el contrario pulsamos la tecla inferior derecha la corriente nos llegará a través de la unión entre R4+R8. Siempre que pulsemos una tecla cualquiera obtendremos un voltaje de caída entre la suma de dos resistencias Rcolumna+Rfila

Otro detalle a tener en cuenta es que si no pulsamos ninguna tecla nuestro pin del PIC estaría conectado a nada, la linea que une el pic con las resistencias R5 a R8 y tras ella el vacío. Esto podría, y sería con total seguridad, una verdadera antena que recogería todo lo que pasase cerca de allí, dándonos todo tipo de lecturas falsas mientras no pulsásemos ninguna tecla. Para evitar ese efecto colocamos R9 que mantendrá el pin del conversor conectado a GND mientras nos pulsemos nada sobre el teclado.

Pero esta configuración es lo que conocemos como un Divisor de Tensión (http://picmania.garcia-cuervo.net/electronica_basica_divisor_tension.php) en la que tenemos una resistencia conectada a VDD y otra a GND y nosotros tomamos el valor del voltaje en la unión que hay entre ellas.

(http://picmania.garcia-cuervo.net/images/vdiv1.gif)

Este divisor de tensión en el que tenemos un Vin o voltaje de entrada y un Vout o voltaje de salida tras él, que es perfectamente calculable mediante la fórmula que aparece a la derecha.
 
Como vemos en esta configuración lo que llamamos aquí Rtop es lo que en nuestro teclado hemos llamado Rcolumna+Rfila o sea la suma de las dos resistencias correspondientes al pulsar una tecla en él. Y Rbottom es nuestra R9 del teclado.

La gran falta del documento de Microchip es que no nos aporta ni valores de R1 a R9, ni comportamiento aproximado de cómo podríamos elegir dichos valores. Pero con lo que hemos visto hasta aquí estamos en condiciones de poder calcular con bastante precisión el comportamiento de nuestro circuito, sabiendo que Rtop es Rc+Rf y que VDD es 5V podemos concluir que Vout = R9 / R9+Rc+Rf * 5V y así tendremos un valor de Vout para cada pareja de resistencias Rc+Rf.

Con esta información me he construido una tabla Excel en la que he puesto primero la tabla de resistencias de columnas y filas y las distintas sumas de cada una de ellas. Despues otra con los distintos voltajes que se generan en el divisor de tensión con cada una de las parejas anteriores. Y por último otra tabla en la que hago corresponder cada uno de estos voltajes con el valor de la conversión AD del PIC con precisión de 10 bits (1024 -> 5V lo que Vout es a X)

Jugando con las combinaciones entre valores de unas y otras resistencias he llegado a obtener uno valores que veo correctos.

Los resultados:

(http://picmania.garcia-cuervo.net/images/trucos_switches_3t.jpg)
Nota1

Como podéis ver tenemos abajo los valores que vamos a obtener en la conversión AD para cada tecla pulsada. Son valores razonablemente separados unos de otros y que nos pueden permitir leer nuestro teclado con un único pin del PIC (con AD) que es lo que queríamos hacer.

Conclusión: R1=0, R2=470R, R3=1K, R4=2K2, R5=220R, R6=330R, R7=470R, R8=560R y R9=1K2 con VDD a 5V Nota2. Y con esto completamos el documento de Microchip poniéndole valores a lo propuesto por los amables señores de nuestro proveedor favorito.   :mrgreen:

Ea, mañana más.

Nota1 Teclado_Resistivo_CAD.xls (http://picmania.garcia-cuervo.net/recursos/teclado_resistivo_cad.xls)
Nota2 Todas las resistencias son Comerciales (http://picmania.garcia-cuervo.net/resistencias.php)
 
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: beatAurex1 en 10 de Octubre de 2007, 18:15:04
Felicidadesss..Super tu articulo es ser un picmaniaco
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Leon Pic en 10 de Octubre de 2007, 18:27:01
Felicitaciones RedPic. Está espectacular tu artículo. Nos ahorraste 7 pines, y lo mejor, es que se puede llegar a ampliar sin necesidad de gastar otros pines.

Saludos.  :-/ :-/
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: aitopes en 10 de Octubre de 2007, 19:45:57
Buenisimo Diego!!!

Me late que voy a aprender a usar el ADC en CCS.....en breve, gracias a este ejemplo :)

Un abrazo.  :mrgreen:
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Cryn en 11 de Octubre de 2007, 04:12:58
saludos, muy buen trabajo, felicitaciones, creo haber deducido algo asi para digamos solamente una columna del teclado, y he hecho los calculos para 4, 3 y 2 V y me han salido esos valores de resistencia; ahora cuando pruebo el circuito independientemente sale correctamente los valores de tensión, pero si lo llevo a la entrada analogica del microcontrolador (especificamente al RA0 del 16f877a) los valores de tension ya no son los que calcule (son casi cero varian entre 0.8 0.6 V), por que sucede eso, esto en cuanto a simulacion, no he probado fisicamente, ya que primero qeuiro simular, uso proteus 7.1 sp4.

aca mi diagrama, donde esta el multimetro va a la entrada RA0:

(http://img410.imageshack.us/img410/7617/imagxk5.jpg)

estan correctas mis resistencias, o que error tengo?
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Nocturno en 11 de Octubre de 2007, 04:25:45
¿Es que has soñado conmigo?  :lol:

Gestiona un teclado matricial con un sólo pin (http://www.micropic.es/index.php?option=com_content&task=view&id=56&Itemid=42)
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Cryn en 11 de Octubre de 2007, 04:30:36
crees que haya cometido algun error nocturno?? porque algo similar he visto en tu teclado y pues en mi simulacion no me funciona, ahora me he quedado sin fuente y no puedo armarlo y ver is es un problema del simulador que talvez lo sea, pero si no lo es sabes cual podria ser el error para que conectado eso al micro ya no funcione en los niveles de tension que he calculado??
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Nocturno en 11 de Octubre de 2007, 05:21:16
Asegúrate que la tensión de alimentación es estable y de 5V. Y ponle un condensador a la entrada del ADC que pueda filtrar los ruidos.
No debería variar tanto.
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 11 de Octubre de 2007, 05:29:41
¿Es que has soñado conmigo?  :lol:

Gestiona un teclado matricial con un sólo pin (http://www.micropic.es/index.php?option=com_content&task=view&id=56&Itemid=42)

La verdad es que no, pero parece que seguimos caminos paralelos en algunos casos ...
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 11 de Octubre de 2007, 08:20:23
Si bien el creador del hilo es Diego, hay que reconocer el trabajo de Manolo... :mrgreen:

La pregunta es para ambos:

Aunque se que es casi un imposible en los cortos tiempos que maneja un PIC, puede este sistema detectar una doble pulsacion??

Ejemplo a mi pregunta:
Necesito detectar si se pulsan a la vez la tecla F1 y el numero 7.

Puede hacer esa deteccion este sistema, y darme un resultado diferenciado respecto a una pulsacion estandar??

Gracias desde ya a los dos Maestros por la respuesta !!! :-/ :-/
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Nocturno en 11 de Octubre de 2007, 08:52:25
Habría que hacer muchos cálculos para calcular cuál sería la lectura en cada combinación, ya que entrarían en juego resistencias en paralelo y en serie.
Es probable que exista un conjunto de valores de resistencias que permitan el mayor número de combinaciones diferentes, pero la verdad es que veo improbable que no se repitan.
Y ya si lo que buscas es leer tres pulsaciones simultáneas todavía lo complicas más.
Realmente mis conocimientos de matemáticas no llegan; quizás alguien pueda sacar un modelo matemático que lo calcule.

Luego está la precisión del ADC, pero esa es otra guerra.
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 11 de Octubre de 2007, 09:26:56
El sistema que tengo pensado no permite teclas simultáneas. Yo pretendo implementar un barrido de lecturas AD durante un tiempo de pulsación de tecla de algunos milisegundos, son realmente rapidísimas y se leen muchas veces en ese tiempo, y obtener la media de todas ellas. El valor con el que voy a comparar no es el de una conversión matemática de un valor de voltaje definido, sino de una distribución estadística alrededor de ese valor. Ya os pondré el código de muestreo que implemente.

Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 11 de Octubre de 2007, 09:59:37
Otra posibilidad es poner un Puente de Wheatstone en lugar del simple divisor de tensión. Así podemos medir con la máxima precisión que deseemos ....

(http://upload.wikimedia.org/wikipedia/commons/9/91/PWheatstone.png)

(http://upload.wikimedia.org/math/8/2/b/82b85f93b55896310c8a22268f51134b.png)

En lugar de Rx pondríamos nuestro teclado.

Puente de Wheatstone (http://es.wikipedia.org/wiki/Puente_de_Wheatstone)
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 11 de Octubre de 2007, 10:52:52
Esa esta muy buena Diego!! :-/
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Chrisbaf en 11 de Octubre de 2007, 13:57:21
excelente aporte  :)
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Leon Pic en 11 de Octubre de 2007, 19:58:52
¿Es que has soñado conmigo?  :lol:

Gestiona un teclado matricial con un sólo pin (http://www.micropic.es/index.php?option=com_content&task=view&id=56&Itemid=42)

Hola Nocturno. Ya me parecía conocido el método, pero no lo recordaba. Me lo has enviado a mi e-mail hace dos o tres meses atrás.

De todas maneras no quiero desmoralizar a RedPic, Todo lo contrario. Le quiero dar ánimo para que continue y lo mejore al máximo.

Saludos.  :-/ :-/
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: LABmouse en 11 de Octubre de 2007, 20:15:57
GRACIAS REDPIC!!!! Gracias por compartirlo con todos en el foro.. Esta muy muy bueno  :-/
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 12 de Octubre de 2007, 08:14:29

De todas maneras no quiero desmoralizar a RedPic ...


Si yo me desmoralizase cada vez que descubro que Manuelo Nocturno ha realizado lo mismo que yo pero antes y mejor estaría ya sumido en la mas absoluta de las depresiones, porque constantemente voy descubriendo cosas que ya él las ha dado por cocinadas, deglutidas y eyectadas tiempo ha.  No, no me afecta.

Sólo los jóvenes creen que lo que acaban de descubrir es la primera vez que se descubre, los viejos sabemos que éste es solo un viaje personal que desde antes otros muchos han realizado. :mrgreen: :mrgreen: :mrgreen:

Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: aitopes en 12 de Octubre de 2007, 08:19:14
Sólo los jóvenes creen que lo que acaban de descubrir es la primera vez que se descubre, los viejos sabemos que éste es solo un viaje personal que desde antes otros muchos han realizado.

Totalmente de acuerdo. Dudo que nada de lo que haya hecho en mi vida haya sido algo completamente original, siempre hay alguien que lo hizo primero. Pero la satisfaccion reside en el logro personal, en la superacion de uno mismo.

Es mas, creo que eso de intentar lograr "un poquito mas" de uno mismo puede hasta llegar a ser adictivo. :)
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Nocturno en 12 de Octubre de 2007, 08:40:26
Pues yo sí me desmoralizo. Me desmoralizo cuando veo ese puente con nombre parecido al parque del oso Yogui y no se me ocurre cómo gestionar el teclado matricial con un sólo pin de esa manera. Será que me estoy volviendo mayor  :(
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Leon Pic en 12 de Octubre de 2007, 09:21:49

De todas maneras no quiero desmoralizar a RedPic ...


Si yo me desmoralizase cada vez que descubro que Manuelo Nocturno ha realizado lo mismo que yo pero antes y mejor estaría ya sumido en la mas absoluta de las depresiones, porque constantemente voy descubriendo cosas que ya él las ha dado por cocinadas, deglutidas y eyectadas tiempo ha.  No, no me afecta.

Hola RedPic. La razón de mi post anterior, es poorque años atrás había desarrollado una dirección, para un automovil, eléctrica, es decir, se maneja con un joystick, estaba en pleno desarrollo cuando, mirando un programa de TV, sobre aviones, vi que utilizaban el mismo principio de funcionamiento, el sistema se llama Flight Wire Were (o algo así) Me agarre tanta desilución, que tire todo a la mismisima miercoles.

Ahora maduré (solo un poquito  :-/ :lol: :z) :roll: :c)) y me doy cuenta que lo que hise fue una estupidez de mi parte, haber dejado el proyecto.

Sólo los jóvenes creen que lo que acaban de descubrir es la primera vez que se descubre, los viejos sabemos que éste es solo un viaje personal que desde antes otros muchos han realizado. :mrgreen: :mrgreen: :mrgreen:

Totalmente de acuerdo.

Pues yo sí me desmoralizo. Me desmoralizo cuando veo ese puente con nombre parecido al parque del oso Yogui y no se me ocurre cómo gestionar el teclado matricial con un sólo pin de esa manera. Será que me estoy volviendo mayor  :(

A esto me refiero con que fue una estupidez lo que hise, ya que RedPic mejoró o utilizó un método parecido, sin querer, a lo que hiso Nocturno.
Ahora me doy cuenta pude haber realizado mi dirección, de una forma tan eficiente como la que utiliza una empresa de aviones. (no quiero decir que yo solo puedo mejorar todo un sistema, a lo que hacen varios ingenieros).

Bueno, espero no haberlos aburrido con mi melancolía. Un gran problema que tengo, es que no se explicarme, y cuando digo algo, parezco grosero, burlon, etc, y no son mis intenciones

Saludos.  :-/ :-/
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 12 de Octubre de 2007, 10:47:51
Igualmente en algunos temas es lindo ser "el primero"... :D :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 12 de Octubre de 2007, 11:03:41
(http://publi.garcia-cuervo.net/iacd_v1.0.4_con_analog_keybsp.jpg)

Bueno ... tras unas cuantas horas perdidas debido a que el cable negro, el que tira a masa la resistencia R9, no hacía buen contacto y por consiguiente no había divisor de tensión ni nada que se le parezca, lo he solucionado y ya funciona.  :mrgreen:

He implementado una forma de leer que intenta minimizar los efectos aleatorios, y perversos, de las interferencias, transitorios y otras zarandajas.

Simplemente lo que hago es acumular n lecturas consecutivas y después calcular la media de todas ellas. Cuanto mas lecturas realice menor impacto pueden tener lecturas aleatorias esporádicas que puedan producirse.

Como leo con 10 bits de precisión, 1024 valores posibles, pero la menor y la mayor resistencia que puedo obtener son de 220R y 2760R que generan voltajes de 4,225V y 1,515V respectivamente, solo puedo obtener lecturas entre 865 y 310 aproximadamente.

Si es la mayor, 865, y acumulo sobre una variable de 16 bits solo podré acumular 75 lecturas (2^16/865) y después dividir por 75 para obtener la media de todas ... pero no es necesario ajustarse tanto al límite, con 32 lecturas tendremos mas que suficiente.

Asi que implementando que es gerundio:

Código: C++
  1.  
  2. void main(void){
  3.  
  4.    int16 ANval;
  5.    int16 ANval_Acumuleitor=0;
  6.    int16 ANVal_Result;
  7.    int16 ANVAL_Minimun=255;
  8.    int8  CAN_count=0;
  9.    int8  CAN_maxcount=32;
  10.  
  11.    setup_adc_ports(AN0 | VSS_VDD); // Configuro AN0 para lectura ADC, usando como referencia VSS y VDD
  12.    setup_adc(ADC_CLOCK_INTERNAL);  // Configuro velocidad de muestreo la interna del PIC 2-6 us
  13.    set_adc_channel(0);             // Configuro siguiente canal de lectura a AN0;
  14.  
  15.    do{
  16.  
  17.          ANVal = read_adc();                                        // Leo canal ACD y guardo en ANVal
  18.          ANval_Acumuleitor += ANVal;                                // Acumulo sucesivas lecturas sobre ANval_Acumuleitor
  19.          if(++Can_Count==CAN_maxcount){                             // Si hago mas de CAN_maxcount lecturas ...
  20.             ANVal_Result = (int16) ANval_Acumuleitor/CAN_maxcount;  // Calculo la media de las lecturas realizadas ...      
  21.             if(ANVal_Result>ANVAL_Minimun){                         // Que si resulta mayor que ANVAL_Minimun ...
  22.                printf("KeyScan %Lu\r\n",ANVal_Result);              // La tomo en consideración, en este caso lo muestro,
  23.                                                                     // ya haremos la conversión a teclas por margen.
  24.             }
  25.             Can_Count=0;                                            // Reinicio Can_Count, el contador de lecturas.
  26.             ANval_Acumuleitor=0;                                    // Reinicio ANval_Acumuleitor, el acumulador de lecturas.
  27.          }
  28.    }while(1);
  29. }
  30.  
  31.  

Asi el funcionamiento es claro y simple. Leo CAN_maxcount veces (32) sobre ANval, acumulando sobre ANval_Acumuleitor, incrementando CAN_count cada vez que leo. Cuando CAN_count alcanza el valor de CAN_maxcount lecturas calculo ANVal_Result dividiendo ANval_Acumuleitor por CAN_maxcount. Si ANVal_Result es mayor que ANVAL_Minimun lo muestro, recordad que en nuestra tabla el menor resultado posible de una lectura correspondía a la mayor resistencia posible que nos daba una lectura de unos 310. Reinicio CAN_count y ANval_Acumuleitor y volvemos a empezar.

El resultado, mas abajo, tras pulsar la tecla Col4/Row4, F4 en el teclado de la imagen:

(http://publi.garcia-cuervo.net/iacd_v1.0.4_con_analog_keybsp_dump1.jpg)

Los resultados obtenidos son compatibles, en desviación, con el 5% de precisión de las resistencias usadas (las de la banda dorada). Con resistencias mas precisas, del 1% por ejemplo, podríamos afinar la lectura proporcionalmente.

Ahora ya solo queda identificar cada lectura con cada tecla, cosa que haremos teniendo en cuenta un margen de error de +-(mas, menos) ese 5%, disminuido a aproximadamente un 1% por la ponderación realizada, alrededor de cada valor teórico calculado, de forma que nuestra tecla F4 que debería generar una lectura de 310 deberemos fijarla como 307>[F4]>313.  :mrgreen: :mrgreen: :mrgreen:

Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: elreypic2 en 12 de Octubre de 2007, 12:01:18
Que tal amigos todos,

Me gustaria aportar el anailisis matematico para la deteccion de dos teclas segun el esquema y valores que han proporcionado nuestro amigos redpic y Nocturno.

Ahora bien proacticamente el modelo matematico general es el mencionado por RedPic, esto es:

Vout = [Rbottom / (Rtop + Rbottom) ] X Vin

Donde Rbottom = R9
Esta es la ecuacion general y lo que cambia para todods los casos es la Rtop. En el caso de la detecion de una sola tecla Rtop = Rcolumna + Rfila. Ahora vamos a analizar que sucede cuando se presionan dos teclas.

Si observamos con detalle, podemos darnos cuenta de que existe 3 posible condiciones de presionar dos teclas simultaneamente y estos son:
1) Cuando se presionan dos teclas en la misma fila
2) Cuando se presionan dos teclas en la misma columna
3) Cuando se presionan dos teclas en diferente columna y fila

Analicemos el primer caso. Para el primer caso si presionamos dos teclas que se encuentran en una mima fila, se genera un resistencia equivalente en parelelo de dos resistencias de columna, esto es se puede generar las siguientes combinaciones; R1|| R2, R1|| R3, R1|| R4, R2|| R3 ... etc
Entonces podemos decir que se forma una resistencia equivalente formada por el paralelo de 2 resistencias, esto es Reqc = Rcx || Rcy y en su expresion matematica seria: Reqc = RcxRcy/(Rcx+Rcy). Esta resistencia equivalente sera ahora nuestra nueva resistencia de columna, es decir
Rcolumna = Reqc. Si sustituimos en nuestra ecuacion general tenemos que, Vout = [R9 /( Reqc+Rf+R9)]Vin.

Ahora analicemos el segundo caso. En este caso se presionan 2 teclas en la misma columna, por lo tanto ahora se genera una resistencia equivalente de dos resistencia de fila en paralelo, esto es R5 || R6, R5 || R7, RR5 || R8 ... etc. Por lo que la resistencia equivalente la podemos definir de la siguiente manera: Reqf = Rfx || Rfy, y su espresion matematica es: Reqf  = RfxRfy/(Rfx+Rfy). Esta ahor asera nuestro nuevo valor para la resistencia de fila, es decir Rfila = Reqf. Sustituyendo en nuestra ecuacion general tenemos que: Vout = [R9 /(Rc + Reqf + R9)]Vin.

Para el tercer caso en el que tenemos que se presionan dos teclas las cuales estan en diferente fila y columna tenemos ahora que la resistencia equivalente se forma de Reqtop = (Rcx+ Rfx) || (Rcy + Rfy), esta ahora es nuestra nueva resistencia equivalente pero ahora esta es igual a Rtop y no solamente a Rcolumna o Rfila. Su expresion matematica seria: Reqtop = (Rcx + Rfx)(Rcy+Rfy)/(Rcx+Rcy+Rfx+Rfy). Entonce sustituyendo en nuestra ecuacion general tenemos que:  Vout = [R9 /(Reqtop + R9)]Vin.

Este es mi pequenio aporte, ahora solo bastaria corroborar esta analisis. Saludos y espero que esto le pueda servir a alguien mas.

Su amigo: Elreypic.
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 12 de Octubre de 2007, 12:10:41
Menuda placa de pruebas, Diego !! :-/ :-/

Fanfarron !! :D :D :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Nocturno en 12 de Octubre de 2007, 12:20:32
Ese análisis es realmente interesante Elreypic, pero no sé cómo aplicarlo para deducir unos valores de resistencias que permitan conseguir que no haya dos combinaciones iguales. Ahí es donde yo no sé llegar con matemáticas.

Diegooooo, yo quiero una entrenadora como esa ;-)
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 12 de Octubre de 2007, 13:39:13
Diego, que es el modulo negro largo que esta conectado a la bornera derecha?? :shock:

Me tiene muy intrigado... :mrgreen:
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Nocturno en 12 de Octubre de 2007, 13:55:52
¡Yo lo seeee, yo lo seeee!  :mrgreen:
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 12 de Octubre de 2007, 16:11:10
Que es ?? :-/ :-/
Que es ??? :shock: :shock:
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: aitopes en 12 de Octubre de 2007, 16:23:44
Me extraña Marcos!
Se ve lejos que es un módulo PQPLC, ¿no?

Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 12 de Octubre de 2007, 16:30:09
Lo que?? :D :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: aitopes en 12 de Octubre de 2007, 16:36:38
PQ-PLC: Para Que Pregunten Los Curiosos.  :D :D :D :D :D

(existe el PQPLB, pero se que para vos ultimamente es un tema sensible... :-) )
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Marioguillote en 12 de Octubre de 2007, 16:41:07
Holas !  :)

Diego, que es el modulo negro largo que esta conectado a la bornera derecha?? :shock:

Es un lector de tarjetas magnéticas ?  :?:

Otra cosita.
Diego: has tenido en cuenta la vida útil del contacto de cada pulsador ?
Digamos que en la teoría y durante los primeros meses en que el teclado no sufra abusos y mantenga su Ron (Resistencia en conducción) (no la bebida de la que abusa Manolo  :D ) tendiente a 0 Ohm, no habrá problemas, pero eso no es duradero.
Yo trataría de dejar previsto un margen mayor de tolerancia, ya que en un año nomás, le resistencia de contacto variará, máxime aún si siempre se teclea una misma secuencia numérica.
Se me ocurre éste razonamiento, en virtud de ver cómo varían las Ron de los soft touch de los equipos electrónicos del hogar y por funcionar de un modo análogo, provocan fallas, activando alguna función distinta al pulsador seleccionado.

En otro orden de cosas me anoto en la lista de quienes babean por la placa de la foto.

Podrías sortear una entre los integrantes del foro ...  :D

Saludos
Mario
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: LABmouse en 12 de Octubre de 2007, 17:01:51
(existe el PQPLB, pero se que para vos ultimamente es un tema sensible... :-) )


 :D :D :D  Amigos ustedes son de lo mejor!!! Que apuntes que apuntes juajuajua  :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Nocturno en 12 de Octubre de 2007, 17:07:43
Bueno, como Diego no lo dice, y puesto que estáis impacientes, os diré que es un lector de tarjetas RFID.
Supongo que Diego aparecerá mañana por aquí y dará referencias, datasheets y más datos en pocas palabras  :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Marioguillote en 12 de Octubre de 2007, 17:09:11
en pocas palabras  :D

 :D  :D  :D  :D  :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 12 de Octubre de 2007, 17:12:32
Espero que no se explaye... :shock:
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: aitopes en 12 de Octubre de 2007, 17:23:58
.....solo faltaria que se pongan a discutir con Reinier....  :shock:

 :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: LABmouse en 12 de Octubre de 2007, 17:29:56
.....solo faltaria que se pongan a discutir con Reinier....  :shock:

 :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D

 :D :D :D :D

Maginate eso!!!!  :shock: cada insulto seria de mas de 10000 palabras.. juajuajua  :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Leon Pic en 12 de Octubre de 2007, 17:46:06
.....solo faltaria que se pongan a discutir con Reinier....  :shock:

 :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D

 :D :D :D :D

Maginate eso!!!!  :shock: cada insulto seria de mas de 10000 palabras.. juajuajua  :D


 :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D
Saludos.  :-/ :-/
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: reiniertl en 12 de Octubre de 2007, 19:28:56
A ver que también se insultar con pocas palabras, lo que pasa es que así no tiene estilo. ;) ;) ;)
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 12 de Octubre de 2007, 21:11:16
Creo que les estan tomando el pelo a Diego y a Reiner.. :mrgreen:
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 12 de Octubre de 2007, 22:11:55
Diego, que es el modulo negro largo que esta conectado a la bornera derecha?? :shock:
Me tiene muy intrigado... :mrgreen:

Es un Lector de Tarjetas de Proximidad RFID 125Khz marca GIGATEK modelo RF222 con transmisión Data & Clock ABA TRACK 2 (de este mismo modelo los hay con transmisión Wiegand 32 y RS232)  :mrgreen:

(http://publi.garcia-cuervo.net/rf222.jpg)
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 12 de Octubre de 2007, 22:23:53
en pocas palabras  :D
:D  :D  :D  :D  :D

Quidquid latine dictum sit, altum viditur.
Cualquier cosa dicha en latín parece mas profundo.  :mrgreen:

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus. Phasellus viverra nulla ut metus varius laoreet. Quisque rutrum. Aenean imperdiet. Etiam ultricies nisi vel augue. Curabitur ullamcorper ultricies nisi. Nam eget dui.

Lorem ipsum ... (http://es.wikipedia.org/wiki/Lorem_ipsum) Cicerón.

Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: LordLafebre en 12 de Octubre de 2007, 22:29:23
Hola:

Muy interesante amigos esto del teclado con un solo pin, es algo que vale la pena probarlo.  :-/
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 13 de Octubre de 2007, 08:33:16
Quo Vadis, Diegum? :D :D
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 14 de Octubre de 2007, 09:13:15
En el Post inicial (http://www.todopic.com.ar/foros/index.php?topic=18911.msg133263#msg133263) discutíamos la configuración teórica del cómo podríamos leer un teclado matricial 4x4 mediante un único canal de conversión Analógico-Digital:

(http://picmania.garcia-cuervo.net/images/trucos_switches_3.jpg)

En este segundo post (http://www.todopic.com.ar/foros/index.php?topic=18911.msg133520#msg133520) implementábamos un sistema estadístico para recoger n valores consecutivos de una misma lectura con el fin de minimizar los posibles errores por interferencias, inestabilidad u otras posibles influencias en la lectura:

(http://publi.garcia-cuervo.net/iacd_v1.0.4_con_analog_keybsp_dump1.jpg)

Vamos ahora a solucionar los últimos flecos de nuestra implementación  de una Lectura de un Teclado Matricial 4x4 con un solo pin del PIC consiguiendo una lectura segura, estable y unívoca de nuestro teclado.

El nuevo objetivo a conseguir es detectar infalíblemente una tecla pulsada, que no se confunda con ninguna otra, que solo la obtengamos tras asegurarnos que lleva un tiempo mínimo siendo pulsada, que no se repita la lectura independiente del tiempo que la tengamos pulsada y que sea válida cuando detectemos que la hemos soltado, reiniciando todo el sistema para obtener la siguiente tecla.

O sea esto:

(http://picmania.garcia-cuervo.net/images/trucos_switches_3_dump.jpg)

El mundo Analógico es fundamentalmente distinto del Digital. En éste entre dos estados distintos y consecutivos no hay ningún estado intermedio, en aquel hay infinitos estados. Nuestra conversión AD es conocida hasta el décimo bit de precisión, si usamos un AD de 10 bits ya que si el conversor que usamos es de 8 bits será esta la precisión de nuestro conocimiento.

Pero independiente de esta precisión para la parte analógica de nuestra conversión vamos a recibir distintos voltajes en distintos momentos dependiendo de cientos de factores que van a influir en él: Desde el mismo error en la construcción de la red de resistencias que hemos montado, hasta las variaciones del voltaje VCC que utilizamos pasando por la misma inestabilidad térmica del sistema o la presión y forma de presionar que ejerzamos sobre cada una de las teclas al pulsarlas.

Al pulsar y soltar una única tecla podemos obtener toda una gama de distintos valores, lo he comprobado empíricamente, que pueden recorrer todo el espectro de valores posibles para nuestro teclado.

Desde el momento en que empieza a haber contacto de la tecla, que cierra y abre el circuito una decenas de veces, pasando por el tiempo que mantenemos dicho contacto con distintas áreas de contacto y presiones sobre la tecla, y hasta el momento en que soltamos la tecla volviendo a un tren de voltajes distintos generados durante la separación de la membrana de contacto.

La solución que he adoptado es la de recoger todas estas variaciones y tomar en cuenta aquella que estadísticamente mas se repita.

Para la primera fase, la del valor de la conversión, ya visteis cómo recogía n veces cada conversión individual y después sacaba el valor medio de todas las conversiones realizadas.

Ahora doy otro paso más:

Este valor obtenido no deja de ser una propuesta de lectura, recordad que puedo obtener x valores compatibles con la tecla KEY1 mezclada con y valores de KEY2 e incluso z valores de una KEY3.

La implementación que he hecho es la de recoger los distintos valores de Key leídos sobre una matriz (arreglo) de contadores, incrementando cada contador individual cuando recibo una key leída.

Cuando un contador de éstos alcanza un valor determinado y definido doy por absolutamente válida dicha key, limpio el resto de contadores y vuelvo a empezar.

Si obtengo un cierto número de lecturas por debajo de la mínima lectura posible es que estoy en estado de no tener ninguna tecla presionada, en dicho caso también limpio la matriz de contadores.

Si por el contrario obtengo insistentemente la misma key válida es que estoy manteniendo la tecla pulsada, asi que después de devolverla la primera vez no vuelvo a hacerlo hasta no pasar de nuevo por el estado de tecla no pulsada.

La matriz de contadores es de 17 contadores, el primero [ 0 ] para contar las lecturas menores a la mínima que me va a indicar el estado de tecla no pulsada, y el resto de contadores [ 1 ]..[ 16 ] para cada una de las teclas.

Y ya por fin, y dejándome de tanta filosofía, aquí tenéis la implementación en CCS C que he realizado:

Código: C++
  1.  
  2. int16 ANval;
  3. int16 ANval_Acumuleitor=0;
  4. int16 ANVal_Result;
  5. int8  CAN_count=0;
  6. int8  NumKeys=0;
  7. int8  NumKeysMinimun=0;
  8. int8  Keys[17]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  9. int8  Key_Pressed=0;
  10. int8  Key_Previous=0;
  11.  
  12. const int16 ANVAL_Minimun=255;
  13. const int8  CAN_maxcount=64;
  14. const int8  NumKeysForValidKey=15;
  15. const int8  NumKeysForDepressed=25;
  16. const int8  WideForKey=5;
  17. const int16 KeyValues[17]={0,310,318,329,339,445,460,486,508,551,574,614,650,698,736,803,855};
  18. const char  KeySimbols[17]={'\0','A','B','C','D','3','6','9','u','2','5','8','X','1','4','7','0'};
  19.  
  20.  
  21. void main(void){
  22.  
  23.    setup_adc_ports(AN0 | VSS_VDD);
  24.    setup_adc(ADC_CLOCK_INTERNAL);
  25.    set_adc_channel(0);
  26.  
  27.    do{
  28.          task_Analog_Keyboard();
  29.    }
  30. }
  31.  
  32. void task_Analog_Keyboard(void){
  33.  
  34.    int1 flag_Depressed=0;
  35.  
  36.    int8  i;
  37.  
  38.    ANVal = read_adc();                                         // Leo canal ACD y guardo en ANVal
  39.    ANval_Acumuleitor += ANVal;                                 // Acumulo sucesivas lecturas sobre ANval_Acumuleitor
  40.    if(++Can_Count==CAN_maxcount){                              // Si hago mas de CAN_maxcount lecturas ...
  41.       ANVal_Result = (int16) ANval_Acumuleitor/CAN_maxcount;   // Calculo la media de las lecturas realizadas ...
  42.       if(ANVal_Result>ANVAL_Minimun){                          // Que si resulta mayor que ANVAL_Minimun ...
  43.          for(i=1;i<17;i++){
  44.             if(ANVal_Result>(KeyValues[i]-WideForKey) AND ANVal_Result<(KeyValues[i]+WideForKey)){ // Si el valor está dentro del margen de error ~ WideForKey
  45.                if(++Keys[i]==NumKeysForValidKey){
  46.                   Key_Pressed=i;                               // Si alcanzo NumKeysForValidKey marco definitivamente Key_Pressed
  47.                   for(i=0;i<17;i++){Keys[i]=0;}                // Limpio los acumulados de Keys hasta el momento
  48.                   break;                                       // Aborto ejecución del bucle para tomar en cuenta la tecla pulsada.
  49.                }
  50.             }
  51.          }
  52.       }
  53.       else{                                                    // Si es menor que ANVAL_Minimun estoy en Key_Depressed
  54.          if(++Keys[0]==NumKeysForDepressed){
  55.             if(flag_Depressed==0) flag_Depressed=1;            // Si alcanzo NumKeysForDepressed marco definitivamente Key_Depressed
  56.          }
  57.       }
  58.       Can_Count=0;                                             // Reinicio Can_Count, el contador de lecturas.
  59.       ANval_Acumuleitor=0;                                     // Reinicio ANval_Acumuleitor, el acumulador de lecturas.
  60.       // Si tengo una Key_Pressed y no es igual a la última Key_Pressed y ya he detectado que he soltado la telca
  61.       // tomo en consideración los resultados obtenidos: son válidos y estables.
  62.       if((Key_Pressed!=0) AND (Key_Pressed!=Key_Previous) AND flag_Depressed==1){
  63.  
  64.          printf("Key = %2u Symbol=%c\r\n",Key_Pressed,KeySimbols[Key_Pressed]); // Aqui tenemos disponibles los valores de Key pulsada y/o Simbolo asociado
  65.          flash_BUZZER(1,50);
  66.  
  67.          Key_Previous=Key_Pressed;                             // Asigno valor actual de tecla al anterior para evitar repeticiones
  68.          Key_Pressed=0;                                        // Limpio valor actual para seguir investigando teclas pulsadas.
  69.       }
  70.       if(flag_Depressed==1){                                   // Si recibo estado definitivo de Key_Depressed ...
  71.          flag_Depressed=0;                                     // Marco como leido dicho estado ...
  72.          Key_Previous=0;                                       // Reinicio valor anterior de tecla pulsada Key_Previous
  73.       }
  74.    }
  75. }
  76.  
  77.  

El resultado el que os mostré mas arriba.

(http://picmania.garcia-cuervo.net/images/trucos_switches_3_dump.jpg)

Seguro, estable, fiable y confiable.  :mrgreen: :mrgreen: :mrgreen:

Hasta otraaaaaaa.
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: MGLSOFT en 14 de Octubre de 2007, 12:10:26
Creo que habra que tener mucho cuidado en el uso de este tipo de teclados respecto a como se alimenta el circuito (desde que fuente) y ademas que las referencias de tension sean provenientes de esa misma fuente, para no introducir variables que pueden convertirse en problemas al momento de su utilizacion.
Si esto no fuera asi tendriamos un rompedero de cabezas al momento de diagnosticar nuestros problemas...

El tema es espectacular, Diego!! :mrgreen:
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: DLT_FONS en 22 de Abril de 2014, 03:50:41
Saludos
hace poco implemente el teclado matricial par aun solo pin
Les dejo esta funcion que seguro puede ayudar a usar este metodo, lo que hice que hiciera es:

1: teclado
Espera hasta que encuentra una entrada mayor a la referencia y al final entrega un valor de la tecla presionada

2: pass
una pequeña aplicacion

Espero que les sirva, introduscan esas funciones con sus banderas; quizá no sea tan eficiente pero probado en programas robustos no da problemas.
Cambia valores de banderas solamente, puede sustituirse con cambiar en teclado de void a int y poner retun


ahi va el codigo:


Código: CSS
  1. /*
  2. Teclado sys by Fons
  3. V 1.0.3a
  4. para todopic.com.ar
  5.  
  6. Entradas: Lectura analogica
  7. Salidas: lcd con mensajes
  8. */
  9.  
  10. #define LCD_DATA_PORT getenv("SFR:PORTD")
  11. #include   <16f887.h>   //Carga librer¡a del uC
  12. #device  adc=10
  13.  
  14. #fuses   HS, NOWDT, MCLR
  15. #use   delay(clock=20MHz)
  16.  
  17. #include <lcd.c>      //incluir libreria del lcd en carpeta poryecto
  18. #include <ctype.h>    //Indicamos la libreria ctype
  19. #include <stdlib.h>   //de char a carcter
  20. #include <stdio.h>
  21.  
  22.  
  23. /////////////////////////////////////////////////////////////////////
  24. //////////////////// BANDERAS Y CONSTANTES //////////////////////////
  25.  
  26. //==================================================================
  27. //TECLADO  
  28. //Valores para la lectura analogica
  29.    const int VminF=150;
  30.  
  31. //Valores para cada tecla
  32.    const long VdO=166,    Vc=296, Vb=408, Va=563;
  33.    const long VgatoN=178, V9=336, V6=488, V3=728;
  34.    const long V0S=182,    V8=348, V5=514, V2=788;
  35.    const long Vaste=188, V7=371, V4=566, V1=915;
  36.  
  37. //banderas
  38.    int b_teclado=0;
  39.    int entradateclado=0;
  40.    int superior=0, inferior=0;
  41.    char letra='x', numero='x', s_teclado='x';
  42.  
  43. //==================================================================
  44. //PASS
  45.    char pass1[4]={'1','1','1','1'};
  46.    int match_1;
  47.    int usuario;
  48.  
  49.  
  50.  
  51. /////////////////////////////////////////////////////////////////////
  52. /////////////////////// CONFIGURACION PIC ///////////////////////////
  53. void config()
  54. {
  55.    lcd_init();                   //Configuracion de lcd
  56.  
  57. //configuracion de entrada ADC
  58.    setup_adc(ADC_CLOCK_DIV_32)    
  59.    setup_adc_ports(sAN5);      
  60.    set_adc_channel(5);
  61.    
  62.  
  63. }//fin config
  64.  
  65.  
  66. /////////////////////////////////////////////////////////////////////
  67. //////////////////// FUNCIONES AUXILIARES ///////////////////////////
  68.  
  69. /*%%%%%%%%%%%%%%%%%%% ENTRADA DE TECLADO A5  %%%%%%%%%%%%%%%%%%%%%%*/
  70. void teclado()
  71. {
  72.    b_teclado=0;  
  73.    while(b_teclado==0){    
  74. //Asegurando una entrada mediante dos mediciones. Filtro por lecturas
  75.      entradateclado=0;
  76.      while(entradateclado<VminF){                     //mientras la bandera sea menor a la referencia minima
  77.         entradateclado = read_adc();                   //asigmamos una priemra lectura a la bandera
  78.         delay_ms(70);                                        //esperamos a que pasen picos de voltaje
  79.         entradateclado = read_adc();                  //volvemos a hacer una segunda medicion
  80.         delay_ms(30);                                       //esperamos a que pasen picos
  81.     }//fin while de presionar teclado
  82.  
  83. //guardando la entrada
  84.     entradateclado = read_adc();                      //hacemos 3ra lectura donde guardamos el valor [considerando que la tecla se ha mantenido presionado por los 100ms]      
  85.     superior=entradateclado+1;
  86.     inferior=entradateclado-1;    
  87.     letra='x';                                                   //reinicio de bandera de letra
  88.     numero='y';                                              //reinicio de bandera de numero
  89.      
  90.     if (superior>=VdO && VdO>=inferior)letra='D';
  91.     else if (superior>=VgatoN && VgatoN>=inferior)letra='#';
  92.     else if (superior>=V0S && V0S>=inferior)numero='0';
  93.     else if (superior>=Vaste && Vaste>=inferior)letra='*';
  94.     else if (superior>=Vc && Vc>=inferior)letra='C';
  95.     else if (superior>=V9 && V9>=inferior)numero='9';
  96.     else if (superior>=V8 && V8>=inferior)numero='8';
  97.     else if (superior>=V7 && V7>=inferior)numero='7';
  98.     else if (superior>=Vb && Vb>=inferior)letra='B';
  99.     else if (superior>=V6 && V6>=inferior)numero='6';
  100.     else if (superior>=V5 && V5>=inferior)numero='5';
  101.     else if (superior>=V4 && V4>=inferior)numero='4';
  102.     else if (superior>=Va && Va>=inferior)letra='A';
  103.     else if (superior>=V3 && V3>=inferior)numero='3';
  104.     else if (superior>=V2 && V2>=inferior)numero='2';
  105.     else if (superior>=V1 && V1>=inferior)numero='1';
  106.     else{letra='x';numero='y';delay_ms(300);}  
  107.  
  108.     if(letra=='x' && numero=='y')b_teclado=0;       //si es que no entro en rango de letras, volvemos a entrar al while
  109.                                                                          //[an pasado menos de 1 ms, maximo, desde las comparaciones;
  110.                                                                          //por lo que si se presiona por medio segundo se aseguran 4  lecturas almenos]
  111.  
  112.     else b_teclado=1;                                           //si hubo match con alguna tecla, para salir del while (sustituible con un break pero esta al final asi que da igual)
  113.  
  114.   }//fin while de bandera
  115.  
  116. //hasta aqui se ha asegurado de que no saldra del loop hasta que tenga un valor conocido  
  117. //asignamos el caracter medido a la variable s_teclado
  118.  
  119.    if(letra!='x')
  120.        s_teclado=letra;
  121.    else if(numero!='y')
  122.        s_teclado=numero;
  123. }//fin funcion teclado, salida: variable global con cambio de valor, s_teclado
  124.  
  125. /*%%%%%%%%%%%%%%%%%%% ENTRADA DE PASSWORD  %%%%%%%%%%%%%%%%%%%%%%%%*/
  126. void m_Pass()
  127. {  
  128.    lcd_putc("\fDigite \n *****");
  129.    match_1=0;
  130.    lcd_gotoxy(1,2);
  131.  
  132.    for(int i=0; i<=3; i++)
  133.    {
  134.       s_teclado='x';
  135.       teclado();
  136.       printf(lcd_putc,"%c",s_teclado);
  137.       if(s_teclado==pass1[i])
  138.          match_1++;
  139.    }
  140.  
  141.    if(match_1==4)usuario=1;    
  142.    else lcd_putc("\fError en pass");
  143.    delay_ms(1200);
  144. }//fin de funcion pas. bandera global con cambio : usuario
  145.  
  146.  
  147.  
  148.  
  149. /////////////////////////////////////////////////////////////////////
  150. //////////////////// FUNCIONES PIRNCIPALES //////////////////////////
  151.  
  152. /*%%%%%%%%%%%%%%%%%%% MENSAJE DE INICIO %%%%%%%%%%%%%%%%%%%%%%%%%%%*/
  153. void m_inicio()
  154. {
  155.   lcd_putc("LOADING . \n  ");   //MUESTRA EN ´PANTALLA LOADING.
  156.   delay_ms(600);            //RETRASO
  157.   lcd_putc("\f");            //CON ESTO SE LIMPIA PANTALLA
  158.   lcd_putc("LOADING . .\n  ");
  159.   delay_ms(600);
  160.   lcd_putc("\f");
  161.   lcd_putc("LOADING . . .\n  ");
  162.   delay_ms(600);
  163.   lcd_putc("\f");
  164.   delay_ms(1200);
  165.   lcd_putc("   Teclado SYS\n V 1.0.3a");
  166.   delay_ms(2600);
  167.   lcd_putc("\f");
  168.   lcd_putc("   Teclado SYS\n by FONS");
  169. }
  170.  
  171.  
  172. /////////////////////////////////////////////////////////////////////
  173. //////////////////// LOOP DE TRABAJO //////////////////////////
  174. void main()
  175. {
  176.    config();
  177.    m_inicio();
  178.    while(true)
  179.    {
  180.      pass();
  181.  
  182.    }
  183. }
  184.  
Título: Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: RedPic en 22 de Abril de 2014, 06:19:37
Gracias DLT_FONS por el aporte  :mrgreen:
Título: Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Arsenic en 21 de Enero de 2016, 08:25:08
Si quisiera implementarla como librería con un código cómo haría?
Título: Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: KILLERJC en 21 de Enero de 2016, 09:26:31
Si quisiera implementarla como librería con un código cómo haría?

En un .c tenes que tener:

- El codigo de la funcion

task_Analog_Keyboard(void)

- Definidos las variables que se usan unicamente alli

- Cambiar el tipo de funcion, me refiero a que devuelva un valor, ejemplo de:

void task_Analog_Keyboard(void)

a

int task_Analog_Keyboard(void)

- Aplicar unos return en ves de asignar a una variable que se use en otro lado.

Crear un .h con el prototipo de funcion

int task_Analog_Keyboard(void);

Asi lo incluis en el main, y lo usas.
Título: Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Arsenic en 21 de Enero de 2016, 13:32:24
Lo que hice fue copiar el código, pero no me imprime nada en pantalla. Te lo dejo:

Código: C
  1. #Include <18F2550.h>
  2. #use delay(clock=4M)
  3.  
  4. #define use_portB_lcd TRUE
  5. #fuses nowdt,noprotect,nolvp,hs
  6. //LCD handle:
  7. #define LCD_DB4   PIN_B4
  8. #define LCD_DB5   PIN_B5
  9. #define LCD_DB6   PIN_B6
  10. #define LCD_DB7   PIN_B7
  11. #define LCD_RS    PIN_B1
  12. #define LCD_RW    PIN_B2
  13. #define LCD_E     PIN_B0
  14.  
  15. //function variables:
  16. int16 ANval;
  17. int16 ANval_Acumuleitor=0;
  18. int16 ANVal_Result;
  19. int8  CAN_count=0;
  20. int8  NumKeys=0;
  21. int8  NumKeysMinimun=0;
  22. int8  Keys[17]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  23. int8  Key_Pressed=0;
  24. int8  Key_Previous=0;
  25.  
  26. const int16 ANVAL_Minimun=255;
  27. const int8  CAN_maxcount=64;
  28. const int8  NumKeysForValidKey=15;
  29. const int8  NumKeysForDepressed=25;
  30. const int8  WideForKey=5;
  31. const int16 KeyValues[17]={0,310,318,329,339,445,460,486,508,551,574,614,650,698,736,803,855};
  32. const char  KeySimbols[17]={'\0','A','B','C','D','3','6','9','u','2','5','8','X','1','4','7','0'};
  33.  
  34.  
  35. //LCD library:
  36. #include  <LCD.c>
  37.  
  38.  
  39. //Auxiliar functions:
  40.  
  41. void task_Analog_Keyboard(void);
  42.  
  43.  
  44. //Main program:
  45. void main()
  46. {
  47.    lcd_init();
  48.    delay_ms(50);
  49.    set_tris_a(0xff);
  50.    setup_adc_ports(an0);
  51.    setup_adc(ADC_CLOCK_INTERNAL);
  52.    set_adc_channel(0);
  53.  
  54.    while(true)
  55.    {
  56.       task_Analog_Keyboard();
  57.    }  
  58.  
  59. }
  60.  
  61.  
  62. void task_Analog_Keyboard(void){
  63.  
  64.    int1 flag_Depressed=0;
  65.  
  66.    int8  i;
  67.  
  68.    ANVal = read_adc();                                         // Leo canal ACD y guardo en ANVal
  69.    ANval_Acumuleitor += ANVal;                                 // Acumulo sucesivas lecturas sobre ANval_Acumuleitor
  70.    if(++Can_Count==CAN_maxcount){                              // Si hago mas de CAN_maxcount lecturas ...
  71.       ANVal_Result = (int16) ANval_Acumuleitor/CAN_maxcount;   // Calculo la media de las lecturas realizadas ...
  72.       if(ANVal_Result>ANVAL_Minimun){                          // Que si resulta mayor que ANVAL_Minimun ...
  73.          for(i=1;i<17;i++){
  74.             if(ANVal_Result>(KeyValues[i]-WideForKey) && ANVal_Result<(KeyValues[i]+WideForKey)){ // Si el valor está dentro del margen de error ~ WideForKey
  75.                if(++Keys[i]==NumKeysForValidKey){
  76.                   Key_Pressed=i;                               // Si alcanzo NumKeysForValidKey marco definitivamente Key_Pressed
  77.                   printf(lcd_putc,"Key = %c",KeySimbols[Key_Pressed]);
  78.                   delay_ms(2000)
  79.                   lcd_;
  80.                   for(i=0;i<17;i++){Keys[i]=0;}                // Limpio los acumulados de Keys hasta el momento
  81.                   break;                                       // Aborto ejecución del bucle para tomar en cuenta la tecla pulsada.
  82.                }
  83.             }
  84.          }
  85.       }
  86.       else{                                                    // Si es menor que ANVAL_Minimun estoy en Key_Depressed
  87.          if(++Keys[0]==NumKeysForDepressed){
  88.             if(flag_Depressed==0) flag_Depressed=1;            // Si alcanzo NumKeysForDepressed marco definitivamente Key_Depressed
  89.          }
  90.       }
  91.       Can_Count=0;                                             // Reinicio Can_Count, el contador de lecturas.
  92.       ANval_Acumuleitor=0;                                     // Reinicio ANval_Acumuleitor, el acumulador de lecturas.
  93.       // Si tengo una Key_Pressed y no es igual a la última Key_Pressed y ya he detectado que he soltado la telca
  94.       // tomo en consideración los resultados obtenidos: son válidos y estables.
  95.       if((Key_Pressed!=0) && (Key_Pressed!=Key_Previous) && flag_Depressed==1){
  96.  
  97.          //lcd_putc("Key = %2u Symbol=%c\r\n",KeySimbols[Key_Pressed]); // Aqui tenemos disponibles los valores de Key pulsada y/o Simbolo asociado
  98.          //flash_BUZZER(1,50);
  99.  
  100.          Key_Previous=Key_Pressed;                             // Asigno valor actual de tecla al anterior para evitar repeticiones
  101.          Key_Pressed=0;                                        // Limpio valor actual para seguir investigando teclas pulsadas.
  102.       }
  103.       if(flag_Depressed==1){                                   // Si recibo estado definitivo de Key_Depressed ...
  104.          flag_Depressed=0;                                     // Marco como leido dicho estado ...
  105.          Key_Previous=0;                                       // Reinicio valor anterior de tecla pulsada Key_Previous
  106.       }
  107.    }
  108. }
  109.  
  110.  
  111.  
Título: Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: KILLERJC en 21 de Enero de 2016, 20:29:53
Edito. El error fue mio.
Título: Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Arsenic en 22 de Enero de 2016, 00:20:28
Pregunto... ¿no era más sencillo utilizar el get_trisx(y) [x=letra puerto; y=número puerto] y hace un bucle "IF"? Creo que el código original se encuentra en otro sitio web. Pero no así las fotografías. Es este:
http://picmania.garcia-cuervo.net/proyectos_analog_keyboard.php (http://picmania.garcia-cuervo.net/proyectos_analog_keyboard.php)
Título: Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: KILLERJC en 22 de Enero de 2016, 03:20:38
Pregunto... ¿no era más sencillo utilizar el get_trisx(y) [x=letra puerto; y=número puerto] y hace un bucle "IF"? Creo que el código original se encuentra en otro sitio web. Pero no así las fotografías. Es este:
http://picmania.garcia-cuervo.net/proyectos_analog_keyboard.php (http://picmania.garcia-cuervo.net/proyectos_analog_keyboard.php)

No.. no podes por que el TRIS solamente lee el registro TRISx ( TRISA por ejemplo ) el cual le dice si es entrada o salida, nada mas.

Edite el post anterior por que me di cuenta que me comi una llave invalidando toda mi respuesta.
Título: Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
Publicado por: Arsenic en 22 de Enero de 2016, 05:51:48
Solucionado. Sólo había que quitar lo de dentro de "read_adc(x)" lo que sería el valor de equis no se pone cuando es PIC18F2550. ¿Por qué es tan particular ese PIC?

Cierto: No funcionará en un matricial de membrana, dado que dichos teclados tienen de por sí una resistencia que es aproximadamente de 30Ω