Lo scopo del progetto consiste nel costruire una pianola “virtuale” mediante la programmazione di una scheda DSP.
In figura possiamo notare lo schema generale del progetto: l’utente sposta la sorgente S lungo la pianola “finta”;
la sorgente S emette un suono che viene ricevuto dai due microfoni 1 e 2;
successivamente la scheda DSP, confrontando i segnali letti da 1 e 2, determina la posizione di
S lungo la tastiera e produce una nota della frequenza desiderata.
I passi dunque da seguire per la realizzazione sono i seguenti:
La dinamica fisica, in base agli strumenti a disposizione, consiste nel calcolare il ritardo del suono tra il
microfono 1 e il microfono 2. Tale ritardo può purtoppo essere influenzato da molteplici fattori: frequenza, rumore, disturbi,
frequenza di campionamento, distanze tra microfoni e sorgente. Per semplificare il lavoro si usa come sorgente
una sinusoide di frequenza 2 KHz.
Tale suono ovviamente entra nel range delle frequenze udibili dall'orecchio umano (20H~20KHz),
tuttavia non è necessario, come si spiegherà in seguito, che l'intensità di tale suono sia elevata, perciò non crea alcuna
confusione con i suoni emessi dalla scheda DSP e non recherà alcun disturbo all'orecchio.
Le distanze tra gli strumenti, in particolare tra i due microfoni e la sorgente, hanno alcune limitazioni causate dal rilevamento del
ritardo: infatti i due microfoni non potranno essere nè troppo vicini, nè troppo lontani dalla sorgente, e nemmeno troppo distanti
tra loro. In particolare, la distanza tra la sorgente e i microfoni non può superare una lunghezza d'onda di distanza:
infatti in tale modo ci si assicura che la fase che verrà rilevata dalla scheda stia all'interno di un certo range, pari proprio ad una lunghezza d'onda,
nel nostro caso circa 17/18 cm (velocità del suono diviso la frequenza). Con questi accorgimenti, le distanze prese in considerazione saranno di 16 cm tra i due microfoni e di 10 cm di ortogonalità
con la sorgente. Il suono dunque verrà rilevato dai due microfoni, i quali invieranno il segnale ricevuto alla scheda DSP: il principio basilare del funzionamento del progetto consiste infatti nel calcolare il ritardo
tra i due segnali ed associare ad ogni piccolo range di valori per tale ritardo ad una nota stabilita. Per esempio nel nostro caso abbiamo stabilito che la misura di ogni nota è di 2 cm, partendo da il LA a 440 Hz
completando l'ottava fino al SOL successivo, mentre i microfoni sono posizionati ad un centimetro di distanza ai lati della tastiera. Se posizioniamo la sorgente esattamente a metà tra i due microfoni, il ritardo sarà quasi nullo e la nota stabilita è il RE.
Il device basilare per l'elaborazione dei segnali è la scheda DSP TMS320C6713 della Texas Instruments. La scheda ha numerosi tutorial d'apprendimento delle funzionalità in rete, disponibili anche nella sezione download.
Per la realizzazione di questo tipo di progetto si sfruttano l'ingresso e l'uscita audio: l'ingresso serve per ricevere i segnali
dai due microfoni, mentre l'uscita serve per generare il suono desiderato in base alla posizione della sorgente. Siccome tale scheda è dotata di un unico ingresso audio stereo, un primo piccolo problema si riscontra per il fatto
che i due microfoni trasmettono un segnale mono: per ovviare a tale problema è stato realizzato un piccolo semplice dispositivo che rivece i due segnali dai microfoni e li unisce in un destro/sinistro stereo da inviare alla scheda.
Lo schema a blocchi illustra il comportamento dei due segnali all'interno della DSP: inizialmente i due segnali vengano convertiti in digitale e vengano filtrati per ottenere dei campioni più puliti. Successivamente si effettua la convoluzione; in tale
modo infatti otteniamo un segnale che avrà il suo massimo in corrispondenza dello sfasamento tra il segnale sinistro e quello destro. Questa considerazione matematica rappresenta il vero e proprio nucleo del progetto. Ora basterà, per l'appunto, associare a piccoli range di valori, che il massimo può assumere, la nota corrispondente che si desidera. La scheda dunque in tempo reale risponde con l'emissione di una nota in base allo sfasamento dei due segnali ricevuti in ingresso dai due microfoni,
ovviamente dopo che il segnale in uscita viene elaborato dal codec audio e viene riconvertito in analogico.
In questa sezione si mostrano alcuni esempi di rilevamenti effettuati in real-time con la scheda DSP per poi illustrare due video esemplificativi con il comportamento effettivo della pianola virtuale. Ecco dunque alcuni grafici di rilevamento nelle diverse fasi d'esecuzione:
Il risultato finale del progetto è illustrato in questi video che mostrano il funzionamento della pianola virtuale:
Problemi riscontrati durante la progettazione:
durante la fase di progettazione ed implementazione si sono riscontrati diversi problemi che hanno influenzato anche la dinamica fisica. Inizialmente infatti il progetto era fondato su una sorgente a 100 Hz per
non recare confusione con i suoni prodotti in uscita. Tuttavia tale frequenza è troppo influezata dai disturbi (anche per la "vicinanza" alla frequenza di rete a 50 Hz) ed i filtri operavano in malo modo.
Perciò il progetto si è evoluto man mano fino a decidere che la frequenza di 2 Khz fosse adatta allo scopo (si sono svolte prove anche a 150 Hz, 200 Hz, 1 Khz). Come spiegato in precedenza, la frequenza di 2Khz ha limitato
le dimensioni della pianola anche se le dimensioni raggiunte sono simili ai reali tasti di un pianoforte: nei primi progetti infatti le dimensioni erano molto più dilatate fino a raggiungere dimensioni di metri per
metri con conseguenze anche logistiche di spazio.
Un ulteriore problema è nato dalle prove effettuate nel laboratorio sotterraneo dell\Università: oltre alla temperatura che influisce sulla velocità del suono, vi sono notevoli riflessioni d'onda e disturbi provocati
dalla presenza di molte aparecchiature elettroniche.
Ad ogni modo, in generale funziona!
Gli strumenti necessari per la realizzazione del progetto sono:
/***********************************************************************
Virtual_Piano.c
***********************************************************************/
void detect_delay(short *vector_1, short *vector_2)
{
int convolution[40];
int x[130];
int y[130];
int k = 0, t = 0, max = 0, index_max = 0;
DSK6713_LED_on(0);
//init convolution:
for ( k = 0; k < 40; k++ )
convolution[k]=0;
//vettore1 si lascia dov'è, si aggiungono 20 zeri all'inizio e alla fine
for ( k = 0; k < 20; k++)
x[k] = 0;
for ( k = 20; k < 110; k++)//non prendo i dati dal primo, ma dal 100-esimo
x[k] = vector_1[k-20];///100.0;
for ( k = 110; k < 130; k++)
x[k] = 0;
//vettore2 si sposta a sinistra di 20 e poi si esegue uno shift di 1 bit alla volta
for ( k = 0; k < 90; k++)
y[k] = vector_2[k];
for ( k = 90; k < 130; k++)
y[k] = 0;
for ( k = 0; k < 40; k++)// 40 spostamenti del vettore y
{
for ( t = 0; t < 130; t++)
convolution[k] = convolution[k] + x[t]*y[t];
shift_right(y);// esegue uno shift a destra del vettore
}
for ( m = 0; m < 40; m++)
{
if( convolution[m] >= max )
{ max = convolution[m];
index_max = m;
}
}
tone = index_max;
if( tone > 0 && tone < 7)
freq = 440; //LA
else if ( tone >= 7 && tone < 11)
freq = 494; //SI
else if ( tone >= 11 && tone < 17)
freq = 523; //DO
else if ( tone >= 17 && tone < 21)
freq = 587; //RE
else if ( tone >= 21 && tone < 28)
freq = 659; //MI
else if ( tone >= 28 && tone < 33)
freq = 698; //FA
else if ( tone >= 33 && tone < 38)
freq = 784; //SOL
else freq = 400; // se freq = 400, l'audio viene spento
new_tone = freq;
if ( new_tone != old_tone) //controllo tempistico: passaggio alla nota successiva dopo 4 conteggi
{
tn++;
if ( ts >= 3)
{
tn=0;
old_tone = new_tone;
}
}
else
tn = 0;
freq = old_tone;
coef = PI*freq/48000;
DSK6713_LED_off(0);
}