No espere poder realizar una sonata para piano de Beethoven en este proyecto , pero  hoy vamos a cambiar de registro  en cuanto los contenidos que compartimos en este blog ,   enfocándonos en  un proyecto  muy sencillo  pensado sobre  para que los mas pequeños aprendan electrónica  y programación de un modo divertido   usando la excusa   del  las frutas para activar 8 notas  ¡y, no se preocupe si no tiene plátanos en este momento también  debería funcionar con cualquier fruta o verdura !.

El fundamento del circuito es a realmente  sencillo  pues basta  conectar a  cada fruta con una resistencia de 2,2 Mohmios ( o similar ) a una entrada analógica diferente y usar una referencia de GND como polo común    y con esto ya tenemos  junto con cualquier Arduino los fundamentos para hacer el piano frutal pues la electricidad  fluyera cuando toquemos la fruta para cerrar el circuito y, cuando lo haga, lo leeremos desde  una  Placa Arduino  pudiendo desencadenar un evento  que en este caso, sera  reproducir una nota  que sacáramos por un pin digital

Es decir cuando , usando un  pin digital de  Arduino configurado como entrada, si lo conectamos  a  un objeto con cierta resistencia , esto hará que la resistencia entre esta  y masa se desplace hacia GND (es decir a 0 V) porque el circuito está completo , el programa  leerá ese valor binario ( es decir un cero lógico)  y este evento provocara   que  Arduino reproduzca  una nota.

Para hacer el piano  de frutas  necesitará:

• Una placa Arduino, puede usar Arduino  UNO pero también puede usar cualquier placa compatible  procedente del mercado oriental .
• Ocho  resistencias de alto valor  de  2,2 Mega ohmios, aunque  debería funcionar con cualquier valor  entre 1 Mega-ohmios  y 10 Mega-ohmios . Si no tiene  estos valores también puede asociar varias en serie o en paralelo  hasta obtener  valores parecidos (al usar 8 entradas al menos necesitaremos pues 8 resistencias)
• Una resistencia de 220 ohmios para no proteger  el altavoz ,( si es un altavoz de 1W  o mas puede  prescindir de esta).
• Un altavoz de 8 ohmios.
•  Idealmente una placa de prueba para  conectar fácilmente los cables y las resistencias al Arduino.
• Cables rígidos  para las conexiones.
• !Su fruta o verdura favorita!( cuanto mas agua tenga mejores resultados obtendremos)

En cuanto al circuito , vamos a usar un Arduino Uno  configurando los pines digitales 2,3,4,5,6,7 y 8, como entradas digitales  y el pin digital 12 como salida digital.  También se puede usar cualquier placa compatible  con Arduino  procedente del mercado oriental y por supuesto también   una placa  Netduino en  todas sus variantes ( tendra que adaptar el sw)

El circuito es  muy sencillo  pues  consintiendo básicamente   en   8  entradas      y una   salida.   A las entradas digitales conectaremos 8  resistencias de pull-up de 2,2 Meg Ohm entres estas y VCC(+5V), conexión esta ultima que obtendremos directamente de la propia placa de Arduino. Como se puede deducir,  estas  entradas digitales se conectan   a  una fruta  clavando el hilo en esta . Cuando tocamos esta  fruta ,al estar conectada  a  una entrada de Arduino , llevaremos  a nivel lógico BAJO etas   al conectar  a tierra cada fruta  que a su vez esta  conectada a cada entrada digital.

El circuito se complementa con una resistencia de  220 ohmios, conectada desde el pin 12 a un altavoz de 8 ohmios. Esta resistencia perfectamente se puede suprimir si conecta directamente un altavoz  y no un amplificador   

En cuanto al sketh o programa para nuestro Arduino vamos a usar el ejemplo de E.Ballew escrito en Junio de 2018 que toma prestados  las librerías de tono de Tom Igoe (puede ver mas  ejemplos  en http://arduino.cc/en/Tutorial/Tone ) utilizando  sus archivos pitches.h  con una  clausula  include     para las frecuencias de las notas.

Este código implementa una sola octava de un piano simple, es decir solo reproduce  8 sonidos diferentes .

En primer lugar en el bloque Setup  se definen los pines de entradas digitales  asi como sus correspondientes notas para lo cual se define una matriz  unidimensional llamada  digInput   

int digInput[] = { 2, 3, 4, 5, 6, 7, 8, 9 };

También se define  cual va a ser el pin digital que va a usarse como salida  para conectar el altavoz ( el pin 12)

int toneOut = 12;

Definida el array  de los pines digitales  que usaremos como entrada digital  y la variable para el pin digital de salida    simplemente  toca asignar esta como entradas   mediante la clausula  pinMode(xx INPUT )  recorriendo el array  con un  bucle for  . También para  terminar definiremos  la salida  con la clausula pinMode(yy, OUTPUT);  resultando el siguiente código:

void setup() { ;

 for (int i = 0; i < numKeys; i++)

{ pinMode(digInput[i], INPUT);

}

pinMode(toneOut, OUTPUT); }

En cuanto al   bucle principal  leemos  mediante bucle el estado de las 8 teclas de frutas mediante la instrucción sensorVal = digitalRead(digInput[j])    ,  de modo   que si detectamos un nivel bajo   reproducimos la nota asociadas a  esa tecla  mediante la instrucción  tone(toneOut, myNote[j]); 

Asimismo  debemos  evitar  falso sonidos  para lo cual  incrementaremos la variable kepressed ,que inicializamos a cero en cada pasada del bucle para  silenciar el altavoz en cuanto sepamos que no se ha pulsado ninguna fruta  

int keypressed = 0;

……

if (sensorVal == LOW)

{ ++keypressed;

// increment keypressed

digitalWrite(13, HIGH);

tone(toneOut, myNote[j]);

}

…

if (keypressed == 0) { noTone(toneOut); }

También  a  efectos de depuración   realizamos un retardo entre cada interacción de 250ms  mediante la clausula  delay(250);

Al  bucle principal  ademas   efectos de depuración se añade una salida a de monitor en serie (que deberemos configurar  a 9600  baudios   )  , para probar los 8 niveles lógicos correspondientes   a las 8 entradas binarias .

El código final resultante  de  todas las consideraciones anteriores es el siguiente:

#include "pitches.h"

int numKeys = 8;
int digInput[] = { 2, 3, 4, 5, 6, 7, 8, 9 };
int myNote[] = { NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5 };
int toneOut = 12;

void setup() {
  // arrnacar conexion serie
  Serial.begin(9600);
  // Configurar  pines  digitales como entrada 
  for (int i = 0; i < numKeys; i++) {
    pinMode(digInput[i], INPUT);
  }
  pinMode(toneOut, OUTPUT);
}

void loop() {
  
  int keypressed = 0;
  for (int j = 0; j < numKeys; j++) {
    int sensorVal = digitalRead(digInput[j]);
    String outStr = String("K");
      outStr = String(outStr + j);
      outStr = String(outStr + ": ");
      outStr = String(outStr + sensorVal);
    if (sensorVal == LOW) {
      ++keypressed;  // incrementar keypressed
      digitalWrite(13, HIGH);
      tone(toneOut, myNote[j]);
    }
    //outStr = String(outStr + ":");
    //outStr = String(outStr + keypressed);
    Serial.print(outStr);
    Serial.print("\t");
  }
  Serial.println("");
  if (keypressed == 0) {
    noTone(toneOut);
  }
  delay(250);
}

Fichero pitches.h

/*************************************************
* Public Constants
*************************************************/

#define NOTE_C4 262

#define NOTE_D4 294

#define NOTE_E4 330
#define NOTE_F4 349

#define NOTE_G4 392

#define NOTE_A4 440

#define NOTE_B4 494
#define NOTE_C5 523

Obviamente una vez hayamos depurado el circuito no necesitamos la salida por consola del estado de las entrada binarias , por lo que el programa puede quedar reducido las
siguientes lineas:


#include «pitches.h»

int numKeys = 8;
int digInput[] = { 2, 3, 4, 5, 6, 7, 8, 9 };
int myNote[] = { NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5 };
int toneOut = 12;

void setup() {
for (int i = 0; i < numKeys; i++) {
pinMode(digInput[i], INPUT);
}
pinMode(toneOut, OUTPUT);
}

void loop() {
int keypressed = 0;
for (int j = 0; j < numKeys; j++) {
int sensorVal = digitalRead(digInput[j]);
if (sensorVal == LOW) {
++keypressed; 
digitalWrite(13, HIGH);
tone(toneOut, myNote[j]);
}
}
if (keypressed == 0) {
noTone(toneOut);
}
delay(250);
}

Por cierto el concepto , aunque sirve para emular un mini órgano también puede servir para emular un miniteclado , un pulsador especial , o cualquir cosa que ncesiste ser activado mediante algo diferente