TODOPIC

Microcontroladores PIC => * PROYECTOS * => Mensaje iniciado por: Nocturno en 12 de Diciembre de 2009, 13:22:16

Título: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 12 de Diciembre de 2009, 13:22:16
He estado haciendo unas pruebas con el PIC 16F727 y su capacidad de leer sensores capacitivos utilizando mTouch de Microchip (http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2599&redirects=mtouch).

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:
(http://img189.imageshack.us/img189/1082/prototipopruebasmtouch.th.jpg) (http://img189.imageshack.us/i/prototipopruebasmtouch.jpg/)

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:
(http://img192.imageshack.us/img192/2813/esquemahm.th.jpg) (http://img192.imageshack.us/i/esquemahm.jpg/)

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


Agradezco a Droky toda la información que publicó  (http://radikaldesig.blogspot.com/2009/10/teclado-capacitivo-mtouch-16-sensores.html)sobre esta tecnología y la ayuda que me prestó cuando me estuve peleando con los QT100A.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: gera en 12 de Diciembre de 2009, 14:18:34
Gracias por compartirlo Manolo!!! :-/ :-/
Tengo un 16f727 tirado por ahi jeje, vamos a ver si le pongo las manos encima jeje.
saludos!!
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: ema en 12 de Diciembre de 2009, 15:13:25
Muy bueno manolo!!! Gracias por compartirlo.... ya lo vamos a probar.

Saludos
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: droky en 12 de Diciembre de 2009, 16:06:40
Bravo Manolo!
Ya estabas tardando en poner algo con los mTouch :)
Te ha quedado genial la PCB y el código super depuradísimo  :shock: WOW!
En cuanto al agradecimiento... :oops: inmerecido, ha sido un placer.
Salu2
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: martpic en 13 de Diciembre de 2009, 00:19:14
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????
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 13 de Diciembre de 2009, 03:03:00
No hay problema, funcionan igual pero a 5V, mientras que el mío lo hace a 3.3V
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Cryn en 13 de Diciembre de 2009, 13:51:58
muy buen trabajo Nocturno, felicidades, se ve muy bien el mTouch.

algún otro micro tiene ese módulo interno?
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 13 de Diciembre de 2009, 14:19:56
Sí, hay varios modelos. Aquí puedes verlos:
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2600&param=en535174

(http://www.microchip.com/stellent/groups/designcenter_sg/documents/market_communication/~export/en535174~24~AppDezTTP~BasicLayout/101301-3.gif)
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: fidodido18 en 13 de Diciembre de 2009, 14:51:48
 :-/ estaba buscando como hacer estos teclados!! iba a mandar a comprar unos!
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 13 de Diciembre de 2009, 14:55:06
¡Te los vendo!  :D :D :D
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: xocas en 13 de Diciembre de 2009, 15:03:04
¿ya tienes tu sensor de caricias?

buen trabajo, te ha quedado genial
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: fidodido18 en 13 de Diciembre de 2009, 15:07:06
¡Te los vendo!  :D :D :D

cuesta mas el envio desde europa  :mrgreen:
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 13 de Diciembre de 2009, 15:13:35
¿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
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: MGLSOFT en 13 de Diciembre de 2009, 15:55:22
Buenisimo!!
A ver si cuando termino lo que estoy haciendo me dedico al mtouch, que se me esta llenando de polvo!!
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: jhozate en 13 de Diciembre de 2009, 17:33:26
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?
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 13 de Diciembre de 2009, 17:58:57
Sí, supongo que será con algo parecido.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: stk500 en 13 de Diciembre de 2009, 18:06:09
Chiquillo que callado te lo tenia :shock: :shock:     :x :x
 y ni me avisaste  :?

Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 13 de Diciembre de 2009, 18:31:09
Y pensar que ese micro ha pasado por tu casa  :D
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: stk500 en 13 de Diciembre de 2009, 19:39:42
Y pensar que ese micro ha pasado por tu casa  :D

que malo eres  :D :D y ni me avisaste  :D :D
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Suky en 13 de Diciembre de 2009, 20:32:27
 :shock: Guauu!!! No sabia ni que existían estos micros con esos módulo  :D excelente trabajo Manolo  ;-)

Chiquillo que callado te lo tenia :shock: :shock:     :x :x
 y ni me avisaste  :?

mmm... puede ser que haya tenido miedito que no salga  y mejor tenerlo oculto!  :D :D Pero salio!!!  :mrgreen:


Saludos!
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: JOJOJORGE5 en 13 de Diciembre de 2009, 21:11:06
Gracias por el aporte.

Esta tecnología apenas la estoy conociendo pero parece muy interesante.
Algunas preguntas:
¿Que pasa cuando presionas mas de 1 tecla al mismo tiempo?
¿Y que pasa con los rebotes o es que no tienen algo parecido estos sensores?
¿Como le afecta el ruido? ¿mucho? ¿poco?

Creo que es todo, espero no molestar.

salu2:)


Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 13 de Diciembre de 2009, 21:36:54
Las teclas se detectan en un bucle que va recorriéndolas todas. Si hay varias pulsadas, cuando el bucle llegue a su turno la reconocerá sin más.

Sí hay rebotes, y si te fijas en el código fuente está resuelto con una doble lectura.

No tengo experiencias con el ruido, estoy empezando con esto.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: PAWA en 20 de Abril de 2010, 20:38:02
Felicidades Nocturno muy buen aporte.
En tu circuito esta montado todo en la placa (botones y micro)
Se puede hacer la placa con el micro y el circuito y mandar cables a otra placa donde solo esten los botones funcionaria de igual manera?

Saludos.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 21 de Abril de 2010, 01:53:11
Pues no lo he probado, aunque imagino que si lo haces no podrás ir muy lejos con los cables.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: PAWA en 21 de Abril de 2010, 17:06:54
Voy a hacer pruebas ya que me lleguen los micros y les comento si se puede.

Por otro lado Nocturno me encontre que en la version 4.100 de CCS ya estan la librerias para hacerlo.

Te anexo link de CCS  CCS info forum http://www.ccsinfo.com/forum/viewtopic.php?t=42107 (http://www.ccsinfo.com/forum/viewtopic.php?t=42107)

Saludos.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 21 de Abril de 2010, 17:39:40
¡Anda, qué bien!
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: facuenta en 15 de Febrero de 2011, 16:00:52
Qué bueno como quedó!! Felicitaciones Nocturno!
Y ahora? si lo quiero hacer para un chasis de metal... en vez de hacerlo capacitivo lo tengo que hacer inductivo... pero que circuito se recomienda para eso? alguien sabe?

Abrazo,
Facundo
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: PulKon en 13 de Marzo de 2011, 00:17:45
Nocturno,

Felicitaciones que buena aplicación.

Me gustaría hacer una aplicación similar con solo 6 botones, pero solo medio entiendo el lenguaje ensamblador y nada de CSS, si sabes de alguna información que exista para hacerlo en ensamblador, te agradecería lo comentaras.

Saludos.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 13 de Marzo de 2011, 04:15:39
Pues no tengo ni idea, pero seguramente encontrarás alguna Application Note en la web de Microchip.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Strepto en 09 de Febrero de 2012, 19:16:49
Buenas!

Estoy metido en un projecto en el que necesito añadir un teclado y añadir algun boton mas y por necesidades del diseños, me vendria genial que estos fuesen tactiles. Ahora viene la pregunta, alguien ha probado a programas estos Pics con los controles que trae el CCS¿? O hay que hacer alguna cosilla mas?

Código: [Seleccionar]
touchpad_state( )
touchpad_getc( )
touchpad_hit( )
#USE TOUCHPAD ( )

Lo pregunto porque todavia no he tenido la opcion de jugar con este sistema, mtouch, y en caso de tener que implementar alguna cosa mas, podria ir mirandomelo mientras me llegan los Pics.

Un saludo!
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: huichoman en 10 de Febrero de 2012, 02:41:07
Wooooow

Desconocía esos micros. Se me están ocurriendo muchas aplicaciones jejejeje.

Gracias Nocturno por la info.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 10 de Febrero de 2012, 02:55:12
alguien ha probado a programas estos Pics con los controles que trae el CCS¿? O hay que hacer alguna cosilla mas?


Sí, yo lo he probado, y la verdad es que funciona genial, con una simplicidad alucinante.

Sólo tienes que definir los botones que usarás al principio:

#use touchpad(scantime=32ms,threshold=6,PIN_B0='0',PIN_B1='1',PIN_B2='2')

Y luego en tu programa, preguntas si hay algo pulsado con:
      if(touchpad_hit())

y si hubiera algo pulsado, averiguas cuál es con:
         c=touchpad_getc();


Funciona de categoría.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: huichoman en 10 de Febrero de 2012, 02:59:40
Y son muy baratos esos micros  :grin:

Se pueden crear paneles touch con acrilico.

Tengo pensado comprar una máquina CNC, con eso quedarían acabados buenísimos.

^^ no podré dormir hoy pensando que hacer con esos micros   :-/
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: MGLSOFT en 10 de Febrero de 2012, 08:13:49
Tiene un solo problema, no puede leer una combinación de botones (touch) pulsados juntos.
Por ejemplo si quiero hacer Alt + 2 , las funciones de CCS no lo contemplan, y entiendo que en C18, con las funciones de Mchip, si se puede...
Por lo demás, lo que dice Nocturno, va de lujo...
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 10 de Febrero de 2012, 09:14:50
Efectivamente, las funciones de CCS no estan diseñadas para multipulsación. Pero sí se puede hacer en CCS sin usarlas.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: ALE1973 en 10 de Febrero de 2012, 09:23:55
Manolo, si delante de los pulsadores, colocas un acrilico por ejemplo, que espesor máximo tiene que ser para que todo siga funcionando bien?, Has hecho esa prueba?

Saludos.
Alejandro.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Strepto en 10 de Febrero de 2012, 10:07:13
Muchas gracias pir las aclaraciones! Me habeis alegrado el dia! Ahora solo me queda esperar a que me lleguen los samples que pedir para probarlos y luego dar un paso adelante en el proyecto.

 
Manolo, si delante de los pulsadores, colocas un acrilico por ejemplo, que espesor máximo tiene que ser para que todo siga funcionando bien?, Has hecho esa prueba?

Tambien estoy interesado en esa pregunta.

Un saludo!
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Nocturno en 10 de Febrero de 2012, 13:33:02
Aún estoy probando y desarrollando el firmware. Cuando termine de hacer todas las pruebas os diré cuál es el máximo espesor que he conseguido y os pondré el correspondiente vídeo.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: Strepto en 10 de Febrero de 2012, 13:44:13
Aún estoy probando y desarrollando el firmware. Cuando termine de hacer todas las pruebas os diré cuál es el máximo espesor que he conseguido y os pondré el correspondiente vídeo.

Perfecto! Muchas gracias de antemano!

Un saludo!
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: ALE1973 en 10 de Febrero de 2012, 14:57:25
Gracias Manolo.

Saludos.
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: danning1 en 28 de Junio de 2012, 05:17:42
disculpen, intente manipular el programa para poder adecuarlo a 11 sensores, pero no consegui nada mas que errores :x, me podrian indicar como poder activar y que sean detectados, los sensores 12, 13  y 14? saludos :)
Título: Re: mTouch de Microchip: en CCS y en español
Publicado por: jel_75 en 24 de Enero de 2013, 07:40:57
Antes que nada, muchas gracias a Nocturno por este impresionante trabajo que realizo.

Ahora el pedido de ayuda
Necesito encender un led mientras se apoya un dedo sobre el pad tactil de un pic12f1840, intente con las funciones mtouch de ccs y no sirven por que solamente detentan el cambio de No-Pulsado a Pulsado y si sigues teniendo el dedo apoyado o no le da lo mismo.

Adjunto el codigo fuente modificado por si Nocturno o alguien mas me uede dar una mano.

Archivo: test.h
Código: [Seleccionar]
#FUSES INTRC_IO                 //Oscilador interno
//#FUSES VCAP_A0                  //VCAP en pin A0
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES NOPROTECT                //Código accesible
//#FUSES PLLEN                    //PLL activado
#FUSES NOMCLR                     //Master Clear activado
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOPUT                    //No Power Up Timer   
 
#use delay (clock=8000000)
 
// No dejamos que el compilador establezca los TRIS
#use fast_io(A)

 
// Registros del micro
#byte ANSELA = 0x18C
 
#byte PORTA = 0x00C
 
#byte TRISA = 0x08C
 
#byte T1CON = 0x018       
#byte T1GCON = 0x019
#byte CPSCON0 = 0x01E
#byte CPSCON1 = 0x01F
 
// Bits de configuración
#bit TMR1GIF = 0x011.7 // clear gate intpt flag
#bit TMR1GIE = 0x091.7 // enable gate intpt
#bit TMR1ON = 0x018.0
 
// Salidas de leds
#define LED            PIN_A1



Archivo: test.c
Código: [Seleccionar]
/*
   mTouch con 12F1840
   Modificacion de del codigo de Manuel Jiménez - Nocturno 2009
   www.micropic.es
*/
 
#include <12F1840.H>  //16LF727.h>
#include <test.h>
 
#define ANTIRREBOTES 1
#define SENSIBILIDAD 5
 
// unsigned char indice;
unsigned long lectura;             // lectura de cada sensor
unsigned long promedio;             // promedio leído de cada sensor
unsigned long umbral;                // umbral que debe superar para que se considere pulsado
unsigned long promedio_alto;          // variable temporal de promedio alto
unsigned long promedio_bajo;          // variable temporal de promedio bajo
 
 
// Estructura de información de los sensores
   unsigned char rebotes;
   int1 Pulsado;
   int1 SePulso;
   int1 Soltado;


 
/***********************************************************************************************
                     INICIALIZACIÓN
***********************************************************************************************/
void inicializacion() {

   promedio = 0;
   lectura = 0;
   
   
   /* Utilizaremos este sensor:
   CPS2:   RA2 
   */
   
   ANSELA = 0b00000100;        //SELECCIONAMOS COMO ENTRADA ANALOGICA RA2
   set_tris_a (0b00001100);  // SELECCIONAMOS COMO ENTRADAS RA2 Y RA3
   
     
   //setup_timer_2(T2_DIV_BY_16,0xB4,15);// Timer2 activo, prescaler 1:16   REVISAR  Y T1GCON
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256|RTCC_8_bit);
   setup_timer_1(T1_GATE_INVERTED);    // Timer1 activo, asociado al sensor capacitivo y sin prescaler
   T1GCON = 0b11100001;        // Timer1 gate activo, y asociado al Timer0 ya no al 2
   
   CPSCON0 = 0b11001100;             // Activamos los sensores capacitivos
   CPSCON1 = 0x02;                // y ahora usamos CPS2 que es RA2
                       
   
   TMR1GIF = 0;                   // Borramos el flag de interrupción
   TMR1GIE = 1;                   // Activamos la interrupción del Timer1 Gate
   enable_interrupts(GLOBAL);         // Activamos la gestión de interrupciones
   
 
   output_HIGH(LED);               // Apagamos los leds
 
}
/***********************************************************************************************
                     RUTINA DE INTERRUPCIÓN
***********************************************************************************************/
 
#INT_DEFAULT
void GestionDeInterrupciones() {
   if (TMR1GIF && TMR1GIE) {         // Interrupción del Timer1 Gate
      TMR1GIF = 0;                // Borramos el flag de interrupción
      TMR1ON = 0;                // Paramos el timer1
     
      // Cálculo de la media móvil de los últimos 4 ciclos
      lectura = promedio_alto = get_timer1() * 4;
      promedio_bajo = promedio / 4;
      umbral = promedio>>SENSIBILIDAD;
     
      // Si ha pulsado, veremos que el Timer se ha acortado, por debajo del promedio - umbral
      if (promedio_alto < promedio - umbral) {
         // Chequeo repetitivo para evitar rebotes
         if(rebotes < ANTIRREBOTES) rebotes++;
            if(!SePulso && rebotes == ANTIRREBOTES) {
               Pulsado = 1;
               SePulso = 1;
               }
         } else {
         // Si no ha pulsado y estamos en ciclo de rebotes
         if(rebotes > 0) rebotes--;
         if(SePulso && rebotes == 0) {
            SePulso = 0;
            Soltado = 1;
            }
         // Al promedio acumulado le restamos el valor antiguo y le metemos el nuevo
         promedio += promedio_alto/4 - promedio_bajo;
         }
      set_timer1(0);               // Iniciamos la cuenta en el Timer1
      TMR1ON = 1;                // Activamos nuevamente el Timer1
                 
   }
}
 
/***********************************************************************************************
                     PROGRAMA PRINCIPAL
***********************************************************************************************/
void main() {
   
   inicializacion();
   
   output_low(LED);   //enciendo y apago al principio para verificar el led
   delay_ms(3000);
   output_high(LED);
   
   while (true) {                   // bucle infinito
            delay_ms(1000);         // incluyo un led testigo de que no se ha colgado
            output_toggle(PIN_A4);  // solo para probar
            if(Pulsado) {      // se ha detectado pulsación
                  output_LOW(LED);
            Pulsado = 0;   // trabajo realizado, borramos el indicador         
         } else if(Soltado) {   // se ha quitado el dedo
                output_HIGH(LED);
                Soltado = 0;   // trabajo realizado, borramos el indicador
         }
      }
   }

desde ya muchas gracias.