PaperTecladoRC: Varios pulsadores utilizando una entrada digital

Descripción

Al realizar proyectos con microcontroladores, tarde o temprano nos encontraremos que no tenemos suficientes entradas y salidas (incluso con un Arduino Mega), una posibilidad es utilizar una entrada digital en la que conectamos un condensador, y medimos el tiempo que tarda en descargarse. Este tiempo lo modificaremos variando las resistencia de descarga. Controlando el tiempo de descarga podremos deducir que pulsador se ha activado.

- ¡ HUY chacho!,  ¡esto es muu complicao!!

- ¡ Que nó, hombre ! , vamos a verlo poco a poco...

Primero veamos el esquema del circuito:

Como ves en el esquema tenemos un condensador C1 , con una patilla a 5v y la otra conectada simultáneamente a una entrada/salida digital y a masa a través de un montón de resistencias.

Para verlo mejor, vamos a simplificarlo:

Lo que vamos a hacer es medir el tiempo que tarda el condensador en descargarse.  Y lo haremos en varios pasos:

1 Configuramos la patilla 2 como salida, y la ponemos a nivel alto, y esperamos un poco a que se cargue el condensador, con lo que los dos terminales del mismo condensador están a 5v.

2 Después ponemos la patilla 2 como entrada, con lo que pasa a tener una resistencia muy alta y no consume nada (dependiendo del micro, hay que quitarle las resistencias internas pull-up). El condensador se descargará a través de R a masa.

3 Finalmente medimos a través de la patilla 2, el tiempo que tarda el condensador en descargarse, es decir controlamos el estado de esa entrada hasta que esté bajo.

El tiempo de descarga variará en función del valor del la resistencia R, con lo que la sustituimos por unas cuantas resistencias en serie, que pueden ser puenteables mediante pulsadores.

En la imagen vemos que si activamos el pulsador 3, puentea las resistencias R3-R12, es decir el condensador se descargará sólamente a través de R1, R2 y R13. Por lo tanto el tiempo de descarga variará.

Si utilizamos la plataforma Arduino, podemos controlar ese tiempo mediante el programa RCTime (http://arduino.cc/en/Tutorial/RCTime), que nos envía al terminal serie del editor Arduino dicho valor. El montaje del circuito sería el siguiente:

En mi caso los valores que observo al pulsar los distintos pulsadores son:

P1:3, P2:10, P3:16, P4:22, P5:29, P6:35, P7:42, P8:48 ,P9:55, P10: 61, P11:67, P12:74 y ninguno:80.

Pero no utilizaremos estos valores, sinó los intermedios, para evitar las variaciones que pueden dar falsas lecturas. Es decir:
P1= entre 0 y 6 ->(3+10)/2
P2= entre 6 y  13 ->(10+16)/2
...

NOTA1: En el archivo de descargas tienes una tabla con los cálculos de los valores intermedios.
NOTA2: Si el valor leído oscila mucho, prueba a incrementar el tiempo de espera para que se cargue completamente el condensador (yo lo tuve que aumentar a 4 ms).

Componentes

R1-R13 Resistencias 3K3 SMD 1206   12x0,025€=0,3€
R12 3K3 1/4W                                 0,01€
R14 300 1/4W                                 0,01€
C1 0,01uF SMD                                0,015€
P1-P12 Pulsador reset              12x0,2? = 2,4?€

Un trozo de stripboard             0,5?    = 0,5?€

El coste total es de menos de 3,5 Euros en el año 2010 (no tengo ni idea del coste de los pulsadores)

Realización

Como siempre utilizaremos el método Paper que consiste en ayudarnos en unas pegatinas para facilitarnos el proceso de montaje y soldadura. Pero esta vez daremos un pasito más, ! vamos a utilizar componentes SMD !

Primero imprimiremos el documento PaperTecladoRC (disponible en la parte inferior de esta página en el apartado de descargas):

Y después de comprobar con la regla situada a la izquierda de la página impresa que está a escala 1/1, recortamos la Paperetiqueta:

Si quieres puedes protegerla pegando encima un poco de plástico autoadhesivo transparente.

Con ayuda de la paperetiqueta toma las dimensiones de un trozo de stripboard

Puedes cortarlo con una sierra, taladrín, o incluso con un cutter, para lo cual marcamos por una cara(por encima de los agujeros)...

Marcamos por la otra:

Y cortamos colocando la linea de corte sobre algún canto (como hacen los cristalesros al cortar vidrio):

Como hemos cortado sobre los agujeros, con una lija dejamos los laterales un poquito menos txapuzas:

Ahora podemos colocar algún tipo de adhesivo a la paperetiqueta (yo utilizo cinta adhesiva de doble cara):

Y con ayuda de algo puntiagudo la colocamos sobre el stripboard de modo que encajen lo agujeros dibujados con  los de la stripboard.

Después con el punzón y sobre un soporte blando, perfora todos los agujeros de la etiqueta.

Comprueba al trasluz que no te has dejado ningún agujero:

Como verás, para hacer la placa más pequeña, he hecho una txapucilla:
he cortado una de las patas de los pulsadores para que no produzcan cortocircuito (fíjate bien cual) ,

y la pata "coja" la soldamos con el interior de un trozo de cable unifilar:

Se me olvidaba! en la parte inferior tienes que cortar las pistas:

como ves en la imagen superior, he marcado la posición exacta de corte con un rotulador para no confundirme, y después de haber soldado los pulsadores, así me sirven de referencia.

Te puedes guiar de la vista inferior que tienes en el documento impreso:

Ahora viene lo difícil, soldar las diminutas resistencias y condensadores. Después de probar varias técnicas :sujetarlas con un palillo mientras se sueldan, con masilla adhesiva "Blu-Tack",...  lo que mejor me ha funcionado es con "Loctite", con ayuda de un palillo dejo una minúscula gota en la zona, luego con una pinza coloco la resistencia, espero unos segundos y ya puedo soldar.


Los tres cables de conexión también son "peculiares", el primero se suelda por la parte superior, el segundo a través de una resistencia "al aire", y el tercero por la parte inferior.

El resultado es el siguiente:

Y una vista por la parte inferior:

Si queremos dar un paso más y realizar una carcasa para nuestro teclado, lo que haremos será, primero en la hoja impresa, colocamos un poco de plástico autoadhesivo transparente, para proteger la superficie:

Después lo recortamos dejando un poco de margen:

Y hacemos lo mismo con la parte trasera, es decir protegemos con plástico y recortamos:

si quieres, puedes utilizar otra impresión de la etiqueta trasera como plantilla de corte, la recortaremos esta vez externa e internamente.:

Con esta plantilla transladamos a un trozo de cartón pluma (o cualquier material que tenga el espesor del teclado)

una ver dibujado, lo recortamos dejando margen en el exterior:

En el interior colocamos el teclado

colocamos adhesivo de doble cara en su perímetro:

Y pegamos la carátula frontal que hemos recortado anteriormente (se me ha olvidado sacar foto de este paso)
Hacemos lo mismo con la parte trasera, además como el espesor del cartón pluma que he utilizado es superior al espesor del teclado, he colocado un poco de papel para que haga de muelle. (ya sé, es una txapuza, pero,...)

Y pegamos la etiqueta trasera:

Ahora lo único que nos queda es recortar todos los márgenes (este paso hemos de hacerlo con mucho cuidado, que es el definitivo):

Y el resultado es teclado que da el "pego":

Funcionamiento

PaperTecladoRC.pde
Si utilizas Arduino, puedes utilizar este programa para comprobar su funcionamiento. Tienes que realizar el montaje siguiente:

El programa muestra mediante pitidos que tecla se ha pulsado, también envía al terminal serie del PC el código del pulsador.

/* PaperTecladoRC
   Se basa en la función RCtime que permite utilizar entradas digitales para medir
   el valor de resistencias midiendo el tiempo de descarga de un condensador,
   pero lo utilizamos para detectar que pulsador se ha accionado en el
   PaperTecladoRC, ya que cada pulsador puentea un serie de resistencias.
   El programa muestra mediante pulsaciones de un led la tecla pulsada.

* Circuito:
   Se conecta el cable de salida del PaperTecladoRC a la entrada digital 2 de Arduino,
   Y el cable de 5v y masa de PaperTeclado a 5v y masa del Arduino.
   El led indicador se colocará entre la salida 13 y masa a través de una resistencia.
   (casi todas las placas de Arduino lo traen incorporado)

Creado el 17 de Septiembre de 2010
por Iñigo Zuluaga

*/


int sensorPin = 2;              // El cable de salida de PaperTecladoRC se conecta a la entrada 2 de Arduino
int ledPin=13;                  // Led indicador en salida 13

void setup() {                  // Rutina de inicio
   Serial.begin(9600);
   Serial.println("Inicio");    // Indicador de inicio
}

void loop() {                   // Ciclo continuo
   int Pulsador=0;
   Pulsador=PaperTecladoRC(sensorPin);  // Lee el pulsador accionado
   Serial.println( Pulsador);           // imprime en el puerto serie el pulsador accionado
   if ( Pulsador<13) {                  // si se ha pulsado alguna tecla:...
      for (int cont=0; cont < Pulsador; cont++) { //enciende el led indicador un nº=Pulsador
        digitalWrite(ledPin, HIGH);     // Enciende el LED
        delay(200);                     // Espera 200 milisegundos      
        digitalWrite(ledPin, LOW);      // Apaga el LED
        delay(200);                     // Espera 200 milisegundos:
      }
   }
}


//***************************************************************
int PaperTecladoRC(int sensPin){
/*
DESCRIPCION:
  Función encargada de detectar que tecla de PaperTecladoRC se ha accionado
ENTRADAS:
  SensPin: Puerta de Arduino donde se conecta el PapeTecladoRC
SALIDA:
  Entero (1-12) indicando el pulsador accionado (ningún pulsador=99)
NOTA:
  Dependiendo de la carátula que coloquemos delante habrá que convertir los valores
 
   Posición pulsadores       Carátula teclado            SALIDA FUNCION
    ----------------          ----------------          ----------------  
    | 12 |  5 |  1 |          |  1 |  2 |  3 |          |  1 |  2 |  3 |
    ----------------          ----------------          ----------------
    | 11 |  6 |  2 |          |  4 |  5 |  6 |          |  4 |  5 |  6 |
    ----------------     >    ----------------    >     ----------------
    | 10 |  7 |  3 |          |  7 |  8 |  9 |          |  7 |  8 |  9 |
    ----------------          ----------------          ----------------
    |  9 |  8 |  4 |          |  * |  0 |  # |          | 11 | 10 | 12 |
    ----------------          ----------------          ----------------

*/

   long contador = 0;              // Contador que almacena el tiempo de descarga del condensador
   int Pulsador=0;                 // Pulsador accionado
   pinMode(sensPin, OUTPUT);       // Pone el pin sensPin como salida
   digitalWrite(sensPin, HIGH);    // Lo pone en nivel alto para cargarlo
   delay(4);                       // espera a que el condensador esté descargado
   pinMode(sensPin, INPUT);        // Pone el pin como entrada
   digitalWrite(sensPin, LOW);     // desconecta las resistencias pullups - o no funcionará
   while(digitalRead(sensPin)){    // espera hasta que el pin esté está bajo (se descargue el condensador)
      contador++;
   }
   if (contador>77) {
      Pulsador=99;                 // Ningún pulsador accionado
   }
   else if (contador>70) {
      Pulsador=1;                  // Pulsador 12 > " 1 "
   }
   else if (contador>64) {
      Pulsador=4;                  // Pulsador 11 > " 4 "                  
   }
   else if (contador>58) {
      Pulsador=7;                  // Pulsador 10 > " 7 "
   }
   else if (contador>51) {
      Pulsador=11;                 // Pulsador 9 > " * "
   }
   else if (contador>45) {
      Pulsador=10;                 // Pulsador 8 > " 0 "
   }
   else if (contador>38) {
      Pulsador=8;                  // Pulsador 7 > " 8 "
   }
   else if (contador>32) {
      Pulsador=5;                  // Pulsador 6 > " 5 "
   }
   else if (contador>25) {
      Pulsador=2;                  // Pulsador 5 > " 2 "
   }
   else if (contador>19) {
      Pulsador=12;                 // Pulsador 4 > " # "
   }
   else if (contador>13) {
      Pulsador=9;                  // Pulsador 3 > " 9 "
   }
   else if (contador>6) {
      Pulsador=6;                  // Pulsador 2 > " 6 "
   }
   else {
      Pulsador=3;                  // Pulsador 1 > " 3 "
   }
   return Pulsador;                // report results  
} 

PaperTecladoRCPiano.pde

Este es otro ejemplo muy similar al anterior, pero lo que hace es hacer sonar un altavoz piezoeléctrico con una tono diferente en función de la tecla pulsada. El circuito a montar es el siguiente (en el dibujo de montaje no se ha representado la alimentación del paperduino):

/* PaperTecladoRCPiano
   Se basa en la función "RCtime" que permite utilizar entradas digitales para medir
   el valor de resistencias midiendo el tiempo de descarga de un condensador,
   pero lo utilizamos para detectar que pulsador se ha accionado en el
   PaperTecladoRC, ya que cada pulsador puentea un serie de resistencias.
   El programa muestra sonidos la tecla pulsada, y envía al terminal serie el numero pulsado

* Circuito:
   Se conecta el cable de salida del PaperTecladoRC a la entrada digital 2 de Arduino,
   Y el cable de 5v y masa de PaperTeclado a 5v y masa del Arduino.
   Se colocará un altavoz piezoeléctrico entre la salida 13 y masa.
 
Creado el 17 de Septiembre de 2010
por Iñigo Zuluaga

*/


int sensorPin = 2;              // El cable de salida de PaperTecladoRC se conecta a la entrada 2 de Arduino
int AltavozPin=13;              // Altavoz piezoeléctrico en salida 13

void setup() {                  // Rutina de inicio
   Serial.begin(9600);
   Serial.println("Inicio");    // Indicador de inicio
}

void loop() {                   // Ciclo continuo
   int Pulsador=0;
   int Frecuencia;
   Pulsador=PaperTecladoRC(sensorPin);  // Lee el pulsador accionado
   Frecuencia=Pulsador*100;
   Serial.println( Pulsador);           // imprime en el puerto serie el pulsador accionado
   if ( Pulsador<13) {                  // si se ha pulsado alguna tecla:...
      tone(AltavozPin,Frecuencia);      // toca una "nota"
   } 
   else{                                // si no se ha pulsado ninguna
      noTone(AltavozPinPin);                   // deja de tocar
   }
}


//***************************************************************
int PaperTecladoRC(int sensPin){
/*
DESCRIPCION:
  Función encargada de detectar que tecla de PaperTecladoRC se ha accionado
ENTRADAS:
  SensPin: Puerta de Arduino donde se conecta el PapeTecladoRC
SALIDA:
  Entero (1-12) indicando el pulsador accionado (ningún pulsador=99)
NOTA:
  Dependiendo de la carátula que coloquemos delante habrá que convertir los valores
 
   Posición pulsadores       Carátula teclado            SALIDA FUNCION
    ----------------          ----------------          ----------------  
    | 12 |  5 |  1 |          |  1 |  2 |  3 |          |  1 |  2 |  3 |
    ----------------          ----------------          ----------------
    | 11 |  6 |  2 |          |  4 |  5 |  6 |          |  4 |  5 |  6 |
    ----------------     >    ----------------    >     ----------------
    | 10 |  7 |  3 |          |  7 |  8 |  9 |          |  7 |  8 |  9 |
    ----------------          ----------------          ----------------
    |  9 |  8 |  4 |          |  * |  0 |  # |          | 11 | 10 | 12 |
    ----------------          ----------------          ----------------

*/

   long contador = 0;              // Contador que almacena el tiempo de descarga del condensador
   int Pulsador=0;                 // Pulsador accionado
   pinMode(sensPin, OUTPUT);       // Pone el pin sensPin como salida
   digitalWrite(sensPin, HIGH);    // Lo pone en nivel alto para cargarlo
   delay(4);                       // espera a que el condensador esté descargado
   pinMode(sensPin, INPUT);        // Pone el pin como entrada
   digitalWrite(sensPin, LOW);     // desconecta las resistencias pullups - o no funcionará
   while(digitalRead(sensPin)){    // espera hasta que el pin esté está bajo (se descargue el condensador)
      contador++;
   }
   if (contador>77) {
      Pulsador=99;                 // Ningún pulsador accionado
   }
   else if (contador>70) {
      Pulsador=1;                  // Pulsador 12 > " 1 "
   }
   else if (contador>64) {
      Pulsador=4;                  // Pulsador 11 > " 4 "                  
   }
   else if (contador>58) {
      Pulsador=7;                  // Pulsador 10 > " 7 "
   }
   else if (contador>51) {
      Pulsador=11;                 // Pulsador 9 > " * "
   }
   else if (contador>45) {
      Pulsador=10;                 // Pulsador 8 > " 0 "
   }
   else if (contador>38) {
      Pulsador=8;                  // Pulsador 7 > " 8 "
   }
   else if (contador>32) {
      Pulsador=5;                  // Pulsador 6 > " 5 "
   }
   else if (contador>25) {
      Pulsador=2;                  // Pulsador 5 > " 2 "
   }
   else if (contador>19) {
      Pulsador=12;                 // Pulsador 4 > " # "
   }
   else if (contador>13) {
      Pulsador=9;                  // Pulsador 3 > " 9 "
   }
   else if (contador>6) {
      Pulsador=6;                  // Pulsador 2 > " 6 "
   }
   else {
      Pulsador=3;                  // Pulsador 1 > " 3 "
   }
   return Pulsador;                // devuelve el resultado  
} 

Información legal

1. Propiedad intelectual
Todos los derechos de propiedad intelectual del contenido de Txapuzas eléctronicas, están bajo una licencia Creative Commons Share-Alike, cuyo contenido podéis revisar en este enlace.
Por tanto queda permitido copiar, distribuir, comunicar públicamente la obra y hacer obras derivadas de la misma, siempre que se respeten los términos de la licencia arriba reseñada.
3. Actualizaciones y modificaciones de Txapuzas electrónicas
El autor se reserva el derecho a actualizar, modificar o eliminar la información contenida en Txapuzas eléctrónicas, y la configuración o presentación del mismo, en cualquier momento, sin previo aviso, y sin asumir responsabilidad alguna por ello.
4. Indicaciones sobre aspectos técnicos
El autor no asume ninguna responsabilidad que se pueda derivar de problemas técnicos o fallos en los equipos informáticos, que se produzcan a causa de los circuitos e ideas expuestos en el blog de txapuzas electrónicas, así como de los daños que pudieran ocasionar.
El autor se exime de toda responsabilidad ante posibles daños o perjuicios que pueda sufrir el usuario a consecuencia de errores, defectos u omisiones en la información facilitada.

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

Si tienes problemas con el enlace anterior, aquí puedes descargar todos los archivos de txapuzas

Notas
Para la realización de este proyecto se han utilizado los programas: Arduino, Inkscape, Openoffice, Gimp, Picasa, Fritzing
Si encuentras algún fallo, se te ocurre alguna mejora, o simplemente quieres hacer algún comentario, te lo agradeceré: Gracias.  :-)