Home    Programma    Prerequisiti     Materiale didattico    Metodi didattici     Avvisi    Esami    Lezioni    Contatti



Architetture e Programmazione DSP
Corso di Laurea Magistrale in Informatica


    Prof. Mario Malcangi malcangi@di.unimi.it

       


Nuove tecnologie di computing e di comunicazione come Internet of the Things (IoT) e Internet of Eeverything (IoE) stanno evidenziando la natura sempre più dedicata (embedded) delle applicazioni di elaborazione dell'informazione.
L'evoluzione del computing dal modello interattivo (human-in-the-loop) verso il modello proattivo (human-above-the-loop) sta configurando un nuovo paradigma computazionale non più centrato sulla persona ma supervisionato dalla persona, il sistema embedded. Questi sistemi, già in avanzata fase di sviluppo tecnologico e applicativo, rappresentano già oggi la gran parte dei sistemi di computing dedicati o in rete, in rapporto di centinaia o migliaia di unità per persona. Tali sistemi, supervisionati o non supervisionati dalla persona, interagiscono con il mondo fisico,  rispondono in maniera rapida ed efficiente agli stimoli e agiscono in maniera proattiva, rappresentando così la principale fonte di informazione e di sincronizzazione per una vasta gamma di applicazioni. 
L’obiettivo del corso è di offrire allo studente un quadro completo delle conoscenze relative alle metodologie e alle tecnologie necessarie e sufficienti per affrontare e realizzare sistemi di natura embedded, ultra-embedded (deeply embedded) e indossabili (wearable) con un un approccio sistemistico. L'elaborazione del segnale (signal processing) è  la metodologia fondante che lega i tre livelli di  rappresentazione dell'informazione nei sistemi embedded, il livello analogico (fisico sensoriale), il livello a segnali misti (analogico/digitale) e il livello digitale (digital signal processing, DSP). L'elaborazione di informazioni di natura sfumata e imprecisa (fuzzy) è alla base della capacità di decisione proattiva dei sistemi embedded L'inferenza basata sulla logica fuzzy e sui paradigmi del neural computing faranno parte delle conoscenze teoriche e metodologiche che lo studente acquisirà durante il corso.
 Le architetture di computing orientate all'elaborazione in tempo reale dell'informazione di segnale (real-time signal processing) sono le tecnologie fondanti per la realizzazione di sistemi e applicazioni di natura embedded. Nel corso saranno trattate le metodologie e le tecnologie per lo sviluppo dei sistemi embedded avanzati (ultra-embedded e indossabili) facendo riferimento alle piattaforme di progettazione allo stato dell'arte e di ultima generazione (sensori e attuatori, front-end analogici, sottosistemi mixed-signal, core processor RISC/DSP e sottosistemi comunicazione con e senza fili). A tale scopo verranno utilizzate piattaforme per lo sviluppo su system-on-chip (SoC) basati  sull'architettura di computing ARM Cortex-M4, moduli multisensoriali microelettromeccanici (MEMS) e sottosistemi di comunicazione wired e wireless.
L’uso della metodologia di progettazione dal modello al sistema (Model System Design) in ambiente Matlab consentirà allo studente di disporre di un metodo completo per la progettazione di applicazioni DSP di natura embedded in campi  applicativi come multimedia, comunicazione, interfaccia uomo-macchina, robotica, biomedicale, audio-musicale e industriale, automazione, e-health e wearable computing.
Il corso si articola in lezioni frontali durante le quali vengono discussi gli argomenti teorici ed esemplificate le relative applicazioni. Lo studente avrà la possibilità di modellare in aula su computer le esemplificazioni proposte e verificarle su piattaforme di prototipazione rapida di ultima generazione.  Il corso prevede lo sviluppo e il test di una applicazione real-time di natura indossabile (le specifiche di sviluppo saranno concordate all'inizio del corso).

L’obiettivo del corso è di offrire allo studente le conoscenze necessarie e sufficienti per affrontare e realizzare applicazioni basate sulle metodologie di elaborazione numerica del segnale (Digital Signal Processing - DSP) con un’ottica sistemistica. Lo studio della programmazione viene condotto congiuntamente a quello delle architetture di calcolo orientate all’elaborazione numerica del segnale allo scopo di poter codificare in maniera ottimale e computazionalmente efficiente gli algoritmi DSP. L’uso della metodologia di progettazione dal modello al sistema (Model System Design) in ambiente Matlab consentirà allo studente di disporre di un metodo completo per la progettazione di applicazioni DSP di natura embedded in campi  applicativi come Multimedia, Comunicazione, Interfaccia Uomo-Macchina, Robotica, Biomedicale, Audio-musicale, Automazione, ecc.
Il corso si articola in lezioni frontali durante le quali vengono discussi gli argomenti teorici e i relativi esempi di programmazione DSP. Lo studente avrà la possibilità di eseguire in aula su computer le esemplificazioni proposte.  Il corso prevede lo sviluppo e test di una applicazione DSP real-time (le specifiche di sviluppo saranno date all'inizio del corso).


    Avvisi:                                                                                                            Top

Programma                                                         Top


Prerequisiti                                                                                                                   Top

    Analisi Matematica / Matematica discreta / Fisica

Materiale didattico                                                                                                                                                                                                                                                              Top

Testo di riferimento (dispensa):

    M. Malcangi: "Elaborazione numerica del segnale", Maggioli Editore, Milano, 2013. (Disponibile presso Libreria Cortina).

    Steven W Smith – The scientist and Engineer’s guide to Digital Signal Processing – California Technical Publiscing, 1999

    Tutorial Matlab

Esempi di programmazione di algoritmi DSP (script Matlab):

 Generazione di segnali con tecnica table look-up

% set-up parametri

Fs=8000;    % Frequenza di campionamento [Hz]
Ts=1/Fs;    % Periodo di campionamento [s]
Fo=1;       % Frequenza fondamentale [Hz]
To=1/Fo;     % Periodo fondamentale [s]
Ns=Fs/Fo;    % Dimensione tabella (1 secondo)
alfa=0:2*pi/Ns:2*pi-2*pi/Ns;
s=sin(alfa);

% ----------------------------Frequenza--------------------------

F=2; % FREQUENZA DA GENERARE [Hz]
if (F > Fs/2) F=Fs/2; % satura se supera la metà della frequenza di campionamento
end

% converte la frequenza in passo di lettura nella tabella

N=Fs/F;
Step=Ns/N;

% ---------------------------Ampiezza------------------------------

 AdB=-24;  % AMPIEZZA DA GENERARE [dB]

% converte dB in lineare

A=1;
while (AdB <= 0)
    AdB=AdB+6;
    A=A/2;
end

% -----------------------------Fase--------------------------------

Fase=pi/2; % fase iniziale [radianti]

% converte la fase iniziale in numero di campione

Fi=Ns/(2*pi/Fase);

% -----------------------------Generatore Table Look-Up---------

m=Fi;
for n=1:Ns
    mm=fix(m);   % trasforma in intero
    if(mm == 0) mm=1; % corregge se indice == 0
    end
    x(n)=A*s(m);    % estra dalla tabella e applica il fattore di ampiezza
    m=m+Step;
    while (mm > Ns) % wrap around - buffering circolare
        m=m-Ns;
    end
end

% ----------------------------Visualizza---------------------------

figure;
plot(x);
sound(x,Fs);

Identificazione frequenze singole tramite calcolo DFT semplificato

%formato digitalizzazione segnale

Fs=8000;    % frequenza di campionamento [Hz]
NBITS=16;   % numero di bit di quantizzazione

% parametri funzionali

w=20;       % Dimensione finestra di analisi [msec]
f0=1000/w;  % La scansione frequenziale sarà f0, 2f0, 3f0, ...
T=0.2;      % Soglia di riconoscimento del tono
Nw=Fs*w/1000;   % Dimensione della finestra di analisi espressa in numero di campioni 

% Frequenza da identificare

F=697;

% Tabella base per il cacolo seno/coseno in modalità table look-up
% (digitalizzazione di un periodo (2*pi) pari alla dimensione della finestra)

for n=1:Nw
    s(n)=sin(2*pi*f0/Fs*(n-1));
end

% ------------------------------------------------------------------

% acquisizione del segnale: segliere una delle due modalità seguenti
% (eliminando quella che non viene utilizzata): 

% ------------------------------------------------------------------

% modalità 1: cattura del segnale da convertitore A/D (scheda audio)

%r = audiorecorder(Fs, NBITS, 1);
%record(r);     % speak into microphone...
%stop(r);
%x = getaudiodata(r, 'double'); % get data

% ------------------------------------------------------------------

% modalità 2: cattura del segnale da file (formato .wav)

[x,Fs,NBITS]=wavread('dtmf.wav');

% ------------------------------------------------------------------

% visualizza il segnale acquisito

figure;
plot(x);

% conversione in step della frequenza per il table look-up 

N=Fs/F;
Step=Nw/N;

% ricerca della frequenza

k=0;
cont=100;
while cont > 0
    cont=cont-1;

    % estrazione di una finestra da analizzare

    for i=1:Nw
        xw(i)=x(i+k);
    end
    k=k+Nw;
    clf;   
    plot(xw);   % Visualizza la finestra di segnale

    % analizza la finestra di segnale
    Afs=0;
    Afc=0;
    m=1;    % fase zero (seno)
    l=Nw/4; % fase 2*pi/4 (coseno)
    for n=1:Nw   
    % converte l'indice da reale a intero
        m=fix(m);
        if(m == 0) m=1; % e lo corregge se necessario
        end
        l=fix(l);
        if(l == 0) l=1; % e lo corregge se necessario
        end

        % applica la funzione ortogonale seno
        Afs=Afs+xw(n)*s(m); % estrae la componente immaginaria (seno)
        Afc=Afc+xw(n)*s(l); % estrae la componente reale (coseno)
   
        % incrementa lo step del table look-up

        m=m+Step;
        l=l+Step;

        while (m > Nw) % e gestisce il wrap-around del buffer circolare
        m=m-Nw;
        end
        while (l > Nw) % e gestisce il wrap-around del buffer circolare
        l=l-Nw;
        end
    end

    Af=sqrt(Afs*Afs+Afc*Afc);   % calcola il modulo
    Af=2*Af/Nw    % scala il valore ottenuto per la dimensione della finestra e moltiplica per 2
    if (Af > T) break; % se l'ampiezza misurata è superiore alla soglia, termina
    end
end

Implementazione della decodifica della tastiera DTMF

%Formato digitalizzazione segnale

Fs=8000;    % Frequenza di campionamento [Hz]
NBITS=16;   % Numero di bit di quantizzazione

% Parametri funzionali

w=20;       % Dimensione finestra di analisi [msec]
f0=1000/w;  % La scansione frequenziale sarà f0, 2f0, 3f0, ...
T=0.15;      % Soglia di riconoscimento del tono
Nw=Fs*w/1000;   % Dimensione della finestra di analisi espressa in numero di campioni

% Tabella base per il cacolo seno/coseno in modalità table look-up
% (un periodo di durata pari alla dimensione della finestra di analisi(2pi))

for n=1:Nw
    s(n)=sin(2*pi*f0/Fs*(n-1));
end

% digitalizza il segnale DTMF
%r = audiorecorder(Fs, NBITS, 1);
%record(r);     % speak into microphone...
%stop(r);
%x = getaudiodata(r, 'double'); % get data

[x,Fs,NBITS]=wavread('dtmf.wav');
figure;
plot(x);

% frequenza di riga della tastiera DTMF

F=697;
Row=1;

% conversione in step della frequenza per il table look-up

N=Fs/F;
Step=Nw/N;

% ricerca della frequenza

k=0;    %indice di frame
sizex=size(x);  %dimensione dello stream di segnale
cont=sizex(1)/Nw;   %numero di finestre
while cont > 0
    cont=cont-1;
    % estrazione di una finestra di 20 ms da analizzare
    for i=1:Nw
        xw(i)=x(i+k);
    end
    k=k+Nw;
    clf;
    plot(xw);   % visualizza la finestra di segnale

    % analizza la finestra di segnale

    Afs=0;
    Afc=0;
    m=1;    % fase zero (seno)
    l=m+(Nw/4); % fase pi/2 (coseno)
    for n=1:Nw
       % converte l'indice da reale a intero
        mm=fix(m);
        if(mm == 0) mm=1; % e lo corregge se necessario
        end
        ll=fix(l);
        if(ll == 0) ll=1; % e lo corregge se necessario
        end

        % applica le funzioni ortogonali seno e coseno

        Afs=Afs+xw(n)*s(mm); % estrae la componente immaginaria (seno)
        Afc=Afc+xw(n)*s(ll); % estrae la componente reale (coseno)
  
        % incrementa lo step del table look-up

        m=m+Step;
        l=l+Step;
        while (m > Nw) % e gestisce il wrap-around del buffer circolare
        m=m-Nw;
        end
        while (l > Nw) % e gestisce il wrap-around del buffer circolare
        l=l-Nw;
        end
    end 
    Af=sqrt(Afs*Afs+Afc*Afc);   % calcola il modulo
    Af=2*Af/Nw;    % scala il valore ottenuto per la dimensione della finestra e moltiplica per 2
    if (Af > T) % controlla se esiste la frequenza di colonna

        % Frequenza di colonna della tastiera DTMF

        F=1633;
        Column=4;

% conversione in step della frequenza per il table look-up

        N=Fs/F;
        Step=Nw/N;

% ricerca della frequenza
% analizza la finestra di segnale

            Afs=0;
            Afc=0;
            m=1;    % fase zero (seno)
            l=m+Nw/4; % fase pi/2 (coseno)
            for n=1:Nw

% converte l'indice da reale a intero

                mm=fix(m);
                if(mm == 0) mm=1; % e lo corregge se necessario
                end
                ll=fix(l);
                if(ll == 0) ll=1; % e lo corregge se necessario
                end

% applica la funzione ortogonale seno

                Afs=Afs+xw(n)*s(mm); % estrae la componente immaginaria (seno)
                Afc=Afc+xw(n)*s(ll); % estrae la componente reale (coseno)

% incrementa lo step del table look-up

               m=m+Step;
               l=l+Step;
               while (m > Nw) % e gestisce il wrap-around del buffer circolare
               m=m-Nw;
               end
               while (l > Nw) % e gestisce il wrap-around del buffer circolare
               l=l-Nw;
               end
           end           

           Af=sqrt(Afs*Afs+Afc*Afc);   % calcola il modulo
           Af=2*Af/Nw;    % scala il valore ottenuto per la dimensione della finestra e moltiplica per 2
           if (Af > T) Row=Row     % FREQUENZA DI RIGA E DI COLONNA SONO STATE IDENTIFICATE: TERMINA
               Column=Column
                       break;
           end
        end
end

Implementazione di un filtro passa banda combinado un passa basso con un passa alto reiterato più volte

FS=8000;   %Campionamento
NBITS=16;   %Quantizzazione

% Generazione del patter-test: sequenza di toni sinusoidali a progressione d’ottava

D=0.1*FS;   %Durata dei segmenti del pattern-test
f=50;       %Frequenza base del pattern-test
k=1;        %Indice di frequenza

while f<FS/2
    for n=1:D
        x(k)=sin(2*pi*n*f/FS);
        k=k+1;
    end
    f=f*2; % progressione d’ottava
end
while(1) % loop infinito per valutare quante iterazioni sono necessarie per ottenere la risposta in frequenza desiderata
         % In ambiente MATLAB mettersi in modalità debug, posizionare un breakpoint su questa istruzione ed eseguire un RUN
         % Ogni ciclo while viene eseguita una iterazione PassaBasso+PassaAlto e visualizzata la risposta in frequenza.
         % Per interrompere il ciclo while infinito, dare il comando CTRL+C al prompt della command window di MATLAB

N=size(x); %Durata in campioni del patter test utilizzato per valutare la risposta in frequenza
n=2;
y(n-1)=0;
Fc=400;     %Frequenza di taglio filtro passa basso
a=1-exp(-2*pi*(Fc/FS));
b=1-a;

%Filtro passa basso

while n < N(2)
    y(n)=a*x(n)+b*y(n-1);   
    n=n+1;
end

x=y*1.707;  % L’uscita del filtro passa basso (normalizzata) viene connessa all’ingresso del filtro passa alto che segue
n=2;
y(n-1)=0;
Fc=400;     %Frequenza di taglio filtro passa alto
a=1-exp(-2*pi*(Fc/FS));
b=1-a;

%Filtro passa alto

R=0;
while n < N(2)
    y(n)=x(n)- R;
    R=x(n)*a+R*b;
    n=n+1;
end

plot(y); % Visualizza la risposta in frequenza
x=y;  % connette l’uscita del passa alto nell’ingresso del successivo passa basso 

end   % esegue una nuova iterazione

Implementazione di un filtro passa basso FIR derivandolo da un filtro IIR

clear;      % Azzera il workspace di MATLAB
FS=8000;
NBITS=16;

Fc=400;     %Frequenza di taglio del filtro IIR da implementare come FIR
a=1-exp(-(2*pi*Fc/FS));
b=1-a;

% Calcolo della risposta all’impulso h(n) del filtro y(n)=ax(n)+by(n-1)

h(1)=a;
n=2;
while 1
    h(n)=b*h(n-1);
    if h(n)<0.000001 break
    end
    n=n+1;
end

plot(h);

% Il seguente codice commentato può essere utilizzato per visualizzare la risposta in frequenza del filtro IIR

%H=fft(h,512);
%RH=real(H);
%IH=imag(H);
%PWR=sqrt(RH.^2+IH.^2)/512;
%f = FS*(0:256)/512;
%plot(f,PWR(1:257))
%title('Frequency content of h')
%xlabel('frequency (Hz)')

TAPS=n;  % Durata della risposta all’impulso

% Preparazione del test pattern per la visualizzazione della risposta in frequenza del filtro FIR

D=0.1*FS;
f=50;
for n=1:TAPS
    x(n)=0;
end
k=n;
while f<FS/2
    for n=1:D
        x(k)=sin(2*pi*n*f/FS);
        k=k+1;
    end
    plot(x);
    f=f*2;
end

% Implementazione del filtro FIR

N=size(x);
n=TAPS+1;
while n<N(2)
    y(n)=0;
    for k=1:TAPS
       y(n)=y(n)+h(k)*x(n-k);
    end
    n=n+1;
end
plot(y);    Visualizza la risposta in frequenza del filtro FIR (da comparare con quella del filtro IIR)

Lezioni     
 -                                                                                 Top
01.10.2018 - Introduzione al corso

05.10.2018 - Fondamenti di elettronica  analogica (PDF)

08.10.2018 - Fondamenti di elettronica analogica

12.10.2018 - Fondamenti di elettronica analogica

15.10.2018 - Fomdamenti di elettronica (verifica pratica) - Natura del segnale (Ampiezza, frequenza, fase). Il segnale sinusoidale.

19.10.2018 - Il segnale analogico: modello matematico del segnale sinusoidale - Ampiezza (media, efficace, picco-pico, massima e minima) Frequenza, periodo e fase.

22.10.2018 - Misura dell'informazione di Ampiezza (Decibel)

26.10.2018 - Campionamento (Campionatore) - Teorema del Campionamento - Filtraggio anti-aliasing

29.10.2018 -Problematiche e soluzioni del campionamento (Sovracampionamento)

02.011.2018 - Tecniche di quantizzazione (A ricerca lineare (rampa) - Approssimazioni successive)

05.11.2018 - Quantizzazione (Quantizzatore - Analog-to- Digital Converter)

09.11.2018 -  Analisi Frequenziale di Fourier - Trasformata discreta di Fourier (DFT)

12.11.2018 - Modello computazionale della Trasformata Discreta di Fourier

16.11.2018 - Simulazione in ambiente Matlab dei pricipi di sintesi e analsisi frequenziale di Fourier (TestDFT)

19.11.2018 - Applicazione della DFT

23.11.2018 - Sistemi lineari - Risposta all'impulso,convoluzione, risposta in frequenza

26.11.2018 - Sistemi lineari - Filtraggio FIR - Finestratura della risposta all'impulso

30.11.2018  filtraggio IIR - Modellazione matematica di un sistema lineare - Trasformata Z  - Equazione tempo discreto di un filtro con risposta infinita all'impulso (IIR)

03.12.2018 Simulazione in ambiente Matlab dei modelli matematici dei filtri IIR e  FIR (IIR _test FIR_test)
 
07.012.2018  Modello di programmazione DSP - Architettura Harvard  vs architettura Von Nemann - parallelismo esecutivo e pipelining (Von Neumann ) (Harvard)

10.012.2018 Architettura Motorola DSP56000 (DSP56000)

14.012.2018 Programmazione di un filtro FIRe di un IIR su un'architettura DSP56000 - Aritmetica di indirizzamento, aritmetica di saturazione. efficienza computazionale MAC (Multiply ACcumulate) (FIR56000) (IIR56000) (Saturazione) (Overflow e saturazione) (Aritmetica indirizzamento)

17.012.2018 Aritmetica Floating-point vs Aritmetica Fixed-point (Fixed-point)

07.01.2019 Chiusura del corso e proposta progetto fine corso. Progetto: (riduzione del rumore audio con sistema multimicrofonico)

  




Metodi didattici                                                                                                             Top

Modalità di esame: Scritto; Modalità di frequenza: Fortemente consigliata; Modalità di erogazione: Tradizionale.

Esami                                                                                               Top   

Modalità di esame: test scritto di 5 domande di teoria e 1 di pratica (codifica in linguaggio simil-C di un processo DSP)    

Contatti                                                                                                                          Top

    Prof. Mario Malcangi
    Computer Science Department
    Università degli Studi di Milano

    Mail:      Via Celoria 18
                  20133 Milano
                  Italy

    Office:    Via Celoria 18
                  Dipartimento di informatica
                  4° Piano - stanza 4005
                  20133 Milano
                  Italy
                  Tel:  +39.02.503.14014
                  Email:     malcangi@di.unimi.it

  Skype:    mario.malcangi

Last update: November  19th, 2018
© 2018 Mario Malcangi
Università degli Studi di Milano