Autor Tema: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC  (Leído 47724 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7865
Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #45 en: 13 de Octubre de 2007, 08:33:16 »
Quo Vadis, Diegum? :D :D
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5460
    • Picmania by Redraven
Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #46 en: 14 de Octubre de 2007, 09:13:15 »
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.  
  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.



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

Hasta otraaaaaaa.
« Última modificación: 10 de Abril de 2009, 05:34:48 por RedPic »
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7865
Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #47 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:
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado DLT_FONS

  • PIC10
  • *
  • Mensajes: 1
Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #48 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.  
« Última modificación: 11 de Mayo de 2014, 05:15:09 por DLT_FONS »
//==========================================
//============== By FONS ======================
/*
    Toda secuencia imaginable, es programable
*/

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5460
    • Picmania by Redraven
Re: Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #49 en: 22 de Abril de 2014, 06:19:37 »
Gracias DLT_FONS por el aporte  :mrgreen:
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado Arsenic

  • PIC10
  • *
  • Mensajes: 47
Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #50 en: 21 de Enero de 2016, 08:25:08 »
Si quisiera implementarla como librería con un código cómo haría?

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #51 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.

Desconectado Arsenic

  • PIC10
  • *
  • Mensajes: 47
Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #52 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.  

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #53 en: 21 de Enero de 2016, 20:29:53 »
Edito. El error fue mio.
« Última modificación: 22 de Enero de 2016, 03:19:25 por KILLERJC »

Desconectado Arsenic

  • PIC10
  • *
  • Mensajes: 47
Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #54 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

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #55 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

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.

Desconectado Arsenic

  • PIC10
  • *
  • Mensajes: 47
Re:Lectura de un Teclado Matricial 4x4 con un solo pin del PIC
« Respuesta #56 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Ω
« Última modificación: 22 de Enero de 2016, 09:06:53 por Arsenic »