Lectura de un Teclado Matricial 4x4 con un solo pin del PIC

[MGLSOFT]

Quo Vadis, Diegum?

[RedPic]

En el Post inicial 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:



En este segundo post 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:



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:



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

El resultado el que os mostré mas arriba.



Seguro, estable, fiable y confiable. 

Hasta otraaaaaaa.

[MGLSOFT]

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!!

[DLT_FONS]

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

[RedPic]

Gracias DLT_FONS por el aporte 

[Arsenic]

Si quisiera implementarla como librería con un código cómo haría?

[KILLERJC]

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.

[Arsenic]

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

[KILLERJC]

Edito. El error fue mio.

[Arsenic]

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

[KILLERJC]

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

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.

[Arsenic]

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Ω