Sound Wall: suoniamo melodie con Arduino

Chi un po’ di musica ne mastica o ha buoni ricordi delle ore di “educazione musicale” alla Scuola Media (o secondaria di primo grado, per dirla in maniera moderna), certamente ricorderà che gli strumenti musicali si dividono in varie categorie in base a come il musicista più o meno erudito li aziona per far uscire le note: abbiamo strumenti a fiato (flauto, oboe, clarinetto, armonica a bocca, ecc.) strumenti a percussione (tamburi, pianoforte, ecc.) a corda (chitarra, basso, violino ma anche l’antico clavicembalo potrebbe rientrare in questa categorie), strumenti a canne e via di seguito.

Tutti sono accomunati dal fatto di funzionare senza bisogno di tecnologie moderne, non a caso sono nati tantissimi anni fa quando nemmeno si conosceva l’elettricità o l’elettronica, e basandosi su principi fisici molto semplici e primordiali.

Fig. 1

 

Quello che vogliamo proporvi in queste pagine è qualcosa di un po’ particolare, perché è uno strumento musicale elettronico che potremmo collocare tra quelli a tastiera, però si suona a tocco mediante tasti (li chiamiamo così sebbene non lo siano) che non si premono ma si sfiorano o si toccano semplicemente. Noi, come vedete nelle foto del prototipo in queste pagine, lo abbiamo concepito come un grande pannello (Fig. 1) dove sono state applicate delle piastre metalliche sagomate a nota musicale (non a caso abbiamo deciso di battezzarlo Sound Wall…) ma ognuno potrà dare all’interfaccia “utente” e quindi alla tastiera, la forma e l’aspetto che preferisce.

 

Il progetto

 

Schema di cablaggio

 

Vediamo subito di cosa si tratta, aiutandoci anche con lo schema di cablaggio proposto in queste pagine: il nostro strumento non è altro che una board Arduino Uno interfacciata alle piastre (toccando le quali con le dita verrà riprodotto il suono) mediante breakout MPR121CAPTOUCH, che sono dei sensori di contatto e che nel circuito sono in numero proporzionale alle note.

Ogniqualvolta tocchiamo una placca metallica, la breakout board cui è connessa elettricamente rileverà il trasferimento della quantità di carica elettrica verso il nostro corpo e invierà un segnale ad Arduino Uno, la quale, in base al firmware caricato, comanderà la generazione di un suono avvalendosi della “collaborazione” della scheda FT1414M che potete trovare qui a fianco tra i prodotti utilizzati in questo progetto.

La breakout board touch è sostanzialmente una scheda per la gestione dei sensori touch, quindi ad ogni pin NOTE e SEL abbiamo collegato delle piastre in alluminio con forma a piacimento (nello specifico si tratta di note musicali e forme geometriche) in modo che pigiando il dito su di esse, questa possano fungere da pulsante; ciascuna scheda legge un certo numero di piastre-nota e per l’esattezza 18, di cui 14 per le note (due ottave esatte…) e quattro per impostare le modalità di esecuzione, ossia gli strumenti simulati o “effetti” se preferite. Tali effetti sonori sono il Celesta (o celeste metallofono a martelletti), il Carillon e due suoni standard MIDI per sintetizzatori che sono l’FX2 (sintetizzatore tipo arma spaziale) e lo Sci-Fi FX8 (sintetizzatore di suono spaziale).

La breakout board per la gestione del touch è basata sul chip MPR121QR2 della Freescale, che è un sensore touch capacitivo controllato tramite interfaccia I²C. Il chip può controllare individualmente fino a 12 elettrodi e un massimo di 8 LED (quando i pin non sono configurati come elettrodi); quindi è per questo che nel nostro progetto ne vedete impiegate due. Nella parte inferiore dello stampato sono presenti 4 ponticelli (piazzole con pista), tutti chiusi per ottenere l’impostazione predefinita. Uno di questi ponticelli collega il pin ADD a massa, pertanto l’indirizzo I²C-Bus del chip sarà 0x5A. Utilizzando due breakout, sulla seconda questo ponticello va aperto, dando così alla scheda l’indirizzo 0x5B. I ponticelli collegano anche i pin SDA, SCL e IRQ a delle resistenze di pull-up da 10 kohm.

La breakout non dispone di regolatore di tensione, pertanto l’alimentazione deve essere compresa tra 2,5 e 3,6 Vcc e a ciò provvede Arduino Uno con il suo regolatore integrato che fornisce la tensione tramite i pin 3V3 e GND.
La generazione dei suoni avviene ad opera dello shield per Arduino FT1414M basato sul chip (VS1053B) di decodifica audio Ogg Vorbis/MP3/AAC/WMA/MIDI prodotto dalla VLSI.

Permette di generare un certo numero di note musicali sintetizzando i suoni di una gran quantità di strumenti musicali sia melodici sia a percussione, dietro comandi impartiti da un canale dati; i comandi accettati possono essere i vari formati, compreso il popolare MIDI, che è lo standard utilizzato da decenni per interfacciare al PC sintetizzatori musicali e tastiere elettroniche.

Per la comunicazione con il dispositivo host (il microcontrollore che governa il sintetizzatore), il VS1053B viene utilizzato in questo shield in modalità seriale.
Lo shield prende alimentazione da Arduino attraverso il pin 5V e la GND comune; con i 5 volt funziona il modulo amplificatore PAM8043, mentre per i 3,3 volt e gli 1,8 volt provvedono i regolatori lineari LDO (MIC5504-1.8YM5-TR e MIC5504-3.3YM5-TR).
L’integrato VS1053B dispone di un’uscita audio stereo collegata a una presa jack da circuito stampato cui è possibile collegare una cuffia. Inoltre la stessa uscita è collegata a un amplificatore BF (non incluso nella shield) di piccola potenza con uscite a bassa impedenza che eleva il livello del segnale quanto basta a pilotare una coppia di altoparlanti da 3 watt e 4 ohm d’impedenza ciascuno.

Il mini amplificatore codice PAM8403POT è montato su una propria scheda adattatrice e si inserisce sullo shield mediante zoccolo.
L’insieme dell’elettronica è proposto nella Fig. 2 applicato al pannello frontalmente.

Fig. 2

Come funziona

Vediamo adesso come funziona l’insieme, partendo dai tasti virtuali: mettendo il dito o la mano su una lamella sensore, provochiamo in uscita dalla breakout board cui è collegato una stringa di dati che vengono letti dal corrispondente bus I²C di Arduino. Questo evento causa l’esecuzione da parte di Arduino della nota corrispondente, che viene generata pilotando opportunamente il sintetizzatore MIDI interno al VS1053B tramite seriale, attraverso la generazione di una stringa di dati su tx0, contenente l’informazione sulla nota corrispondente. Il dato è in formato MIDI e per questo viene decifrato dal VS1053B.

Il VS1053B è un codec multistandard e decoder di molti formati, che però ha la particolarità di integrare un sintetizzatore di suoni a larga scala di integrazione basato su un DSP (Digital Signal Processor) proprietario della VLSI (ossia il VS_DSP). Contiene codici e memoria dati per i codec Ogg Vorbis, MP3, AAC, WMA e WAV PCM+ADPCM audio decoding, oltre a un completo MIDI synthesizer standard; il tutto comunica con l’esterno grazie a un’interfaccia seriale, eventualmente configurabile come SPI.

All’interno del VS1053B troviamo un DAC stereo multi-rate e uno stadio preamplificatore audio con filtro d’uscita in versione stereo. L’integrato supporta anche la codifica audio PCM/ADPCM, utilizzando, per il segnale d’ingresso da codificare, un amplificatore microfonico oppure un ingresso di linea ad alto livello dotato di preamplificatore integrato; il segnale in input viene inviato a un A/D converter stereo.

Grazie a plug-in software, il chip può anche realizzare la decodifica lossless FLAC come quella di una registrazione high-quality in formato Ogg Vorbis. Il sintetizzatore integrato di suoni a interfaccia standard MIDI dispone di due banchi di “effetti” corrispondenti strumenti musicali e chiamati GM1 (per gli strumenti melodici) e GM2 (per quelli a percussione); nella nostra applicazione si utilizza il banco GM1, ma modificando il firmware è possibile cambiare strumento, se ve la sentite e volete provare.

Le note musicali prodotte sono 12 per ottava (quindi le 7 note più i mezzi toni) e le ottave possibili sono 11, quindi l’integrato VS1053B copre una gamma musicale estremamente estesa, ben oltre quella del pianoforte (che ha 7 ottave più un DO). La Tabella 1 riepiloga le singole note correlandole con il valore dei dati ricevuti: come vedete sono possibili 128 suoni per ciascun “registro” o effetto, ognuno identificato da un valore numerico che viene passato da Arduino al VS1053B in forma seriale in formato binario.

Tabella 1

E veniamo ai quattro elettrodi A, B, C, D, che servono a cambiare lo strumento di cui suoniamo le note: il primo attiva lo strumento 1 che è il Celesta (o metallofono a martelletti) il secondo il carillon, il terzo il sintetizzatore tipo arma spaziale e il quarto il sintetizzatore Sci-Fi FX8 (un suono dal film di fantascienza). I suoni suddetti e tutti quelli sviluppabili all’interno del banco GM1 sono descritti nella Tabella 2.

Tabella 2

Lo shield midi

Approfondiamo ora quello che è il cuore del nostro strumento musicale, vale a dire lo shield basato sull’integrato VS1053B della VLSI e capace di generare un certo numero di note musicali sintetizzando i suoni di una gran quantità di strumenti musicali sia melodici (tra cui l’arpa e l’organo) sia a percussione, dietro comandi impartiti da un canale dati; i comandi accettati possono essere di vari formati, compreso il popolare MIDI, che è lo standard utilizzato da decenni per interfacciare al PC sintetizzatori musicali e tastiere elettroniche.

Il tutto si avvale, per la comunicazione con il dispositivo host (il microcontrollore che governa il circuito e che nel nostro caso è Arduino) anche in modalità SPI-bus. In realtà il VS1053B integra un complesso di interfaccia seriale che conta due interfacce: una di controllo (SCI=Serial Command Interface) che serve per comandare il funzionamento del chip e che nel nostro caso è quella attraverso la quale Arduino impartisce i propri comandi ed una di trasferimento dati (SDI=Serial Data Interface) grazie alla quale il VS1053B può trasferire o acquisire streaming di dati a un altro dispositivo esterno o da esso.

Delle due, quella configurabile per funzionare in modalità seriale TTL o SPI è la SCI, cioè l’interfaccia di controllo. Il sintetizzatore di suoni integrato è basato su un DSP (Digital Signal Processor) proprietario VLSI, chiamato il VS_DSP. I suoni sintetizzati vengono convertiti da un DAC stereo multi-rate, alla cui uscite si trova un amplificatore BF con filtro che abbatte i residui della conversione.

L’integrato supporta anche la codifica audio PCM/ADPCM, utilizzando come stadio d’ingresso un amplificato microfonico (per chi desidera impiegare come fonte un microfono) o prelevando il segnale da un ingresso di linea e inviandolo a un A/D converter stereo.

Nel nostro shield Arduino gestisce il VS1053B attraverso la porta seriale utilizzata come UART, che nell’U1 fa capo ai pin 26 (RX) e 27 (TX) connessi rispettivamente ai pin digitali D3 e D2 di Arduino (che sono quindi riservati); quest’ultima gestisce anche il reset dell’U1, tramite D4, così da predisporlo a ricevere i comandi.

Le tre linee in questione sono dotate di pull-up sul lato del VS1053 e vengono comandate dai pin di Arduino tramite resistori in serie; tre jumper (JRX, JTX e JRST) sul circuito stampato dello shield consentono di sconnetterle all’occorrenza, per esempio se si opta per una differente forma di controllo, come ad esempio la SPI.
In ogni caso le linee sono tre anche per consentire l’interfacciamento su SPI, giacché una fa da canale dati, una da reset e l’altra da clock; basta scrivere opportunamente il firmware.

Lo shield prende alimentazione da Arduino attraverso il pin 5V ed il GND; a bordo dipone di regolatori LDO per ricavare 1,8 volt (MIC5504-1.8YM5-TR) e 3,3 volt (MIC5504-3.3YM5-TR) con cui vengono alimentati i vari stadi del VS1053B.
L’integrato VS1053B dispone di un’uscita audio stereo localizzata sui pin 39 (canale R) e 46 (canale L) riferiti al comune pin 42 (GBUF) che non è collegato alla massa analogica, ma anch’esso accoppiato, come le linee di segnale, tramite reti R/C. Le uscite dell’U1 audio raggiungono una presa jack stereo da circuito stampato cui è possibile collegare una cuffia, giacché le stesse fanno capo a un amplificatore BF di piccola potenza con uscite a bassa impedenza.

Le stesse linee R ed L raggiungono gli input del modulo amplificatore PAN8403, che eleva il livello del segnale quanto basta a pilotare una coppia di altoparlanti da 3 watt e 4 ohm d’impedenza ciascuno; il modulo U4 è il PAM8403, basato sull’omonimo integrato già dotato di tutti i componenti esterni di cui necessita e del potenziometro per il controllo del volume.

Il firmware

Bene, ora che abbiamo spiegato in cosa consiste l’hardware possiamo vedere come funziona lo sketch caricato in Arduino per gestire il nostro strumento musicale, vale a dire leggere lo stato dei sensori tattili (piastre o lamine metalliche) e generare i comandi corrispondenti verso lo shield MIDI.

A livello di codice, possiamo vedere la funzione “Play” che è quella che permette di riprodurre la nota se viene rilevato il contatto delle dita su qualche piastra “Touch” a sua volta tramite la funzione “noteOn”. Le funzioni “checkInterrupt1” e “checkInterrupt2” sono la prima per identificare il tasto premuto dalla breakout delle NOTE e la seconda per la breakout SEL. Se si rileva un tasto premuto imposto la locazione “i” nell’array “touchStates” relativo al tasto premuto al valore “1”, oppure “0” se non premuto.

Lo sketch è strutturalmente e concettualmente semplice, perché dopo l’inizializzazione delle linee e la definizione delle variabili va a leggere lo stato delle piastre desumendolo dai dati forniti dalle due breakout board touch-sensitive se viene rilevato un contatto. Se ciò avviene, il firmware innanzitutto identifica qual è stato l’input corrispondente e discerne tra comandi delle note e comandi di impostazione del registro o strumento: nel primo caso fa eseguire allo shield la nota corrispondente mediante l’invio di una stringa di comando MIDI, mentre nel secondo ordina al VS1053B sullo shield stesso di impostare lo strumento corrispondente.

Ogni qualvolta che viene scelto uno strumento nuovo tra i 4, si riproduce una nota del nuovo strumento per identificare il cambio.
Riguardo alle funzioni, di base ci sono 4 strumenti differenti, anche se noi ne abbiamo usati solo 4, ma possono variare senza problemi cambiando il numero alla costante const int.
La scelta degli strumenti è legata alla seconda breakout dove nel disegno di cablaggio abbiamo indicato “SEL”:

const int STRUMENTO1=9;
const int STRUMENTO2=11;
const int STRUMENTO3=98;
const int STRUMENTO4=104;

Gli strumenti previsti e impostati nello sketch sono, secondo la Tabella 2 che riporta i numeri di programma del banco 0 del midi VS1053B:
• 9 Celesta (o celeste metallofono a martelletti);
• 11 Carillon;
• 98 Colonna sonora FX2 (sintetizzatore tipo arma spaziale);
• 104 Sci-Fi FX8 (sintetizzatore suono spaziale).

Otterremo quindi, in base a quale piastra metallica andremo a toccare, note che riprodurranno il suono dello strumento corrispondente.
Lo sketch che gestisce il nostro Sound Wall è piuttosto corposo per poterlo riportare interamente in queste pagine, pertanto vi facciamo vedere tre estratti che sono quelli più significativi: il Listato 1 riporta il setup relativo alle due schede che acquisiscono i segnali relativi ai contatti metallici, ossia i sensori tattili.

Listato 1

void mpr121_setup(void) {
    set_register(0x5A, ELE_CFG, 0x00);
    // Section A – Controls filtering when data is > baseline.
    set_register(0x5A, MHD_R, 0x01);
    set_register(0x5A, NHD_R, 0x01);
    set_register(0x5A, NCL_R, 0x00);
    set_register(0x5A, FDL_R, 0x00);
    // Section B – Controls filtering when data is < baseline. set_register(0x5A, MHD_F, 0x01); set_register(0x5A, NHD_F, 0x01); set_register(0x5A, NCL_F, 0xFF); set_register(0x5A, FDL_F, 0x02); // Section C – Sets touch and release thresholds for each electrode set_register(0x5A, ELE0_T, TOU_THRESH); set_register(0x5A, ELE0_R, REL_THRESH); set_register(0x5A, ELE1_T, TOU_THRESH); set_register(0x5A, ELE1_R, REL_THRESH); set_register(0x5A, ELE2_T, TOU_THRESH); set_register(0x5A, ELE2_R, REL_THRESH); set_register(0x5A, ELE3_T, TOU_THRESH); set_register(0x5A, ELE3_R, REL_THRESH); set_register(0x5A, ELE4_T, TOU_THRESH); set_register(0x5A, ELE4_R, REL_THRESH); set_register(0x5A, ELE5_T, TOU_THRESH); set_register(0x5A, ELE5_R, REL_THRESH); set_register(0x5A, ELE6_T, TOU_THRESH); set_register(0x5A, ELE6_R, REL_THRESH); set_register(0x5A, ELE7_T, TOU_THRESH); set_register(0x5A, ELE7_R, REL_THRESH); set_register(0x5A, ELE8_T, TOU_THRESH); set_register(0x5A, ELE8_R, REL_THRESH); set_register(0x5A, ELE9_T, TOU_THRESH); set_register(0x5A, ELE9_R, REL_THRESH); set_register(0x5A, ELE10_T, TOU_THRESH); set_register(0x5A, ELE10_R, REL_THRESH); set_register(0x5A, ELE11_T, TOU_THRESH); set_register(0x5A, ELE11_R, REL_THRESH); // Section D // Set the Filter Configuration // Set ESI2 set_register(0x5A, FIL_CFG, 0x04); // Section E // Electrode Configuration // Set ELE_CFG to 0x00 to return to standby mode set_register(0x5A, ELE_CFG, 0x0C); // Enables all 12 Electrodes set_register(0x5A, ELE_CFG, 0x0C); //***************** seconda scheda con indirizzo 0x5B ************************ set_register(0x5B, ELE_CFG, 0x00); // Section A – Controls filtering when data is > baseline.
    set_register(0x5B, MHD_R, 0x01);
    set_register(0x5B, NHD_R, 0x01);
    set_register(0x5B, NCL_R, 0x00);
    set_register(0x5B, FDL_R, 0x00);
    // Section B – Controls filtering when data is < baseline.
    set_register(0x5B, MHD_F, 0x01);
    set_register(0x5B, NHD_F, 0x01);
    set_register(0x5B, NCL_F, 0xFF);
    set_register(0x5B, FDL_F, 0x02);
    // Section C – Sets touch and release thresholds for each electrode
    set_register(0x5B, ELE0_T, TOU_THRESH);
    set_register(0x5B, ELE0_R, REL_THRESH);
    set_register(0x5B, ELE1_T, TOU_THRESH);
    set_register(0x5B, ELE1_R, REL_THRESH);
    set_register(0x5B, ELE2_T, TOU_THRESH);
    set_register(0x5B, ELE2_R, REL_THRESH);
    set_register(0x5B, ELE3_T, TOU_THRESH);
    set_register(0x5B, ELE3_R, REL_THRESH);
    set_register(0x5B, ELE4_T, TOU_THRESH);
    set_register(0x5B, ELE4_R, REL_THRESH);
    set_register(0x5B, ELE5_T, TOU_THRESH);
    set_register(0x5B, ELE5_R, REL_THRESH);
    set_register(0x5B, ELE6_T, TOU_THRESH);
    set_register(0x5B, ELE6_R, REL_THRESH);
    set_register(0x5B, ELE7_T, TOU_THRESH);
    set_register(0x5B, ELE7_R, REL_THRESH);
    set_register(0x5B, ELE8_T, TOU_THRESH);
    set_register(0x5B, ELE8_R, REL_THRESH);
    set_register(0x5B, ELE9_T, TOU_THRESH);
    set_register(0x5B, ELE9_R, REL_THRESH);
    set_register(0x5B, ELE10_T, TOU_THRESH);
    set_register(0x5B, ELE10_R, REL_THRESH);
    set_register(0x5B, ELE11_T, TOU_THRESH);
    set_register(0x5B, ELE11_R, REL_THRESH);
    // Section D
    // Set the Filter Configuration
    // Set ESI2
    set_register(0x5B, FIL_CFG, 0x04);
    // Section E
    // Electrode Configuration
    // Set ELE_CFG to 0x00 to return to standby mode
    set_register(0x5B, ELE_CFG, 0x0C); // Enables all 12 Electrodes
    set_register(0x5B, ELE_CFG, 0x0C);
}

Nel Listato 2 trovate invece la porzione di sketch che riguarda la gestione vera a e propria delle breakout boar MPR121, ovvero il controllo dei touch-sensor.

Listato 2

void readTouchInputs() {
   if (!checkInterrupt1()) {
      //read the touch state from the MPR121
      Wire.requestFrom(0x5A, 2);
      byte LSB = Wire.read();
      byte MSB = Wire.read();
      uint16_t touched = ((MSB << 8) | LSB); //16bits that make up the touch states
      for (int i = 0; i < 12; i++) { // Check what electrodes were pressed
         if (touched & (1 << i)) {
            touchStates[i] = 1;
         } else {
            touchStates[i] = 0;
         }
      }
   }
   if (!checkInterrupt2()) {
      //read the touch state from the MPR121
      Wire.requestFrom(0x5B, 2);
      byte LSB = Wire.read();
      byte MSB = Wire.read();
      uint16_t touched = ((MSB << 8) | LSB); //16bits that make up the touch states
      for (int i = 0; i < 12; i++) { // Check what electrodes were pressed
         if (touched & (1 << i)) {
            touchStates[i + 12] = 1;
         } else {
            touchStates[i + 12] = 0;
         }
      }
   }
   for (int i = 0; i < 24; i++) {
      Serial.print(touchStates[i]);
   }
   Serial.println();
}

Infine riportiamo, nel Listato 3, un’ultima porzione di codice che riguarda il controllo della riproduzione delle note da parte dello shield con VS1053B, nel quale la costante int note assume il valore relativo alla nota da riprodurre di volta in volta.

Listato 3

void Play() {
   int note = 30;
   for (int i = 0; i < 20; i++) {
      if ((touchStates[i] == 1) && (touchPres[i] == false)) {
         noteOn(0, note, 127);
         touchPres[i] = true;
      }
      if ((touchStates[i] == 0) && (touchPres[i] == true)) {
         noteOff(0, note, 127);
         touchPres[i] = false;
      }
      note++;
   }
   delay(100);
}

Realizzazione pratica

Detto ciò, passiamo adesso alla parte costruttiva del progetto, che prevede la realizzazione di una parte meccanica e di una elettronica: la prima consiste nel piano su cui fissare la nostra tastiera elettronica formata dalle piastre su cui suoneremo; le piastre metalliche vanno montate su un piano o comunque un supporto in materiale isolante di buono spessore e distanti da bordi o cornici in materiale conduttivo, altrimenti possono verificarsi falsi trigger. Nel nostro prototipo visibile in queste pagine abbiamo optato per un pannello in Forex delle dimensioni di 150×85 cm dotato di cornice in profilato d’alluminio a squadra da 30×15 mm; il piano è stato rivestito di una pellicola fantasia ed è possibile scegliere qualsiasi motivo e materiale purché sia elettricamente isolante.

Ogni piastra metallica è stata fissata al piano mediante viti 4MA a testa tonda con dado, con un occhiello e un filo elettrico (va bene qualsiasi diametro, anche molto ridotto, giacché la corrente in gioco è irrisoria) sulla faccia posteriore del piano di fissaggio stretto dal dado, per realizzare la connessione col relativo pin di input della breakout board.

I cablaggi devono seguire il disegno riportato in queste pagine che riporta l’elettronica del progetto, ossia una scheda Arduino Uno con applicato lo shield midi e le due breakout board connesse ad esso; nel nostro caso una parte del cablaggio è sulla parte frontale, giacché le schede sono applicate ad essa, ed un’altra parte è sul retro: ci riferiamo ai fili di collegamento delle piastre con i rispettivi pin delle breakout board deputati a leggerle, i quali passano da un foro posto sul pannello e scorrono -bloccati con della colla a caldo o del nastro adesivo- dietro come mostrato in Fig. 3, raggiungendo ciascuno un occhiello stretto nello stesso bulloncino che fissa meccanicamente la piastra corrispondente al pannello in forex.

Fig. 3

L’elettronica può essere posizionata sia davanti (in alto a sinistra come vedete nelle foto scattate al nostro prototipo) sia dietro al pannello di supporto delle note, opportunamente protetta, montata su colonnine distanziali (Fig. 4).

Fig. 4

Il tutto verrà alimentato attraverso Arduino Uno, con un alimentatore che fornirà tensione al jack DC di quest’ultima; a riguardo vi invitiamo a fare attenzione al fatto che l’alimentatore è un elemento critico del progetto perché dalle prove fatte abbiamo riscontrato che può causare problemi alla sensibilità dei sensori touch, comportando riproduzioni casuali di note senza che vi sia stato alcun contatto delle mani sulle piastre.
Quindi vi consigliamo di utilizzare un alimentatore che non sia switching (scegliete un alimentatore lineare) e che sia assolutamente stabilizzato: un buon alimentatore esterno da rete, lineare da 9V – 2 ampere montato lontano dalle piastre metalliche, andrà benissimo.

L’uscita audio dello shield basato su VS1053B può essere scelta fra le due disponibili: quella a basso livello, che necessita dell’amplificazione operata nel nostro prototipo da un amplificatore esterno e quella amplificata dal PAM8403 on-board, capace di pilotare altoparlanti da 3 watt di potenza e 4 ohm di impedenza.
Nel nostro prototipo vedete un cavetto di prolunga jack stereo 3,5 mm che si inserisce nella rispettiva presa dello shield (uscita da amplificare) ed esce: lo abbiamo messo per rendere accessibile l’uscita da amplificare, giacché abbiamo racchiuso l’elettronica in un “box” formato da una piastra di plexiglass e dalle rispettive colonnine distanziali di fissaggio e sarebbe difficile raggiungere il jack.

L’elettronica potete comunque racchiuderla come preferite, anche in un contenitore applicato sul retro del pannello; in ogni caso cercate di non esagerare con la lunghezza dei fili di collegamento fra i contatti (piastre metalliche) e le linee corrispondenti delle due breakout board MPR121: possibilmente rimanete sotto al metro di lunghezza.

Per quanto riguarda la disposizione degli elettrodi, a prescindere dalla forma delle piastre e del pannello di supporto che sceglierete, suggeriamo di collocare da una parte quelle di selezione dello strumento (4) e separare idealmente sul pattern quelle delle 14 note; potete trarre spunto dalla Fig. 5, che riporta il layout del nostro prototipo, nel quale al centro del pannello sono poste le note e a destra c’è la “tastiera” di selezione degli effetti.

Fig. 5

Conclusioni

Bene, pensiamo di avervi spiegato quanto basta per preparare il nostro strumento musicale a tocco, nonché per configurarlo in modo da ottenere i suoni desiderati; come spiegato, il progetto si presta a molteplici elaborazioni e vi dà la massima libertà espressiva sul piano della realizzazione pratica e della scelta della “tastiera”, pur rispettando le regole indicate. La versione proposta nelle foto di queste pagine è un suggerimento, ma ognuno di voi potrà dare sfogo alla propria fantasia disponendo le piastre sul supporto che ritiene più adatto e sagomando le piastre come desidera.
Non ci resta che augurare buon lavoro e buon divertimento a tutti!

Download

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Menu