¡Hola, amigos!. ¡Pasad, por favor!. ¡Ponéos cómodos! Hoy vamos a complicarnos la vida con una práctica basada en el uso de nuestra querida Arduino y su posibilidad de utilizar superficies conductoras (el Aluminio, en nuestro caso) como sensores capacitivos, con el uso de la librería #CapacitiveSensor, para construir un piano de suelo, al estilo de una de las escenas más recordadas de un viejo clásico de Tom Hanks, BIG. ¿Cómo hacerlo?. ¡Sigue leyendo!

 De hecho, si quieres hacerte una idea de lo que aparecería en la pantalla del ordenador, puedes probar con este pequeño sketch (eso sí, no es exactamente igual, porque lo he tenido que traducir de Processing a P5.JS, pero ya te harás una idea de la diferencia si terminas montándolo tú):

 ¿Qué es un sensor capacitivo?

Básicamente, un sensor capacitivo es cualquier dispositivo que aprovecha la conductividad de la piel humana al tocar o acercarse a una superficie conductora que está a una tensión en corriente continua (MILIVOLTIOS, POR SUPUESTO... NO ME SEÁIS GAÑANES). Esta superficie conductora, conectada a una resistencia lo suficientemente grande (del rango de los 5 megaohmios en nuestro diseño), tenderá a descargar una intensidad pequeñísima  a través de nuestro cuerpo cuando la toquemos o nos acerquemos a una distancia suficientemente pequeña (si estuviéramos descalzos, o tocamos con las manos, podríamos configurarlo para que reaccionara a 3-5 cm de distancia).

El enfoque es que nuestros sensores (las teclas del piano) forman parte de un circuito RC entre dos pines de nuestro Arduino que están en contacto a una tensión de 5 V. Uno es el transmisor (sender) y otro el receptor (receiver). En el momento en el que se toque el condensador de nuestro sensor, se producirá una descarga de dichos 5 V a través de nuestro cuerpo hacia el suelo. Utilizaremos una librería muy extendida en Arduino, CapacitiveSensor (ya sabéis... si no la tenéis instalada, poneos a ello en primer lugar), que medirá el tiempo que tarda en cambiar la señal de 5 V de un pin a otro, obra de la rapidez de descarga del condensador.

Lo sé, lo sé... suena muy denso y difícil. Mejor que yo lo explican en este artículo de Arduino Playground. Echad un vistazo si necesitáis más información al respecto

¡En fin!. Que vamos a montar ocho sensores en el suelo que harán las veces de las teclas de un piano, conectados a un circuito que enviará la información correspondiente en cada momento a nuestra Arduino. A través del puerto Serie, la Arduino enviará la información de las teclas que se estén pisando a un ordenador corriendo un programa en Processing que a su vez utilizará la librería Minim para generar el sonido en forma de nota musical. Aquí unas imágenes del conjunto:

¿Qué necesitamos?

Como en esta web no queremos ser menos que en sitios mucho más profesionales, académicos, y en suma, molones, no queremos dejar pasar la oportunidad de ofreceros la lista de materiales necesarios, que tengo yo visto que se hace mucho en el mundo maker. Otra cosa distinta es que esa lista esté completa. O que podáis acceder fácilmente a todos los elementos de esa BOM (Bill of Materials, para los no iniciados). O que no podáis hacer lo mismo mucho más fácilmente con un conjunto más simple, limitado y barato de elementos (como por ejemplo, una pajita de refresco y un chicle mascado). Pero, ¡qué diablos!. Hemos venido a jugar.

• Madera de tipo aglomerado o DM para alojar las teclas, así como restos de listones de madera cuadrados, de 15x15 o 20x20
• Bornas eléctricas de conexión para 1,5-2,5 mm2 para las teclas.
• Un poco de cable flexible de 1,5-2-5 mm2 de los que se usan en circuitos eléctricos.
• Un perfil de aluminio semi-curvo
• Alrededor de 2-3 m de cable para cada una de las 8 teclas, preferiblemente de distintos colores (para no mezclar)
• 8 resistencias de 5 a 10 megaohmios
• Una placa perforada de las que se suele utilizar para soldar PCB's caseras
• Bornes de conexión por tornillo para PCB
• Una Arduino Nano o Uno (por supuesto).

Montando las "teclas" del piano

Como decíamos antes, el principio físico de cada tecla es montar algún tipo de superficie conductora que podamos pisar. Así que vamos a cortar unos trozos de madera de la que solemos tener en el taller, normalmente aglomerado chapado, de un tamaño adecuado. En mi caso, unos 20x20 cm. También cortaremos el perfil curvo de aluminio en ocho trozos, cada uno de los cuales se asegurará sobre la base de madera mediante un tornillo y una tuerca con sus correspondiente arandelas (por arriba y por abajo). Para evitar que cada "tecla" toque el suelo, improvisamos también  unas "patas" cortando los restos de listones, como sugieren las imágenes que acompañan a estas líneas.

En la ilustración de la izquierda puede apreciarse también que en cada "tecla" atornillaremos un borne de conexión que comunicará el correspondiente cable que irá a la Arduino con la superficie conductora constituida por el perfil de aluminio. Notad también que uno de los mayores problemas será garantizar, con los rústicos medios de que disponemos, la conductividad con dicho perfil, que en nuestro caso estamos asegurando con una arandela por arriba que conectará eléctricamente a nuestro cable flexible por presión (véase la foto de la derecha).

Además hay que decir que para asegurar las "patas" de cada tecla hechas con trozos de listón cuadrado, podemos optar por dos opciones: una, clavarlas directamente (para lo que hay que vigilar el tamaño del clavo que usamos, preferiblemente de cabeza perdida, además de tener una cierta pericia con el martillo), lo que cuando dejas a alumnos de la ESO al cargo puede resultar en varias "patas" partidas.

La segunda opción (mucho más cobarde y chapucera, dónde va a parar, pero estamos hablando de mí, chicos. No soy ningún héroe, y la calidad estética no es uno de mis estándares) es PEGARLAS directamente. Ya está. Ya lo he dicho. Qué peso me he quitado de encima. Adelante, lapidadme.

 Circuito electrónico

Necesitaremos nueve pines de nuestra Arduino: el número 4 en nuestro diseño será el encargado de enviar la señal (sender), y los pines de 2 a 9 serán los receptores (receiver), de acuerdo a los esquemas que se adjuntan a continuación. Si no te gusta esta distribución, puedes cambiarla. (Lo reconozco, es una distribución al azar, a medida que iba desarrollando mi propia idea a partir de ejemplos de uso de la librería CapacitiveSensor que es el corazón de este montaje).

El circuito esquemático quedaría así:

En realidad es un circuito muy sencillito: hay que poner una resistencia  entre cada pin (Do-Re-Mi-Fa-Sol-La-Si-Do desde el 2 hasta el 10) y el pin "sender", que es el 4, y desde el punto de contacto de la resistencia con el pin 4, tiraremos un cable que irá hasta la superficie conductora (nuestra "tecla"). Aquí un esquema para protoboard:

Yo, por mi parte, he soldado una pequeña PCB con las ocho resistencias y bornas de conexión para PCB con apriete de tornillo (y te recomiendo que hagas lo mismo si buscas un montaje algo más estable, dado la cantidad de metros de cable que vamos a desenrrollar a continuación):

Calibrando las teclas

Ahora necesitamos saber qué valores registrará cada sensor en nuestra Arduino con la librería CapacitiveSensor. Para ello, primero cargaremos un programa que mide los valores en cada pin y los pasa al puerto Serie, para que decidamos a partir de qué valor queremos que la Arduino envíe al ordenador una señal de que se ha pisado una tecla determinada. Para ello, necesitaremos tener en cuenta dos cosas:

1. Necesitamos tener instalada en nuestra Arduino la librería CapacitiveSensor (obvio).
2. Para que todo funcione, el circuito electrónico DEBE TENER UNA BUENA TOMA DE TIERRA. Esto es fundamental. Lo repetiré. UNA BUENA TOMA DE TIERRA. Tenéis varias opciones, como por ejemplo, conectar el pin GND a una estructura metálica, pero para mí lo más sencillo es ALIMENTAR LA ARDUINO DESDE UN ORDENADOR QUE ESTÉ CONECTADO A UN ENCHUFE CON TOMA DE TIERRA. Sin esto, el rango de medición de la librería se tornará muy confuso. Recordadlo. NECESITÁIS UNA BUENA TOMA DE TIERRA.

Bueno, con toda la instalación hecha, cargamos en nuestro Arduino el siguiente código:

/*Sketch para configurar 8 sensores capacitivos
 * Antonio Gómez García
 * IES Eduardo Valencia y Maestro Juan de Ávila
 * Esto es software abierto y podéis copiarlo, modificarlo
 * y distribuirlo a vuestro gusto, pero al menos mencionadme, malditos
 * This is Open Source Software. You can copy, modify and share it
 * whatever the way you choose, but you better damned mention me.
 */
 //Incluir libreria
#include<CapacitiveSensor.h>
//Definimos los sensores capacitivos desde la patilla 4 (sender)
//a los pines 2-10 (receiver)
CapacitiveSensor cs_4_2 = CapacitiveSensor(4,2); 
CapacitiveSensor cs_4_3 = CapacitiveSensor(4,3); 
CapacitiveSensor cs_4_5 = CapacitiveSensor(4,5); 
CapacitiveSensor cs_4_6 = CapacitiveSensor(4,6); 
CapacitiveSensor cs_4_7 = CapacitiveSensor(4,7); 
CapacitiveSensor cs_4_8 = CapacitiveSensor(4,8); 
CapacitiveSensor cs_4_9 = CapacitiveSensor(4,9); 
CapacitiveSensor cs_4_10 = CapacitiveSensor(4,10); 
void setup() { 
  //Inicializamos puerto serie 
  Serial.begin(9600); 
  } 
  void loop() { 
    //Definimos nuestras teclas. Si el valor por defecto no os sirve, cambiadlo por otro más bajo o más alto. 
    long total1 = cs_4_2.capacitiveSensor(80);//Do 
    long total2 = cs_4_3.capacitiveSensor(80);//Re 
    long total3 = cs_4_5.capacitiveSensor(80);//Mi 
    long total4 = cs_4_6.capacitiveSensor(80);//Fa 
    long total5 = cs_4_7.capacitiveSensor(80);//Sol 
    long total6 = cs_4_8.capacitiveSensor(80);//La 
    long total7 = cs_4_9.capacitiveSensor(80);//Si 
    long total8 = cs_4_10.capacitiveSensor(80);//Doooo (léase con voz en falsete) 
    //Imprimimos valores 
    Serial.print(total1); 
    Serial.print("\t"); 
    Serial.print(total2); 
    Serial.print("\t"); 
    Serial.print(total3); 
    Serial.print("\t"); 
    Serial.print(total4); 
    Serial.print("\t"); 
    Serial.print(total5); 
    Serial.print("\t"); 
    Serial.print(total6); 
    Serial.print("\t"); 
    Serial.print(total7); 
    Serial.print("\t"); 
    Serial.println(total8); 
    delay(10); 
    } 
}

Este código os permitirá hacer una primera lectura a través del puerto serie de lo que está pasando en cada sensor. Haced varios ensayos con cada "tecla" del piano. Pisadlos y levantad el pie, y observad en la pantalla cómo cambia la lectura en el puesto correspondiente de la ventana del puerto serie.  Al final, tendréis que decidir qué valor podéis elegir como umbral para que Arduino decida que alguien está pisando la tecla o no, siendo este valor la diferencia entre pisar o no pisar la tecla (por ejemplo, si al pisar una tecla, obtenemos valores de alrededor de 2500, mientras que al levantar el pie el rango de lecturas anda por los 2300, el valor umbral sería de unos 200. Dicho valor no tiene que ser exacto, pero tiene que implicar una diferencia clara entre pisar o no pisar cada tecla).

Ya nos hemos decidido por los valores que haremos actuar como umbrales de detección... ¿Y ahora qué?

Pues estamos a punto de empezar a oir (o sufrir) nuestro piano de suelo. En primer lugar, cargaremos un nuevo código en nuestra Arduino. No me voy a molestar en intentar explicarlo, es relativamente largo. De todos modos, aquí tenéis un resumen de su funcionamiento:

• Incluyendo la librería <CapacitiveSensor.h>, declara e inicializa ocho sensores
• Al principio del programa, declaramos un valor int llamado umbral, y lo inicializamos con el valor que hayamos decidido antes (en mi caso, está a 200).
• Hay ocho variables (de nota1 a nota8) que recogen el último valor leído desde el último cambio de estado. Empiezan valiendo 0, e irán cambiando durante el funcionamiento del programa.
• Se irá leyendo cada sensor, cuyo valor será almacenado por una variable (de total1 a total8) que se comparará con la correspondiente variable notaX). Si hay una variación que supera el valor que hemos definido como umbral, notaX pasa a guardar el valor enviado por totalX, enviando un valor a través del puerto Serie (que escuchará el programa de Processing en el ordenador) en el caso de que totalX>notaX+umbral (señal de que estamos pisando una tecla). Hay un valor distinto por cada tecla.
• Este programa debería incluir una función de handshaking (choque de palmas) que garantice la fluidez en la comunicación entre Arduino y Processing, algo que tengo en mente, pero aún en proyecto.

Aquí tenéis el código a volcar en Arduino:

#include <CapacitiveSensor.h>

/*
 * Lectura de 8 sensores capacitivos en Arduino para piano de suelo
 * Antonio Gómez García 2018
 * Este programa es Open Source.Podéis copiar, modificar y distribuirlo
 * ¡Pero al menos mencionadme!
 */

//Definiendo los ocho sensores capacitivos
    CapacitiveSensor   cs_4_2 = CapacitiveSensor(4,2);        
    CapacitiveSensor   cs_4_3 = CapacitiveSensor(4,3);       
    CapacitiveSensor   cs_4_5 = CapacitiveSensor(4,5);        
    CapacitiveSensor   cs_4_6 = CapacitiveSensor(4,6);       
    CapacitiveSensor   cs_4_7 = CapacitiveSensor(4,7);        
    CapacitiveSensor   cs_4_8 = CapacitiveSensor(4,8);       
    CapacitiveSensor   cs_4_9 = CapacitiveSensor(4,9);        
    CapacitiveSensor   cs_4_10 = CapacitiveSensor(4,10);        
//Este valor es el que definimos como valor umbral, y lo habremos decidido leyendo el puerto serie después de cargar el programa anterior
long umbral=200;
//Las notas 1 a 8 recogerán el último valor leído
long nota1=0;
long nota2=0;
long nota3=0;
long nota4=0;
int nota5=0;
int nota6=0;
int nota7=0;
int nota8=0;

void setup()                    
{
//Inicializamos el puerto serie
   Serial.begin(9600);
}

void loop()                    
{
//Leyendo la nota Do
    long total1 =  cs_4_2.capacitiveSensor(80);
if (total1>nota1+umbral){
  Serial.write('1');
  delay(500);
  nota1=total1;
}
if (nota1>total1+umbral){
nota1=total1;
}
//Leyendo la nota Re
        long total2 =  cs_4_3.capacitiveSensor(80);
if (total2>nota2+umbral){
  Serial.write('2');
  delay(500);
nota2=total2;
}
if (nota2>total2+umbral){
nota2=total2;
}
//Leyendo la nota Mi
          long total3 =  cs_4_5.capacitiveSensor(80);
if (total3>nota3+umbral){
  Serial.write('3');
  delay(500);
nota3=total3;
}
if (nota3>total3+umbral){
nota3=total3;
}    
//Leyendo la nota Fa
          long total4 =  cs_4_6.capacitiveSensor(80);
if (total4>nota4+umbral){
  Serial.write('4');
  delay(500);
nota4=total4;
}
if (nota4>total4+umbral){
nota4=total4;
}   
//Leyendo la nota Sol
          long total5 =  cs_4_7.capacitiveSensor(80);
if (total5>nota5+umbral){
  Serial.write('5');
  delay(500);
nota5=total5;
}
if (nota5>total5+umbral){
nota5=total5;
} 
//Leyendo la nota La
          long total6 =  cs_4_8.capacitiveSensor(80);
if (total6>nota6+umbral){
  Serial.write('6');
  delay(500);
nota6=total6;
}
if (nota6>total6+umbral){
nota6=total6;
}   
//Leyendo la nota Si
          long total7 =  cs_4_9.capacitiveSensor(80);
if (total7>nota7+umbral){
  Serial.write('7');
  delay(500);
nota7=total7;
}
if (nota7>total7+umbral){
nota7=total7;
}   
//Leyendo la nota Do
    long total8 =  cs_4_10.capacitiveSensor(80);
if (total8>nota8+umbral){
  Serial.write('8');
  delay(500);
nota8=total8;
}
if (nota8>total8+umbral){
nota8=total8;
}   
    delay(10);                             

}

 ¿Ya lo habéis volcado?. Muy bien. Ahora vamos a ejecutar el programa de Processing que escuchará al puerto Serie (importante: si teníais abierta la ventana del puerto serie en el IDE de Arduino, hay que cerrarla. Este puerto sólo trabaja con una conexión a la vez, y si no lo hacéis Processing no encontrará a vuestra Arduino.

Algunas cositas sobre el código en Processing:

• Necesitáis instalar la última versión (en realidad, vale cualquiera, pero bueno) de la librería Minim, imprescindible para trabajar con sonido en Processing.
• Recordad que al principio del programa, en setup(), hay una instrucción que realiza la conexión con el puerto serie: miPuerto = new Serial(this, Serial.list()[X], 9600); La X es el número del puerto serie correspondiente a vuestra arduino. Si no sabéis cual es, ejecutad el programa la primera vez (aunque falle), y observad la salida de la consola. El número corresponderá al último puerto que leáis ahí, empezando desde el 0. Por ejemplo, si en consola tenéis la salida COM1 COM2 COM3, pues vuestro puerto será el número 2 (0,1 y 2).
• Se generará un objeto AudioOutput (perteneciente  a la clase Minim) por cada nota del piano. Dicho objeto generará una nota en la frecuencia de la nota deseada si por el puerto Serie se envía desde Arduino el valor correspondiente. Las propiedades de dicho objeto nos permitirán dibujar en pantalla una cuerda que "vibrará" con la nota de la frecuencia deseada.
• Hasta que mejore el código con una función de handshaking, el programa se limitará a leer el puerto serie de forma continua y dibujar ocho cuerdas en pantalla. Cuando llegue un valor (por ejemplo, "3" para "Mi") se generará la nota correspondiente por la salida de audio durante un tiempo de un segundo y la cuerda correspondiente vibrará.

¡Y basta de perder tiempo!. ¡Aquí tenéis el programa!. ¡Ejecutadlo y disfrutad!.

/*
/* Sketch para leer valores de sensores capacitivos y 
 * convertirlos en las notas de un piano de suelo
 * Antonio Gómez García
 * IES Eduardo Valencia y Maestro Juan de Ávila
 * Esto es software abierto y podéis copiarlo, modificarlo
 * y distribuirlo a vuestro gusto, pero al menos mencionadme, malditos
 * This is Open Source Software. You can copy, modify and share it
 * whatever the way you choose, but you better damned mention me.
 */
 
//Importamos las librerias minim y serial
import ddf.minim.*;
import processing.serial.*;
import ddf.minim.ugens.*;
//Creamos un objeto minim que controlara la reproduccion de
//canciones, y ocho objetos AudioOutput (uno por nota)
Minim minim;
Serial miPuerto;
AudioOutput out,out2,out3,out4,out5,out6,out7,out8;
int ancho, alto, espacio;

String textoNota;
void setup()
{
size(800, 600);
 ancho=width;
 alto=height;
 espacio=ancho/8;
minim = new Minim(this);
  println(Serial.list());
  // Abre el puerto que se este usando a la velocidad deseada
  //Tener en cuenta que hay que elegir el numero correspondiente
  //al puerto COM que estemos usando en Arduino, y ponerlo
  //en Serial.list[x]
  miPuerto = new Serial(this, Serial.list()[32], 9600);


out=minim.getLineOut();
out2=minim.getLineOut();
out3=minim.getLineOut();
out4=minim.getLineOut();
out5=minim.getLineOut();
out6=minim.getLineOut();
out7=minim.getLineOut();
out8=minim.getLineOut();
textSize(64);
textoNota="";

}

void draw()
{
 background(255,255,255);

 text(textoNota,width/2-37,height/2-37);
stroke(0,0,255);
fill(0,0,255);

           for(int i =0; i <out.left.size()-1; i++){
  line(espacio + out.left.get(i)*50,i,espacio + out.left.get(i+1)*50 , i+1);
 
}
stroke(255,0,0);
fill(255,0,0);

           for(int i =0; i <out2.left.size()-1; i++){
  line(2*espacio + out2.left.get(i)*50,i,2*espacio + out2.left.get(i+1)*50 , i+1);
 
}
stroke(255,255,0);
fill(255,255,0);

           for(int i =0; i <out3.left.size()-1; i++){
  line(3*espacio + out3.left.get(i)*50,i,3*espacio + out3.left.get(i+1)*50 , i+1);
 
}
stroke(0,255,0);
fill(0,255,0);

           for(int i =0; i <out4.left.size()-1; i++){
  line(4*espacio + out4.left.get(i)*50,i,4*espacio + out4.left.get(i+1)*50 , i+1);
 
}

stroke(255,164,32);
fill(255,164,32);

           for(int i =0; i <out5.left.size()-1; i++){
  line((5*espacio) + out5.left.get(i)*50,i,(5*espacio)+ out5.left.get(i+1)*50 , i+1);
 
}
stroke(117,45,29);
fill(117,45,29);

           for(int i =0; i <out6.left.size()-1; i++){
  line((6*espacio) + out6.left.get(i)*50,i,(6*espacio)+ out6.left.get(i+1)*50 , i+1);
 
}
stroke(93,29,117);
fill(93,29,117);

           for(int i =0; i <out7.left.size()-1; i++){
  line((7*espacio) + out7.left.get(i)*50,i,(7*espacio)+ out7.left.get(i+1)*50 , i+1);
 
}
stroke(130,130,130);
fill(130,130,130);

           for(int i =0; i <out8.left.size()-1; i++){
  line((8*espacio) + out8.left.get(i)*50,i,(8*espacio)+ out8.left.get(i+1)*50 , i+1);
 
}
  if (miPuerto.available() > 0) {
    int inByte = miPuerto.read();
  
        if(inByte == '1') {
          textoNota="DO";
      print ("do");
 out.playNote( 0.0, 1, "C3" );
    }
            if(inByte == '2') {
      print ("re");
       textoNota="RE";
  out2.playNote( 0, 1, "D3" );
    }
            if(inByte == '3') {
      print ("mi");
       textoNota="MI";
  out3.playNote( 0, 1, "E3" );
    }
      
            if(inByte == '4') {
      print ("fa");
       textoNota="FA";
  out4.playNote( 0, 1, "F3" );
    }
                if(inByte == '5') {
      print ("sol");
       textoNota="SOL";
  out5.playNote( 0, 1, "G3" );
    }
                if(inByte == '6') {
      print ("la");
       textoNota="LA";
  out6.playNote( 0, 1, "A3" );
    }
                if(inByte == '7') {
      print ("si");
       textoNota="SI";
  out7.playNote( 0, 1, "B3" );
    }
                if(inByte == '8') {
      print ("doAlto");
       textoNota="DO";
  out8.playNote( 0, 1, "C4" );
    }
}
}

Aquí tenéis un video en el que se puede comprobar el funcionamiento de nuestro diseño. Faltaría montar un perfil en el que fueran montadas las teclas, así como pensar en algún sistema que permitiera disimular todo el cableado (que de momento se ve muy disperso; si estáis pensando en intentarlo vosotros, os recomiendo que utilicéis cables de colores diferentes; en mi caso, yo incluso he intentado que los "colores" de las cuerdas de piano en pantalla y de los cables reales coincieran). El caso es que se ve bastante propio, ¿no os parece?.

¡Atrévete a mejorarlo!

Yo lo he hecho lo mejor que he podido. He tenido que investigar sobre varios aspectos que no sabía o no dominaba, como por ejemplo el funcionamiento de la librería CapacitiveSensor en Arduino, o los distintos atributos que podía utilizar con la clase Minim en Processing con respecto a objetos como AudioLineOutput. Por supuesto que el código y el diseño son mejorables. ¿Se te ocurre algo?. Si es así, y llegas a resultados aceptables, te agradecería que me lo contaras a través de los comentarios, mi canal de Youtube o mi TL de Twitter.

¡Y eso es todo por hoy!. Os agradezco mucho vuestra atención a todos los que habéis llegado hasta aquí. ¡Hasta la próxima!. ¡Sed felices!. ¡Siempre creciendo!. ¡Siempre aprendiendo!. ¡Cultura maker!