Tesi di laurea

1. UNIVERSITÀ DEGLI STUDI DI TRIESTE
FACOLTÀ DI INGEGNERIA
Dipartimento di Elettrotecnica, Elettronica ed Informatica
Tesi di Laurea in
SISTEMI OPERATIVI
Implementazione in ambiente DSP
di algoritmi di beamforming audio
Laureando: Relatore:
Matteo BURIOLA Prof. Ing. Enzo MUMOLO
Correlatore:
Dott. Ing. Massimiliano NOLICH
____________________________________
Anno Accademico 2007-2008

3. Ai miei genitori
e ai miei nonni

5. INTRODUZIONE..................................................................................1
1.1 Introduzione................................................................................1
1.2 Sviluppo della tesi.........................................................................1
1.3 Architettura del sistema.................................................................3
1.4 Il DSP 6713..................................................................................3
1.5 La scheda Edirol...........................................................................4
1.6 Linguaggi e strumenti utilizzati.........................................................5
1.7 Il programma di partenza................................................................5
L'ALGORITMO DELAY AND SUM....................................................................8
2.1 Basi teoriche................................................................................8
2.2 Implementazione...........................................................................9
L'ALGORITMO (L.M.S.).....................................................12
LEAST MEAN SQUARE
3.1 Basi teoriche ...........................................................................12
3.2 Implementazione........................................................................13
3.3 Lms applicato al delay and sum.......................................................16
RISULTATI SPERIMENTALI.......................................................................17
BEAMFORMING NEL DOMINIO DELLA FREQUENZA...................................................20
4.1 Basi Teoriche..............................................................................20
4.2 Implementazione.........................................................................22
CONCLUSIONI.................................................................................24
BIBLIOGRAFIA.................................................................................25

7. INTRODUZIONE
1.1 INTRODUZIONE
La robotica è un campo ideale per sviluppare e provare nuove idee e algoritmi; in altri
termini è un campo di ricerca. Le applicazioni robotiche sviluppate finora realizzano
infatti funzioni piuttosto limitate. Ad esempio è limitata la capacità dei robot di
localizzarsi nell'ambiente e di percepire l'ambiente stesso. E' quindi limitata la capacità
di interagire con l'ambiente. In particolare è limitata la capacità di interagire con gli
esseri umani presenti nell'ambiente.
In questa tesi è stata affrontato il problema della interazione del robot con l'ambiente
acustico. Ci sono ovviamente molte sorgenti acustiche nell'ambiente; se il robot fosse in
grado di separarle e di classificarle potrebbe avere delle informazioni importanti per la
localizzazione del robot. Ad esempio il rumore di ventilatori, se identificato e
localizzato, può essere una informazione utile per capire come il robot è posizionato
nell'ambiente stesso.
A maggior ragione se la voce di parlatori umani può essere correttamente separata e
identificata, diventa posibile per il robot aumentare di molto le sue capacità di
interagire con gli esseri umani presente nell'ambiente.
Un modo molto importante per raggiungere questo risultato è quello del filtraggio
spaziale, in termine tecnico beamforming, cioè quella serie di elaborazioni del segnale
audio che possono discriminare la provenienza del segnale stesso.
In questa tesi è stato affrontato il problema del beamforming in tempo reale tramite
delle implementazioni sul DSP 6713 della Texas Instrument.
1.2 SVILUPPO DELLA TESI
Questa tesi si è occupata, inizialmente, dell'acquisizione di segnali vocali attraverso una
schiera di microfoni e poi della loro elaborazione attraverso algoritmi di beamforming in
modo da avere un segnale audio di qualità migliore da cui possono essere ricavati con
più facilità i comandi da impartire al robot.
A questo punto è necessario dare una spiegazione del termine chiave della tesi:
con il termine beamforming si intende una procedura di elaborazione di segnali
provenienti da un array di sensori per la ricezione o trasmissione di segnali direzionali.

8. Nel nostro caso si tratterà di acquisire e elaborare segnali audio provenienti da una
schiera di microfoni non direzionali in modo da formare un unico microfono che riceva il
segnale proveniente da una direzione ben precisa limitando il contributo di segnali da
altre direzioni, tutto questo attraverso elaborazioni elettroniche senza muovere
fisicamente la schiera di microfoni.
La differenza tra questa tesi e altre che hanno trattato lo stesso argomento, e da cui ho
preso spunto, è che il beamforming verrà eseguito in tempo reale su un processore DSP
collegato ai microfoni mentre in passato l'elaborazione era eseguita off-line partendo da
dei segnali generati sinteticamente.
Per questioni di tempo e praticità gli algoritmi sono stati provati prima in Matlab e
scrivendo programmi in C in versione off-line usando file audio wave come input e
scrivendo il risultato su un altro file. In questo modo si sono potute apportare le dovute
modifiche e fare il confronto di vari algoritmi in un tempo minore rispetto al DSP, in
seguito gli algoritmi scelti sono stati implementati sul DSP e resi real time. I file per
queste prove sono stati acquisiti con una scheda Edirol, che verrà descritta in seguito.
La tesi si è sviluppata quindi secondo i punti seguenti:
 Realizzazione dell'hardware di una schiera microfonica. La schiera è stata
realizzata utilizzando dei microfoni amplificati acquisiti in precedenza
 Realizzazione di un preamplificatore
 Sviluppo di un sistema di acquisizione sincrona con canali multipli
 Sviluppo do algoritmi di beamforming:
• Delay and sum: semplice algoritmo di filtraggio spaziale
• Least mean square (l.m.s.): algoritmo con filtri adattativi per la riduzione del
rumore (associato al delay and sum)
• Beamforming in frequenza
La schiera realizzata inizialmente ha dato risultati negativi per problemi hardware
perciò è stato comprato un array microfonico commerciale.
Figura 1: Il DSP utilizzato

9. 1.3 ARCHITETTURA DEL SISTEMA
Il sistema è composto dalle seguenti componenti:
scheda con DSP della Texas Instrument

scheda TMS320C6713 DSK con processore DSP
o
Daughter card “DUAL3006 rev d” con 2 ingressi e 2 uscite stereo
o
schiera microfonica con 8 uscite mono.

Computer architettura x86

Microsoft Windows XP
o
Code Composer Studio 3.1
o
Samplitude 7.0 professional
o
Matlab 6.1
o
Scheda Edirol FA101

Casse o cuffie

Connessione USB e firewire

Figura 2: L'array microfonico utilizzato
1.4 IL DSP 6713
La scheda TMS320C6713 DSK della Texas Instrument è una piattarforma di sviluppo
stand alone con processore a 225 MHz con bus a 32 bit che collega i 16 Mb di memoria
DRAM . i 512 Kb di memoria flash e gli ingressi delle periferiche.
Di seguito le caratteristiche generali:
Cpu a 225 MHz

Memoria flash a 512 Kb (256 disponibili di default)

Memoria DRAM asincrona a 16Mb

USB 2.0 per la connessiona al pc

4 led e 4 switches DIP accessibili dall'utente

Connettori standard per daughter card

Alimentazione a 5v


10. Su uno degli slot disponibili è inserita la scheda DUAL3006 rev d per le acquisizioni
audio. Questa scheda opera usando il suo oscillatore a 12,288 Mhz quindi si ha come
conseguenza una frequenza di campionamento fissa a 48 kHz e campioni a 12 bit. La
scheda presenta 2 ingressi e 2 uscite stereo e lavora tra +/-1V .
Figura 3: Daughter card DUAL3006 rev d
1.5 LA SCHEDA EDIROL
La scheda FA101 della Edirol è un' interfaccia audio firewire per acquisizioni
sincronizzate in grado di gestire 10 ingressi/uscite a 24-bit/96kHz e 6 ingressi/uscite a
24-bit/192kHz per performance di qualità DVD-A .
Di seguito le caratteristiche generali:
10 canali full duplex fino a 24 bit/96 kHz

6 canali full duplex fino a 2 bit/192 kHz

Alimentazione e connessione al pc tramite cavo firewire

Figura 4: Scheda Edirol FA101 (fronte)

11. 1.6 LINGUAGGI E STRUMENTI UTILIZZATI
Per l'acquisizione ei segnali audio da elaborare poi in un secondo momentoè stata usate
la scheda Edirol appena descritta insiema al programma Samplitude 6.0 professional che
permette l'acquisizione separata di tutti e quattro i canali.
Per la realizzazione off-line è stato usato il programma Matlab 6.5 con realativo
linguaggio e il compilatore wxDev 6.10 con linguaggio C sul Pc con windows xp.
Per quanto riguarda il DSP è stato usato il programma Code Composer Studio 3,1 con
linguaggio C.
Per l'ascolto dei file risultanti dell'elaborazione sono stati usati Audacity 3.1 e Adobe
Audition 1.5.
Inoltre, a partire dagli algoritmi in matlab sono stati generati dei diagrammi di
acquisizione che saranno presentati nel seguito dell'esposizione.
1.7 IL PROGRAMMA DI PARTENZA
Tutte le implementazioni degli algoritmi di seguito descritti sono state fatte partendo
da un programma esempio fornito dalla Texaxs Instrument insieme alla scheda di
acquisizione audio; data la sua importanza verrà qui descritto in dettaglio. Il
programma è organizato in modo da operare solo attraverso gli interrupt che vengono
inviati dalla scheda a udio. Nel file “talkthru.c” è presente il programma principale,
detto main, che inizia con l'istruzione per disabilitare tutti gli interrupt, poi assegna alle
procedure di input e output della scheda gli indirizzi degli interrupt 11 e 12.
// dsp and peripheral initialization
CSR=0x100; // disable all interrupts
IER=1; // disable all interrupts except NMI
*(unsigned char *)0x90080006 = 0x03; // McBSPs to J3
*(unsigned volatile int *)IMH = 0x08203DC3; // assign McBSP1 to INT11/12
Poi vengono inizializzate le porte McBSP per la comunicazione sul bus in modo che la
daughter card si sincronizzi con il DSP, usando la funzione Init_McBSP definita in
“codec.c”
// configure serial port 1 as the master on the I2S connection
// to the PCM3006 codec(s). The McBSP generates the bit clock and L/R clock
// by dividing down the master clock sent to it from the daughtercard
Init_McBSP(McBSP1_Base, 1); // I2S master
#ifdef DUAL3006_DUAL_CODEC // will exclude for single codec boards
Init_McBSP(McBSP0_Base, 0); // I2S slave

12. #endif
Infine vengono abilitati gli interrupt usati dalla scheda e cancellate tutte le richieste di
interrupt presenti al momento.
IER |= 0x1002; // enable McBSP1 Rx interrupt (12)
ICR = 0xffff; // clear all pending interrupts
CSR |= 1; // set GIE
Il programma poi entra in un ciclo infinito dove attende le richieste di interrupt.
Nel file “codec.c” viene ridefinito l'interrupt di acquisizione audio; questa routine di
interrupt si limita semplicemente ad acquisire i campioni dai canali di ingresso e a
riprodurli nei rispettivi canali di uscita. Siccome in ingresso si hanno 4 canali mono con
campioni a 2 byte e in uscita 2 canali stereo con campioni a 4 byte, per memorizzare i
dati viene utilizzate un struct di tipo union che permette di accedere ai dati sia come
una sola variabile di tipo int sia come due variabili distinte di tipo short. Di seguito il
codice dell'interrupt:
#define LEFT 0
#define RIGHT 1
volatile union {
unsigned int uint;
short channel[2];
} TxData;
interrupt void McBSP1_Rx_ISR()
{
McBSP *port;
port = McBSP1_Base;
TxData.uint = port->drr; // get input data from serial 1
delay0[k] = TxData.channel[0]; // microfono 1
delay1[k] = TxData.channel[1]; // microfono 2
port = McBSP0_Base;
TxData.uint = port->drr; // get input data from serial 0
delay2[k] = TxData.channel[0]; // microfono 3
delay3[k] = TxData.channel[1]; // microfono 4
port = McBSP0_Base;
port->dxr = TxData.uint; // send output data to serial 0
port = McBSP1_Base;
port->dxr = TxData.uint; // send output data to serial 1
}

13. Sono inoltre da menzionare i file “c6x11dsk.h”, “vectors1rx.asm” e “lnk.cmd”. Il primo
definisce gli indirizzi di memoria dei registri necessari alla comunicazione tra scheda
audio e DSP; il secondo definisce la tabella degli interrupt da usare in questo
programma e il terzo organizza la memoria del DSP.

14. L'ALGORITMO DELAY AND SUM
2.1 BASI TEORICHE
L'algoritmo delay and sum si basa sull'idea, semplice ma efficace, di sommare i segnali
provenienti dai microfoni della schiera dopo averli ritardati di un certo tempo  m . In
termini matematici :
M −1
∑ y m  t−m  (2.1)
m=0
Se i ritardi sono scelti opportunamente, in base alla velocità di propagazione del campo
ed alla distanza tra i sensori , si ottiene un rafforzamento del segnale proveniente dalla
direzione voluta ed una attenuazione degli altri. Per quanto detto si deduce che la
determinazione corretta dei ritardi è un aspetto fondamentale di questa tecnica.
Per ogni schiera di microfoni è possibile definire il suo centro di fase:
M −1
xc= ∑ xm (2.2)
 
m=0
Ed è sempre possibile scegliere tale punto come origine del sistema di riferimento
utilizzato, semplificando i calcoli senza perdere generalità. Per il calcolo dei ritardi
sono diverse le considerazioni da fare a seconda si operi in regime di campo lontano, e
quindi con onde ipotizzate piane, o di campo vicino, e perciò con onde sferiche. In
questo paragrafo e nei successivi verrà utilizzata sempre l’ipotesi di campo lontano,
perché è la condizione che si verifica più comunemente, in particolare per le
applicazioni audio. Sotto questa ipotesi si può immaginare di immergere la schiera in un
campo f(x,t) costituito da una singola onda piana propagantesi lungo la direzione

individuata dal versore  o :

o
f   ,t =s t− o⋅ 
x x dove o= (2.3)

c
L’uscita dell’ m-esimo microfono, posto in posizione x m , risulterebbe:

y m t =s t− o⋅x m  (2.4)

da cui,sostituendo nella 2.2,si otterrebbe:
M −1
z t = ∑ s t−m −o⋅x m (2.5)

m=0

15. È quindi evidente che per avere in uscita il segnale s(t) non distorto vanno scelti dei
ritardi:

−o⋅x m
(2.6)
m =−o⋅x m =

c
che verranno poi utilizzati nell'algoritmo.
2.2 IMPLEMENTAZIONE
Nell'implementazione dell'algoritmo, si è preferito calcolare i ritardi come numero di
campioni di differenza, invece che in secondi, rispetto a uno dei microfoni, che verrà
preso come origine del sistema di riferimento, o centro di fase, sia nel tempo che nello
spazio; quindi, siccome siamo nell'ipotesi di campo lontano, l'angolo  tra la direzione
dell'onda e la schiera di microfoni è uguale per ogni microfono e i ritardi saranno
calcolati come segue:
m =−x m⋅ f⋅cos /c (2.7)
dove f è la frequenza di campionamento.
Il microfono 1 è stato preso come origine del sistema di riferimento quindi x 1=0 e di
conseguenza anche 1=0 . Ciò significa che per un angolo /2 i ritardi saranno tutti
negativi, come ci si può aspettare osservando la figura dove si può vedere che il suono
giunge prima al microfono quattro che all'uno, mentre per /2 i ritardi saranno
positivi.
ξ
θ
microfono 4
microfono 2 microfono 3
microfono 1
X 2 = 6.4
X 3 = 17.7
X4 = 24.1
Figura 5: Misure delle distanze per il delay and sum

16. L'algoritmo implementato sul DSP è stato sviluppato partendo dall'esempio, descritto nel
capitolo precedente, di acquisizione e riproduzione audio. Nel main del programma ho
aggiunto una funzione che inizializza i quattro buffer dove vengono memorizzati i
campioni e che calcola i ritardi dopo che il valore dell'angolo è stato immesso da
tastiera.
Nel file “codec.c” è stato implementato l'algoritmo vero e proprio, sono stati creati
quattro buffer circolari con 512 allocazioni per memorizzare i campioni dati dai
microfono e su di questi sono stati inseriti due indici, uno per la posizione di scrittura,
indice 'k', e uno per quella di lettura, indice 'j'. Inizialmente viene eseguito solo il
processo di acquisizione dei campioni e di inserimento del buffer per evitare che, con
l'aggiunta dei ritardi, l'indice j superi l'indice k e finisca in una posizione che non
contiene ancora campioni. Poi, ogni volta che viene invocato l'interrupt entrambi gli
indici vengono aumentati, i nuovi campioni vengono scritti in posizione k e vengono
letti i campioni in posizione j + rit[m], dove rit[] è il vettore dei ritardi, facendo un
controllo per evitare che l'indice diventi negativo o che ecceda la lunghezza del buffer.
É stato inoltre aggiunto il file “share.h” in cui vengono definite extern la variabili
create in “codec.c” ma usate anche nel main cosicché possano essere accedute anche
da li.
Di seguito viene riportata la parte di codice della lettura dei buffer e del calcolo
dell'uscita:
idx[1] = j+rit[1]; //calcolo degli indici
idx[2] = j+rit[2]; //con i ritardi
idx[3] = j+rit[3];
idx[0] = j+rit[0];
for(i=0;i<4;i++){ //ciclo per riportare gli indici
if (idx[i]<0) idx[i]+=n; //idx nell'intervallo 0-512 se
if (idx[i]>=n) idx[i]-=n;} //avessero superato i limiti
y0= delay0[idx[0]]; //lettura di buffer
y1= delay1[idx[1]];
y2= delay2[idx[2]];
y3= delay3[idx[3]];
output=(y1+y2+y3+y0)/4; //calcolo dell'uscita
Inizialmente il programma su DSP non dava i risultati desiderati, quindi è stata creata
una versione per pc che elaborava file wave di segnali acquisiti in precedenza, in modo
da fare test e modifiche più velocemente. Siccome è stato con questa versione che si
sono ottenuti i primi risultati apprezzabili ne farò una breve descrizione.
Considerato che la piattaforma finale era comunque il DSP si è cercato di renderlo più
simile possibile a quello prima descritto; per fare ciò, dopo una fase iniziale con il

17. calcolo dei ritardi e l'apertura dei file, è presente un ciclo che simula le ripetute
chiamate dell'interrupt nel DSP. In questo ciclo, oltre alle istruzioni dell'algoritmo prima
descritte sono presenti due funzioni, leggifile e salvafile, che leggono e scrivono
rispettivamente un campione alla volta da e su file simulando gli ingressi e l'uscita del
DSP.
Una volta che il programma ha dato risultati soddisfacenti si è deciso di renderlo più
dinamico aggiungendo la possibilità di modificare l'angolo durante l'esecuzione del
programma. Ciò è stato fatto usando due programmi esempio di comunicazione tra DSP
e pc forniti dal c.c.s. Un esempio forniva un programma in visual basic che realizzava
sul pc una barra di scorrimento per la selezione del volume e inviava il valore al
processore; l'altro invece, attraverso la libreria rtdx, permetteva al DSP la ricezione di
dati dal pc senza usare chiamate alla sua bios. Aggiungendo il codice del secondo
esempio al nostro programma e interpretando i dati in arrivo dal primo come valori di
un angolo invece che di volume è stato possibile creare un metodo per la modifica
della'angolo, e di conseguenza dei ritardi, senza fermare l'esecuzione del programma.

18. L'ALGORITMO (L.M.S.)
LEAST MEAN SQUARE
3.1 BASI TEORICHE
L'algoritmo least mean square è uno dei più popolari algoritmi adattativi per
l'eliminizazione di rumori e interferenze, ciò è dovuto alla sua semplicità di
implementazione e a una efficenza costante in molte applicazioni. Lo scopo è di
minimizzare l'errore quadratico medio(least mean square) attraverso l'uso di filtri
adattativi. L'algoritmo inizia inserendo dei valori di partenza nel vettore dei pesi che
verranno successivamente usati per calcolare l'errore, i pesi verranno poi aggiornati di
volta in volta in funzione dei nuovi ingressi e degli errori calcolati in precedenza,
diventando sempre più precisi. La sequenza dei pesi converge infine verso il valore
ottimo. Come detto prima lo scopo dell'algoritmo è trovare il vettore di pesi w n che al
tempo n minimizza l'errore quandratico medio n=E {∣e n∣2 } usando una relazione
ricorsiva; al tempo n+1 una nuova stima viene calcolata asommando una correzione
 w n per portare w n più vicino al valore desiderato. La correzione viene attuata
muovendosi di un passo di dimensione  avvicinandosi alla superfice dell'errore
quandratico, cioè nella direzione negativa del gradiente.
w n1=w n− ∇  n (3.1)
Dove il gradiente ∇  n è la derivata di E {∣e n∣2 }
Considerato che il gradiente si può scrivere anche:
∇  n=−2r2Rw n (3.2)
con r e R rispettivamenteione vettore e matrice di autocorrelazione.
Siccome non siamo a conoscenza di questi valori dobbiamo stimarli come segue:
r =d n x n
R= x n x h n
Sostituendo quindi nella 3.1:
w n1=w n x n[ d n−x h n w n] (3.3)
=w n e n x n
L'equazione a ciu siamo giunti è il fondamento dell'algoritmo l.m.s. a cui vanno aggiunte
le seguenti per avere un quadro completo:
y n= w n  n
x (3.4)

e n= y n−d n (3.5)

19. Di seguito viene riportata la sequenza di istruzioni dell'algoritmo:
Inizializzare il vettore dei pesi
Acquisire i valori x(n) e d(n)
Calcolare l'uscita y(n)
Calcolare l'errore e(n)=y(n)-d(n)
Aggiornare il vettore dei pesi
Un altro aspetto da trattare è il valore della cosatante  da cui dipende la correttezza
dell'algoritmo. La condizione sotto la quale i valori dei pesi convergono verso la
soluzione ottima è la seguente:
1
0 (3.6)
 max
dove max è il più grande autovalore della matrice di correlazione.
Come detto prima, non siamo a conoscenza di questo valore quindi nella nostra
implementazione il valore di  sarà uguale a 1.
3.2 IMPLEMENTAZIONE
Il codice dell'algoritmo è stato preso dalla rete sotto forma di una classe in linguaggio
C++, si è provveduto a togliere l'aspetto ad oggetti e a implementarlo nel linguaggio C
del C.C.S. cercando di creare i vettori dei pesi 'w' e degli ingressi 'delay' attraverso
l'allocazione dinamica della memoria. Questo aspetto della gestione della memoria nel
DSP è alquanto complesso quindi si è deciso di abbandonarlo e di dare ai vettori una
dimensione fissa di 512 e di inizializzarli con tutti zeri a inizio programma.
Il fatto che il programma funzioni con continue chaimate all'interrupt creava qualche
problema su come implementare la parte iterativa dell'algoritmo in maniera da seguire
lo schema di figura ..., in quanto il calcolo dell'uscita di un filtro e dei pesi richiede n
iterazioni per ogni filtro ad ogni chiamata dell'interrupt mentre, siccome l'uscita del
sistema è unica, il calcolo di quest'ultima e dell'errore viene eseguito una volta sola alla
fine dell'interrupt. Questo problema è stato risolto modificando l'ordine delle istruzioni
presente nel diagramma precedente in modo che ogni chiamata dell'interrupt
rappresenti un'iterazione del ciclo in figura. L'inizializzazione vettori w e delay e è

20. comunque presente nel programma principale, coiè nel main, e la parte dell'interrupt
inizia ovviamente con l'aquisizione dei segnali in ingresso poi per prosegue chiamando
una funzione “sample” che, come prima cosa calcola i nuovi valori dei pesi senza
considerare però l'ingresso attuale poi inserisce il nuovo valore nel vettore delay
scartando quello più vecchio e infine esegue il calcolo dell'uscita y del filtro, che è il
valore restituito dalla funzione. Questa funzione viene invocata tre volte, una per ogni
filtro,poi le uscite vengono sommate per calcolare l'uscita del sistema e l'errore da
minimizzare.
[ ]
1 −1 0 0
0 1 −1 0
00 1 −1
Figura 6: Schema della prima implementazione dell'algoritmo lms
Siccome il DSP dispone di quattro canali di ingresso bisognava decidere come appilicare
i filtri adattativi dell'algoritmo,quindi sono state provate due configurazioni. Nella
prima gli ingressi dei filtri erano dati dalle differenza dei canali adiacenti, quindi si
avevano 3 filtri e l'uscita era data dalla loro media,come mostrato nella figura 4. Nella
seconda si è tenuto fisso un canale e si sono calcolate le 3 differenze tra questo e gli
altri canali, in questo caso si avevano 3 uscite che venivano successivamente sommate
tra loro,come mostrato in figura 5.
Figura 7: Schema della seconda implementazione dell'algoritmo lms

21. Di seguito viene riportato il codice della funzione sample usata all'interno dell'interrupt:
short sample(double x, double e,double w[],double delay[])
{
double lms;
//aggiornamento dei coefficienti secondo la formula dell'algortmo
for(i=0; i<n; i++)
w[i]=w[i] + mu*e*delay[i];
//traslazione dei valori in memoria per fare posto a quello attuale
for(i=n-1; i>=1; i--)
delay[i]=delay[i-1];
delay[0]=x;
//calcolo dell'output
lms=0;
for(i=0; i<n; i++)
lms=lms + w[i]*delay[i];
return lms;
}

22. 3.3 LMS APPLICATO AL DELAY AND SUM
Per quanto l'algoritmo lms sia efficace nell'eliminazione delle interferenze o del rumore
esso non è un algoritmo di beamforming perché non riesce a direzionare l'array di
microfoni verso una determinata direzione ma si limita a ridurre i disturbi senza tenere
in considerazione la direzione da cui proviene il suono. Per creare un algoritmo di
beamforming si è deciso quindi di unire questo algoritmo con il delay and sum descritto
precedentemente. Si è usata la configurazione di figura 4 e si è inserito il delay and sum
al posto della somma per il calcolo di d, come mostra l'immagine seguente.
[ ]
1 −1 0 0
0 1 −1 0
00 1 −1
Figura 8: Schema dell'implementazione del delay and sum con l'algoritmo lms
La semplice somma dei segnali in ingresso può essere vista come un delay and sum con
angolo =/ 2 nel quale i ritardi sono tutti nulli in quanto cos /2=0 .
L'implementazione di questa combinazione è avvenuta in due passaggi: inizialmente il
blocco del delay and sum è stato aggiunto alla struttura del lms senza però utilizzare i
filtri adattativi propri dell'algoritmo, poi sono stati aggiunti quest'ultimi. Ciò è stato
fatto per poter testare il sistema passo passo non sapendo bene quale sarebbe stato il
risultato finale.

23. RISULTATI SPERIMENTALI
I segnali audio usati per gli esperimenti di questa tesi sono di due tipi: un tono continuo
e una voce umana. I toni usati sono sinusoidi con frequenze di 500, 1000, 2000 Hz. Per
testare gli algoritmi in una situazione realistica sono state registrate, con la scheda
Edirol, due tracce audio nelle queli io e il professor Nolich abbiamo letto un testo di
esempio, poi queste tracce sono state unite in un unico file mp3 in modo da poter
riprodurre una sola della voci o entrambe, a seconda delle esigenze. Per le riproduzioni
dei segnali per i test è stato usato un secondo pc con windows xp con il programma
Audacity 1.3 e delle casse. Siccome la maggior parte dei test è stata svolta usando le
versione off-line dei programmi è stato necessario effettuare, sempre con la scheda
Edirol, diverse acquisizioni audio per poi salvarle come file mono che servivano a
simulare i microfoni. É stata eseguita solo un'acquisizione con entrambe le tracce
parlate, usando quindi due casse, le altre sono state effettuate con una sola sorgente.
Le acquisizioni singole sono state fatte ponendo la sorgente nei seguenti punti:
Y p1: x = 150cm e y = 180cm
p2: x = -150cm e y = 180cm
p3: x = 90cm e y = 180cm
p4: x = -90cm e y = 180cm
x p5: x = 0cm e y = 180cm
12 34
Per quanto riguarda quella a due voci le posizioni delle sorgenti erano p3 e p4.
Durante gli esperimenti la schiera di microfoni è stata indirizzata verso diversi angoli, i
più usati sono stati proprio quelli delle direzioni prima indicate. I test sull'algoritmo
delay and sum hanno prodotto scarsi risultati su tutte le acquisizioni audio. Anche se
osservando i grafici dei file risultato dell'elaborazione off-line si possono vedere
differenze tra i test della stessa acquisizione fatti con angoli diversi, queste differenze
sono poco apprezzabili per l'orecchio umano. Questo probabilmente è dovuto al fatto
che la stanza dove sono stati effettuati i test non presenta un isolamento acustico
sufficiente. I test fatti con l'algoritmo lms applicato al delay and sum senza i filtri
adattativi hanno dato gli stessi risultati. Non è stato possibile per motivi di tempo
eseguire i test applicando anche i filtri adattativi dell'algoritmo lms.

24. Di seguito sono riportatati i diagrammi dei lobi direzionali ottenuti con un segnale
sinusoidale a 1000Hz situato nelle posizioni p3,p4,p5.
90 6 e -0 0 5
120 60
4 e -0 0 5
150 30
2 e -0 0 5
180 0
210 330
240 300
270
90 4 e -0 0 5
120 60
3 e -0 0 5
2 e -0 0 5
150 30
1 e -0 0 5
180 0
210 330
240 300
270
90 8 e -0 0 5
120 60
6 e -0 0 5
4 e -0 0 5
150 30
2 e -0 0 5
180 0
210 330
240 300
270

25. Di seguito sono riportatati i diagrammi dei lobi direzionali ottenuti con un segnale
sinusoidale a 2000Hz situato nelle posizioni p1,p2.
90
3 e -0 0 5
120 60
2 e -0 0 5
150 30
1 e -0 0 5
180 0
210 330
240 300
270
90
2 .5 e -0 0 5
120 60
2 e -0 0 5
1 .5 e -0 0 5
150 30
1 e -0 0 5
5 e -0 0 6
180 0
210 330
240 300
270

26. BEAMFORMING NEL DOMINIO DELLA FREQUENZA
4.1 BASI TEORICHE
La tecnica del beamforming delay ad sum può essere anche utilizzata nel dominio della
frequenza, applicandola alla trasformate dei segnali provenienti dai sensori. In questo
caso l'uscita andrà poi riportata nel dominio del tempo per poter essere utilizzata.
L'introduzione di ritardi nel dominio del tempo si traduce nell'applicazione di sfasamenti
nel dominio della frequenza. Il beamforming delay and sum in frequenza è quindi
caratterizzato dalla seguente espressione:
M−1
Z w= ∑ Y m  e− j  (4.1)
m
m=0
dove Y m =F { y m t } è la trasformata dell'uscita dell' m-esimo microfono.
Il vettore che raccoglie gli sfasamenti derivanti dai ritardi di propagazione, relativi ai
vari microfoni e riferiti ad una certa frequenza, viene definito vettore di steering:
−j
e (4.2)
 ={e m }m=0,.... ,M −1
m
Utilizzando questa definizione, l'espressione 4.1 si può riscrivere come:
M −1
Z = ∑ Y m  e− j  (4.3)
m
m =0
ed adoperando una notazione di tipo vettoriale:
Z = Y ⊗   '  
 (4.4)
Ie

dove Y ={Y m }m=0,..... , M −1
Qunato detto sino ad ora è corretto dal punto di vista teorico ma inutilizzabile in
pratica, perchè, per applicare quanto visto, sarebbe necessario calcolare la trasformate
dei sengnali provenienti dai microfoni mediante un'integrazione su tempo infinito. Per
ovviare a questo problema e quindi permettere l'impiego di questa tecnica, si può
utilizzare l'anilisi di Fourier ristretta a una finestra di durata limitata. Con questa
tecnica si stima il valore della trasformata, restringendo il calcolo ad un intervallo di
tempo finito, nel seguente modo:
t T
Y m t , = ∫ w−t  y m  e− j  d  (4.5)

t
dove T è la durata dell'intervallo preso in considerazione e w t è la funzione finestra

dedfinita nell'intervallo [0,T].

27. La stima della trasformata risulta tanto più precisa tantoquanto più grande è l'intervallo
T, inoltre una scelta opportuna di w t può permettere un miglioramento dei risultati.

Rielaborandi opportunamente l'espressione 4.5 si arriva a
T
=∫ w  y m t  e− j t d 
−jt
Y m t ,  e (4.6)

0
che può essere impiegata per ottenere un'espressione simile alla 4.3 ma praticamente
utlizzabile:
M −1
Z t ,= ∑ w m Y m t , e− j  t e− j  (4.7)
m
m=0
dove Z t , risulta essere una stima di Z e− j  t .
Partendo da queste considerazioni, ed introducendo una notazione lievemente diversa,
è possibile arrivare alla definizionedella matricedi correlazione spaziale, il cui uso è
fondamentale nella trattazione di tecniche di beamforming. Definendo il vettore
colonna delle trasformate di Fourier su tempo limitato, relative ai vari microfoni
[]
Y 0 t , 
Y t ,= Y 1 t , 
 (4.8)
⋮
Y M −1 t , 
e la matrice diagonale dei pesi
[ ]
w 0  0 0

0 w1  0


W = (4.9)
⋮ ⋮ ⋱ ⋮
0 0  w M −1 
si può ottenere un'espressione matriciale equivalente alla 4.7:

− jt
(4.10)

Z t ,e = '  W  Y t , 
e
Inoltre è possibile definire la risposta direzionale in potenza come la potenza presente
all'uscita del sistema di beamforming in funzione del vettore di steering, utilizzato
quale indicatore della direzione di propagazione dell'onda piana incidente:
∞
P t ,  =∫  '  W  Y t ,  Y ' t , W '    d 
 
e e e
  (4.11)
−∞
Nell'espressione cosi introdotta l'integrando è una forma quadratica la cui parte centrale
viene comunemente detta matrice di correlazione spaziale.
 t ,=Y t ,  Y ' t , 
  (4.12)
R
Essa è costituita da tutti i prodotti incrociati tra le trasformate delle uscite dei vari
microfoni e contiene informazioni complete sulla direzione di propagazione dell'onda
incidente sulla schiera. Il suo utilizzo è fondamentale sia negli algoritmi di beamforming
che di quelli di localizzazione delle sorgenti.

28. 4.2 IMPLEMENTAZIONE
Siccome il codice di questo algoritmo era già presente come programma Matlab nella
tesi “Algoritmi basati su schiere di microfoni per il controllo vocale di un robot mobile”
di M. Clemente si è deciso di usarlo apportando solo le modifiche necessarie.
L'architettura fittizia ipotizzata nel programma prevedeva 8 microfoni con 16 canali in
ingresso, 8 rappresentavano il segnale corretto e le altre 8 rappresentavano
interferenze, prevedeva inoltre un ricampionamento dei segnali in ingresso da 25 kHz a
8 kHz e la possibilità di indicare fino a 3 vincoli per la direzione del disturbo. Si è
provveduto a ridurre i canali in ingresso a 4, con una frequenza di 48 kHz e, eliminando
i canali di troppo e ricalcolando le variabili utilizzate. É stata anche tolta la parte del
ricampionamento, inoltre i vicoli per il disturbo sono stati ridotti a uno ed è stata
fissato nella direzione speculare al segnale in ingresso rispetto all'asse dell'array di
microfoni.
Siccome i risultati ottenuti con le simulazioni in Matlab non sono stati soddisfacenti e il
tempo a mia disposizione scarseggiava, questo algoritmo non è stato implementato sul
DSP.
Di seguito è riportata la parte principale del programma:
%calcolo dei vettori si steering per ogni frequenza e per gli angoli
ff=0:N-1;
f=ff*48000/N;
for k=1:N/2+1
s(k,:)=[1,exp(-j*2*pi*f(k)*(-d1*sin(an)/vs)),exp(-j*2*pi*f(k)*(-
d2*sin(an)/vs)),exp(-j*2*pi*f(k)*(-d3*sin(an)/vs))];
s1(k,:)=[1,exp(-j*2*pi*f(k)*(-d1*sin(an1)/vs)),exp(-j*2*pi*f(k)*(-
d2*sin(an1)/vs)),exp(-j*2*pi*f(k)*(-d3*sin(an1)/vs))];
s2(k,:)=[1,exp(-j*2*pi*f(k)*(-d1*sin(an2)/vs)),exp(-j*2*pi*f(k)*(-
d2*sin(an2)/vs)),exp(-j*2*pi*f(k)*(-d3*sin(an2)/vs))];
end;
%inizio eleborazione blocco per blocco
for z=1:NMAXFRAME1
A=(z-1)*M+1;
B=(z-1)*M+N;
xx1t=fft(x1s(A:B).*hamming(N),N);
xx2t=fft(x2s(A:B).*hamming(N),N);
xx3t=fft(x3s(A:B).*hamming(N),N);
xx4t=fft(x4s(A:B).*hamming(N),N);
XXt=[xx1t,xx2t,xx3t,xx4t];
for k=1:N/2+1
Am(k,1)=(conj(s(k,:))*inv(Kn)*XXt(k,:)'/(conj(s(k,:))*inv(Kn)*s(k,:)');

29. Am1(k,1)=(conj(s1(k,:))*inv(Kn)*XXt(k,:)'(conj(s1(k,:))*inv(Kn)*s1(k,:)');
R{k,1}=sig^2*Kn+(Am(k,1)^2)*s(k,:)'*conj(s(k,:))+
((Am1(k,1)^2)*s1(k,:)'*conj(s1(k,:));
%sezione del calcolo dei pesi per le frequenze
Rinv=pinv(R{k,1});
W(k,:)=((Rinv*s(k,:)')/(conj(s(k,:)')'*Rinv*s(k,:)'))';
end;
yt=diag((conj(W)*XXt')');
yt1=flipdim(yt(2:N/2),1);
yframe=real(ifft([yt(1:N/2+1);conj(yt1)]));
if z==1
y=yframe;
else
y=[y(1:(z-1)*M);y((z-1)*M+1:(z-1)*M+N-M)+yframe(1:N-M);yframe(N-M+1:N)];
end;
end;

30. CONCLUSIONI
L' obiettivo della tesi era la corretta implementazioni di algoritmi di beamforming su un
DSP in modo che potesse essere usato per migliorare la ricezione dei comandi del robot
mobile. Limitandosi a questo si può dire che l'obiettivo è stato raggiunto perché
l'algoritmo delay and sum anche se non in maniera perfetta, esegue un filtraggio
direzionale dei segnali in ingresso. Per l'implementazione di questo algoritmo sono stati
utilizzati 4 buffer circolari con 2 indici,uno per la scrittura e uno per la lettura. Ad ogni
chiamata dell'interrupt venivano scritti i nuovi ingressi e letti i campioni nelle posizioni
determinate dai ritardi calcolati precedentemente in funzione dell'angolo.
Infine è stata aggiunta un'interfaccia di comunicazione col pc per la modifica dell'angolo
durante l'esecuzione. I risultati di questa tesi sono stati i seguenti:
 Analisi off-line del delay and sum con stima dei diagrammi di ricezione
 Implementazione real time del delay and sum
 Analisi dell'algoritmo lms. Dell'algoritmo lms è stata implementata in tempo
reale solo la struttura in combinazione al delay and sum.
 Analisi del beamforming in frequenza. Di questo si sono fatti solo test off-line,
senza procedere all'implementazione su DSP.
Questa mancanza è dovuta principalmente a predite di tempo causate da problemi di
hardware: creazione e sostituzione di circuiti amplificatori (non utilizzati nella
configurazione finale), sostituzione della schiera di microfoni, aggiunta della scheda
Edirol al progetto. Resta quindi molto lavoro da svolgere, a partire del miglioramento
dei risultati del delay ans dum all'implementazione su DSP del beamforming in
frequenza fino alla scelta di nuovi algoritmi oltre i tre proposti.
Ringraziamenti
Volevo innanzitutto ringraziare i professori Nolich e Mumolo per la disponibilità
dimostrata e per gli aiuti che mi hanno dato durante lo sviluppo della tesi.
Ringrazio inoltre gli amici dell'H3 team per avermi sopportato e aiutato in questi tre
anni e mezzo.

31. BIBLIOGRAFIA
Articoli e manuali:
Clemente M. - Algoritmi basati su schiere di microfoni per il controllo vocale di

un robot mobile
Coslovich A. - Studio e sviluppo di un sistema di classificazione di sorgenti

sonore per applicazioni robotiche mediante schiere di microfoni
H. Huu Hoang – Hands free Voice Interfaces Using a Microphone Array

Lloyd J. Griffiths, Charles W. Jim – An alternative approach to linearly

constrained adaptive beamforming
Otis Lamont Frost – An algorithm for linear constrained adaptive array processing

Siti internet di riferimento:
formato file wave

http://ccrma.stanford.edu/courses/422/projects/WaveFormat/
guida al Code Composer Studio

http://care.iitd.ac.in/academics/spru509.pdf
filtri adattativi

http://www2.units.it/~ieeesb/seminari_2004+/2005/LivioTenze_061205_Filtri_a
dattativi.pdf
guida al linguaggio C

http://digilander.libero.it/uzappi/C/
Documentazione tecnica:
documentazione del DSP:

http://focus.ti.com/docs/prod/folders/print/tms320c6713.html
http://c6000.spectrumdigital.com/dsk6713/V1/docs/dsk6713_TechRef.pdf
documentazione della daughter card:

http://www.educationaldsp.com/downloads/DUAL3006_RevD.pdf