mTouch de Microchip: en CCS y en español

[Nocturno]

He estado haciendo unas pruebas con el PIC 16F727 y su capacidad de leer sensores capacitivos utilizando mTouch de Microchip.

A pesar de haberlo buscado hay poco código fuente en CCS sobre este tema, la mayoría está escrito para Hitec y C18. Finalmente cogiendo un poco de aquí, un poco de allá y peleando con el prototipo he conseguido hacerlo funcionar en CCS, así que os dejaré por aquí el código fuente comentado por si alguien quiere probarlo.

En este vídeo podéis ver los resultados:

Esta es la PCB que he utilizado, como veis está diseñada para poder fabricarla a una sola cara ya que sólo tiene dos puentes:


El esquema está bastante lioso, ya que fui buscando la combinación de pines adecuada para que el ruteo saliese con el menor número de puentes. Por eso te encuentras los Touchpads y los leds algo desordenados y entremezclados; es el coste que pagué para que la PCB saliera más simple:


Y por último, este es el código fuente en CCS:

Pruebas mtouch.c

Código: C

1. /*
2.         mTouch con 16LF727
3.         Manuel Jiménez - Nocturno 2009
4.         www.micropic.es
5. */
6.  
7. #include <16LF727.h>
8. #include <pruebas mtouch.h>
9.  
10. #define ANTIRREBOTES    1
11. #define SENSIBILIDAD    5
12.  
13. unsigned char indice;
14. unsigned long lectura[8];                               // lectura de cada sensor
15. unsigned long promedio[8];                              // promedio leído de cada sensor
16. unsigned long umbral;                                   // umbral que debe superar para que se considere pulsado
17. unsigned long promedio_alto;                    // variable temporal de promedio alto
18. unsigned long promedio_bajo;                    // variable temporal de promedio bajo
19.  
20.  
21. typedef struct{                                                 // Estructura de información de los sensores
22.         unsigned char rebotes;
23.         unsigned char Pulsado:1;
24.         unsigned char SePulso:1;
25.         unsigned char Soltado:1;
26. } TIPO_SENSOR;
27.  
28. TIPO_SENSOR Sensor[8];
29.  
30. /***********************************************************************************************
31.                                                         INICIALIZACIÓN
32. ***********************************************************************************************/
33. void inicializacion() {
34.         char i;
35.        
36.         setup_oscillator(OSC_16MHZ);
37.         for (indice=0; indice<8; indice++){     // Inicialización de variables
38.                 promedio[indice] = 0;
39.                 lectura[indice] = 0;
40.         }
41.        
42.         /* Utilizaremos estos 8 sensores:
43.         CPS4:   RB4
44.         CPS5:   RB5
45.         CPS6:   RA4
46.         CPS7:   RA5
47.         CPS8:   RD0
48.         CPS9:   RD1
49.         CPS10:  RD2
50.         CPS11:  RD3
51.         */
52.        
53.         ANSELA = 0b00110000;
54.         set_tris_a (0b11110111);
55.        
56.         ANSELB = 0b00110000;
57.         set_tris_b (0b01110001);
58.        
59.         ANSELD = 0b00001111;
60.         set_tris_d (0b11111111);
61.        
62.         set_tris_c (0b11101001);
63.        
64.         ANSELE = 0b00000000;
65.         set_tris_e (0b00000000);
66.        
67.         setup_timer_2(T2_DIV_BY_16,0xB4,15);// Timer2 activo, prescaler 1:16
68.         setup_timer_1(T1_GATE_INVERTED);        // Timer1 activo, asociado al sensor capacitivo y sin prescaler
69.         T1GCON = 0b11100010;                            // Timer1 gate activo, y asociado al Timer2
70.        
71.         CPSCON0 = 0b10001100;                           // Activamos los sensores capacitivos
72.         CPSCON1 = 0x04;                                         // Empezamos por el sensor nº 4, que es el primero de los que usamos
73.         indice = 0;
74.        
75.         TMR1GIF = 0;                                            // Borramos el flag de interrupción
76.         TMR1GIE = 1;                                            // Activamos la interrupción del Timer1 Gate
77.         enable_interrupts(GLOBAL);                      // Activamos la gestión de interrupciones
78.        
79.         for(i=0; i<8; i++) Sensor[i] = 0;       // Inicialización de variables
80.        
81.         output_low(LED0);                                       // Apagamos los leds
82.         output_low(LED1);
83.         output_low(LED2);
84.         output_low(LED3);
85.         output_low(LED4);
86.         output_low(LED5);
87.         output_low(LED6);
88.         output_low(LED7);
89. }
90.  
91. /***********************************************************************************************
92.                                                         RUTINA DE INTERRUPCIÓN
93. ***********************************************************************************************/
94.  
95. #INT_DEFAULT
96. void GestionDeInterrupciones() {
97.         if (TMR1GIF && TMR1GIE) {                       // Interrupción del Timer1 Gate
98.                 TMR1GIF = 0;                                    // Borramos el flag de interrupción
99.                 TMR1ON = 0;                                     // Paramos el timer1
100.                
101.                 // Cálculo de la media móvil de los últimos 4 ciclos
102.                 lectura[indice] = promedio_alto = get_timer1() * 4;
103.                 promedio_bajo = promedio[indice] / 4;
104.                 umbral = promedio[indice]>>SENSIBILIDAD;
105.                
106.                 // Si ha pulsado, veremos que el Timer se ha acortado, por debajo del promedio - umbral
107.                 if (promedio_alto < promedio[indice] - umbral) {
108.                         // Chequeo repetitivo para evitar rebotes
109.                         if(Sensor[indice].rebotes < ANTIRREBOTES) Sensor[indice].rebotes++;
110.                                 if(!Sensor[indice].SePulso && Sensor[indice].rebotes == ANTIRREBOTES) {
111.                                         Sensor[indice].Pulsado = 1;
112.                                         Sensor[indice].SePulso = 1;
113.                                         }
114.                 } else {
115.                         // Si no ha pulsado y estamos en ciclo de rebotes
116.                         if(Sensor[indice].rebotes > 0) Sensor[indice].rebotes--;
117.                         if(Sensor[indice].SePulso && Sensor[indice].rebotes == 0) {
118.                                 Sensor[indice].SePulso = 0;
119.                                 Sensor[indice].Soltado = 1;
120.                                 }
121.                         // Al promedio acumulado le restamos el valor antiguo y le metemos el nuevo
122.                         promedio[indice] += promedio_alto/4 - promedio_bajo;
123.                         }
124.                 set_timer1(0);                                  // Iniciamos la cuenta en el Timer1
125.                 TMR1ON = 1;                                     // Activamos nuevamente el Timer1
126.                 indice ++;                                              // Pasamos al siguiente sensor
127.                 indice &= 0x07;                                 // La máscara nos permite contar de 0 a 7
128.                 CPSCON1 = indice+4;                             // Sumamos 4 porque nuestros sensores son del 4 al 11
129.         }
130. }
131.  
132. /***********************************************************************************************
133.                                                         PROGRAMA PRINCIPAL
134. ***********************************************************************************************/
135. void main() {
136.         unsigned char i;
137.        
138.         inicializacion();      
139.        
140.         while (true) {                                          // bucle infinito
141.                 for(i=0; i<8; i++) {                    // recorremos los 8 sensores
142.                         if(Sensor[i].Pulsado) {         // se ha detectado pulsación
143.                                 switch(i) {                             // encendemos el led que corresponda
144.                                         case 0:
145.                                                 output_high(LED0);
146.                                                 break;
147.                                         case 1:
148.                                                 output_high(LED1);
149.                                                 break;
150.                                         case 2:
151.                                                 output_high(LED2);
152.                                                 break;
153.                                         case 3:
154.                                                 output_high(LED3);
155.                                                 break;         
156.                                         case 4:
157.                                                 output_high(LED4);
158.                                                 break;
159.                                         case 5:
160.                                                 output_high(LED5);
161.                                                 break;
162.                                         case 6:
163.                                                 output_high(LED6);
164.                                                 break;
165.                                         case 7:
166.                                                 output_high(LED7);
167.                                                 break;         
168.                                 }      
169.                                 Sensor[i].Pulsado = 0;  // trabajo realizado, borramos el indicador                    
170.                         } else if(Sensor[i].Soltado) {  // se ha quitado el dedo
171.                                 switch(i) {                             // apagamos el led que corresponda
172.                                         case 0:
173.                                                 output_low(LED0);
174.                                                 break;
175.                                         case 1:
176.                                                 output_low(LED1);
177.                                                 break;
178.                                         case 2:
179.                                                 output_low(LED2);
180.                                                 break;
181.                                         case 3:
182.                                                 output_low(LED3);
183.                                                 break;         
184.                                         case 4:
185.                                                 output_low(LED4);
186.                                                 break;
187.                                         case 5:
188.                                                 output_low(LED5);
189.                                                 break;
190.                                         case 6:
191.                                                 output_low(LED6);
192.                                                 break;
193.                                         case 7:
194.                                                 output_low(LED7);
195.                                                 break;         
196.                                 }
197.                                 Sensor[i].Soltado = 0;  // trabajo realizado, borramos el indicador
198.                         }
199.                 }
200.         }
201. }

Pruebas mtouch.h

Código: C

1. #FUSES INTRC_IO                 //Oscilador interno
2. #FUSES VCAP_A0                  //VCAP en pin A0
3. #FUSES NOWDT                    //No Watch Dog Timer
4. #FUSES NOPROTECT                //Código accesible
5. #FUSES PLLEN                    //PLL activado
6. #FUSES MCLR                     //Master Clear activado
7. #FUSES NOBROWNOUT               //No brownout reset
8. #FUSES NOPUT                    //No Power Up Timer    
9.  
10. #use delay (clock=8000000)
11.  
12. // No dejamos que el compilador establezca los TRIS
13. #use fast_io(A)
14. #use fast_io(B)
15. #use fast_io(C)
16. #use fast_io(D)
17. #use fast_io(E)
18.  
19. // Registros del micro
20. #byte ANSELA = 0x185
21. #byte ANSELB = 0x186
22. #byte ANSELD = 0x188
23. #byte ANSELE = 0x189
24.  
25. #byte PORTA = 0x5
26. #byte PORTB = 0x6
27. #byte PORTC = 0x7
28. #byte PORTD = 0x8
29. #byte PORTE = 0x9
30.  
31. #byte TRISA = 0x85
32. #byte TRISB = 0x86
33. #byte TRISC = 0x87
34. #byte TRISD = 0x88
35. #byte TRISE = 0x89
36.  
37. #byte T1CON = 0x010            
38. #byte T1GCON = 0x08F
39. #byte CPSCON0 = 0x108
40. #byte CPSCON1 = 0x109
41.  
42. // Bits de configuración
43. #bit TMR1GIF = 0x0C.7 // clear gate intpt flag
44. #bit TMR1GIE = 0x8C.7 // enable gate intpt
45. #bit TMR1ON = 0x10.0
46.  
47. // Salidas de leds
48. #define LED0            PIN_B1
49. #define LED1            PIN_A3
50. #define LED2            PIN_B7
51. #define LED3            PIN_C1
52. #define LED4            PIN_C2
53. #define LED5            PIN_C4
54. #define LED6            PIN_B3
55. #define LED7            PIN_B2

Agradezco a Droky toda la información que publicó sobre esta tecnología y la ayuda que me prestó cuando me estuve peleando con los QT100A.

[gera]

Gracias por compartirlo Manolo!!!
Tengo un 16f727 tirado por ahi jeje, vamos a ver si le pongo las manos encima jeje.
saludos!!

[ema]

Muy bueno manolo!!! Gracias por compartirlo.... ya lo vamos a probar.

Saludos

[droky]

Bravo Manolo!
Ya estabas tardando en poner algo con los mTouch
Te ha quedado genial la PCB y el código super depuradísimo  WOW!
En cuanto al agradecimiento... inmerecido, ha sido un placer.
Salu2

[martpic]

Hola Nosturno.... Pero el pic q usas es el 16lf727 Yo tengo unos 16f727 tu crees q haya problemas con a la hora de hacer el teclado touch????

[Nocturno]

No hay problema, funcionan igual pero a 5V, mientras que el mío lo hace a 3.3V

[Cryn]

muy buen trabajo Nocturno, felicidades, se ve muy bien el mTouch.

algún otro micro tiene ese módulo interno?

[Nocturno]

Sí, hay varios modelos. Aquí puedes verlos:
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2600&param=en535174

[fidodido18]

  estaba buscando como hacer estos teclados!! iba a mandar a comprar unos!

[Nocturno]

¡Te los vendo! 

[xocas]

¿ya tienes tu sensor de caricias?

buen trabajo, te ha quedado genial

[fidodido18]

¡Te los vendo! 

cuesta mas el envio desde europa 

[Nocturno]

¿ya tienes tu sensor de caricias?

buen trabajo, te ha quedado genial

Bien visto, querido Xocas. Será una de las aplicaciones que va a tener

[MGLSOFT]

Buenisimo!!
A ver si cuando termino lo que estoy haciendo me dedico al mtouch, que se me esta llenando de polvo!!

[jhozate]

me ha parecido una buena aplicacion esos dimmer's que vienen empotrados en la pared y que varian la intensidad deslizando el dedo en un panel, es con esto del mTouch como se logra eso?