Filtro digitale prima prova

[simo85]

Buongiorno a tutti,

Nel mio piccolo percorso di studio di DSP (per il momento sto studiando su questo libro) sono arrivato quasi al capitolo 15.

Per il momento come sorgente del segnale posso usare un DDS fatto con un AD9851 o con un oscillatore a ponte di Wien con frequenza di output di 1kHz.

Lo schema a blocchi sarebbe quindi il seguente:

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

Nel bel mezzo dello studio teorico ho tanta voglia di fare una prima prova con il microcontrollore, però mi è sorto un dubbio che mi piacerebbe risolvere con il vostro aiuto.

Da qui:

"Previous chapters have described how the DFT converts a system's impulse response into its frequency response. Here is a brief review. The quickest way to calculate the DFT is by means of the FFT algorithm presented in Chapter 12. Starting with a filter kernel N samples long, the FFT calculates the frequency spectrum consisting of an N point real part and an N point imaginary part. Only samples 0 to N/2 of the FFT's real and imaginary parts contain useful information ... "

Se ho capito bene, devo prima calcolare la FFT, a seguire la DFT e successivamente filtrare il segnale, corretto?

Spero di non aver fatto confusione.

Grazie a tutti!

[DirtyDeeds]

Se ho capito bene, devo prima calcolare la FFT, a seguire la DFT e successivamente filtrare il segnale, corretto?

Non proprio La FFT è solo un algoritmo veloce per eseguire la DFT: il risultato della FFT E' la DFT.

Ma se tu vuoi fare un filtro che lavori in real time, allora implementalo come filtro FIR o IIR.

[simo85]

il risultato della FFT E' la DFT

OK vedo che mi ero confuso su qualcosina.

Ma se tu vuoi fare un filtro che lavori in real time, allora implementalo come filtro FIR o IIR.

Per il momento lo volevo implementare con la convoluzione come semplice prova.

Quindi ricapitolando:

Calcolo la DFT di x[n]
Implemento il filtro:



Un'altra piccola domanda..

Il segnale in output dal DDS è già a un segnale a tempo discreto. Ci sono considerazioni particolari da tener conto rispetto al caso di usare il segnale di output dell'oscillatore a ponte di Wien in entrata all' ADC?

Grazie ancora!

[DirtyDeeds]

Per il momento lo volevo implementare con la convoluzione come semplice prova.

Se lo vuoi implementare come convoluzione, non hai bisogno della DFT

Tu puoi usare l'analisi nel dominio della frequenza per determinare, attraverso una DFT inversa, i coefficienti del filtro, e poi nel micro implementi la convoluzione.

Il segnale in output dal DDS è già a un segnale a tempo discreto.

Se in uscita dal DDS non hai un filtro ricostruttore, ci sono tutte le frequenze immagini: quando ricampioni col DAC, se non hai un filtro antialiasing, generano aliasing.

[simo85]

OK Grazie mille DirtyDeeds!

[dimaios]

Il segnale in output dal DDS è già a un segnale a tempo discreto. Ci sono considerazioni particolari da tener conto rispetto al caso di usare il segnale di output dell'oscillatore a ponte di Wien in entrata all' ADC?

simo85, innanzitutto il teorema di Shannon.
Se la frequenza di campionamento del tuo ADC è pari a dovrai inserire in ingresso un filtro passa basso analogico con frequenza di taglio almeno .
Siccome i filtri passa basso non hanno un taglio netto dovrai in realtà tagliare di più.
Un criterio è il seguente ( non è il migliore ma neanche il peggiore ).

Il segnale in ingresso al sistema sarà .

Prendiamo in considerazione il suo massimo valore indipendentemente dalla frequenza ( questa è un'ipotesi grossolana che potrebbe degradare le prestazioni in quanto richiede una riduzione della banda ).

Se dove q è il quanto di campionamento dell' ADC[/i ] si ha che l'[i]aliasing si confonde con il rumore di bit.

ATTENZIONE: Questo non vuol dire che non si apprezzi e non degradi il campionamento ma semplicemente è sotto un livello generalmente accettabile.

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

Tecniche evolute fanno riferimento all'analisi spettrale del segnale di ingresso ma per una prova non saprei se vale la pena affrontare questo discorso matematicamente non banale.

Per quanto riguarda l'implementazione del filtro digitale.
La convoluzione si può eseguire in molti modi ovvero diverse sequenze di operazioni che portano al medesimo risultato.

Anzichè la forma diretta di tipo I e II lattice o cascade ti propongo una realizzazione in forma di stato bilanciata.
Una cosa molto importante è sapere se il filtro lo realizzi in virgola fissa o mobile.

Ophs .... mi sono accorto solo ora che DirtyDeeds ti aveva risposto ed ho parzialmente sovrapposto il post!

[simo85]

Grazie anche a te dimaios per le tue considerazioni, davvero siete molto gentili.

Per quanto riguarda l'implementazione del filtro digitale.

Prima di passare all'implementazione forse credo sia bene che mi concentri sulla parte analogica in entrata all' ADC, di cui mi ero proprio dimenticato prima di postare il thread.

Una cosa molto importante è sapere se il filtro lo realizzi in virgola fissa o mobile.

Non ricordo se lo avevo letto in qualche capitolo addietro (spero di non confondermi), ma se non erro immagino che entri in gioco la precisione della risposta all'impulso, ossia, con l'implementazione a virgola mobile si ottiene una risposta all'impulso migliore a confronto (sempre parlando di precisione). Entra anche in gioco il tempo di esecuzione delle operazioni svolte dalla CPU..

Dico bene? Pero qualcosa mi dice che ho mancato le considerazioni a qualche dettaglio importante.

EDIT:
http://www.dspguide.com/ch28/4.htm

[dimaios]

simo85, i problemi principali che dovrai affrontare se implementerai il filtro in virgola fissa saranno i seguenti :

1. Approssimazione dei coefficienti del filtro ( attenzione alla stabilità nel caso IIR )
2. Scalamento del segnale di ingresso
3. Verifica delle saturazioni nei vari stadi del filtro ( test point ).
4. Propagazione degli errori di calcolo nella catena

Ti consiglio inizialmente di realizzare un FIR che è intrinsecamente stabile.
Normalizza il segnale d'ingresso rendendolo unitario ( massimo ).
Fai alcune simulazioni offline e confronta la realizzazione in virgola mobile con quella in virgola fissa ( fai un programmino di tipo console in C o C++ usando l'aritmetica a precisione finita da una parte e quella in virgola mobile dall'altra ).

Questo è il metodo più semplice di procedere.
Ci sono anche quelli alternativi ma molto pesanti dal punto di vista della teoria.
Visto che sei al primo tentativo è meglio procedere per passi.

1. Realizza il FIR ( ordine basso per iniziare )
2. Discretizza i coefficienti in base al numero di bit a disposizione
3. Scala il segnale di ingresso
4. Verifica se hai problemi di saturazione
5. Confronta la soluzione in virgola mobile con quella in virgola fissa ottenuta.

[simo85]

Visto che sei al primo tentativo è meglio procedere per passi.

Grazie, vedo di mettermi subito al lavoro.

1. Realizza il FIR ( ordine basso per iniziare )
2. Discretizza i coefficienti in base al numero di bit a disposizione.

Dunque, facendo riferimento a questo libro capitolo 16, per calcolare i coefficienti del filtro procedo così:

Calcolo la relazione tra la frequenza di taglio e la frequenza di campionamento



Il valore del coefficiente è dato da



mentre per il resto



Per il momento ho fatto fatto un piccolo programma per calcolare i coefficienti, per una frequenza di taglio e una frequenza di campionamento

Codice: Seleziona tutto

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

/* Pi costant*/
#define PI 3.1415926535897932384626433832795029L

/* Cutoff frecuency */
#define Fc 5000

int main(int argc, char *argv[])
{
    /* n is the index and N points */
    int n = 0, N = atoi(argv[1]);

    /*
        x[N] is the input signal array
        h[N] is the coefficient array
        y[N] is the output signal array
    */

    double x[N], h[N], y[N];

    /*
        Fs Sampling frecuency
        Fc Cutoff frequency
    */
    double fs = (fc * 2), cutoff_relationship = fc / fs;

    if(argc < 2)
    {
        printf("usage: %s n\n", argv[0]);
        return 1;
    }
    else
    {     
        while(n < N)
        {
            x[n] = h[n] = y[n] = 0;
       
            n++;
        }
       
        n = 0;

        while(n < N)
        {
            if(n == 0)
                h[n] = cutoff_relationship / PI;
            else
                h[n] = (sin(cutoff_relationship * n))/(PI * n);

            printf("%.5f\n", h[n]);
            n++;
        }

        return 0;
    }
}

Che per un piccolo esempio di 32 (N) punti stampa il seguente output.

Codice: Seleziona tutto

0.15915
0.15261
0.13392
0.10584
0.07236
0.03810
0.00749
-0.01595
-0.03011
-0.03457
-0.03052
-0.02042
-0.00741
0.00527
0.01494
0.01990
0.01968
0.01495
0.00729
-0.00126
-0.00866
-0.01333
-0.01447
-0.01212
-0.00712
-0.00084
0.00514
0.00948
0.01126
0.01026
0.00690
0.00212


Possiamo proseguire con il punto 3 o sono inciampato in un campo di carciofi ed ho fatto confusione? Forse la lunghezza dell'array h[n] non deve appunto essere la stessa di x[n] (mi sto confondendo un po')..

Abbi pietà di me per eventuali castronerie..

[simo85]

Forse la lunghezza dell'array h[n] non deve appunto essere la stessa di x[n] (mi sto confondendo un po')

Appunto, se non erro la lunghezza dell'array h deve essere la metà della lunghezza dell'array x.