Zeitvariante Filter

[Johnsn (Gast)]

Abend!

Und zwar will ich ein zeitvariantes Filter für Audioanwendungen auf 
einem FPGA realisieren. Vorerst versuche ich mal meine theoretischen 
Überlegungen in Matlab zu simulieren. Auf jeden Fall habe ich da 
folgendes Problem:

Mein Filter soll ein Bandpassfilter (einige 100 Hz Bandbreite) sein, 
aber mit einer variablen Mittenfrequenz, die sich abhängig von der Zeit 
ändert. Das heißt, dass als Parameter für die Mittenfrequenz ein LFO 
dienen soll. Nur da scheiterts bei mir, weil ich noch nicht genau weiß 
wie ich ein zeitvariantes Filter simuliere.

Wär toll, wenn mir jemand Antwort geben könnte, kann gerne noch mehr 
Infos dazu geben.

rock on,
Johnsn

[Christoph Kessler (db1uq) (Gast)]

Ich hab mal in Google "Zeitvariante Filter" eingegeben, da findet sich 
einiges an Vorlesungsskripten und Übungen, besonders aus der 
Elekroakustik und Musikelektronik, teilweise wird auch Matlab erwähnt, 
z.B. hier:
http://www.lnt.de/lms/lecture/digsounds/index.php?lang=de

[Christoph db1uq K. (christoph_kessler)]

In der Theorie der digitalen Filter scheinen zeitvariante, also leicht 
über einen oder wenige Parameter in der Frequenz verstellbare Filter 
selten vorzukommen. Ich habe in meiner Literatur zu DSPs eine einzige 
Erwähnung gefunden, und das scheint etwas ziemlich exotisches zu sein. 
Zwei Allpässe, die sich irgendwie "Kongruent" voneinander unterscheiden, 
in einer "Brückenschaltung", und dann gibt es einen Parameter, den man 
ändern muß,
Das Buch heißt  "Digitale Filter", Autor W.Hess im Teubner-Verlag 1993 
ISBN 3-519-16121-4 und der kurze Abschnitt heißt "Abstimmbare Filter" S. 
196-197. Seither sind natürlich 13 Jahre vergangen, vermutlich hat sich 
inzwischern einiges getan.
Vermutlich berechnet man normalerweise die Parameter für jeden 
Einstellvorgang neu oder hat eine Tabelle.

[detlef _a (Gast)]

Zeitvariante digitale Filter sind weitverbreitet, z.B. als Echocanceller 
in jedem DSL Modem / Telefon mit Freisprecheinrichtung etc. oder als 
adaptive Filter zur Systemidentifikation. 'Zeitvariant' hat ja 'mit in 
der Frequenz verstellbare' Filter erstmal nix zum tun. Anderes Beispiel 
sind die Rückkopplungskiller für die Bühne, liefen hier im Forum mal 
unter 'Autonotch' oder so, glaube ich.

Standardwerk
Adaptive Filter Theory (4th Edition) by Simon Haykin

Cheers
Detlef

[Christoph Kessler (db1uq) (Gast)]

Beim Autonotchen wird ein gegenphasiges Signal addiert, das geht 
einfacher, als alle Filterparameter ständig umzurechnen und neu zu 
schreiben. Auch Echocanceller sind so gebaut. LMS-Filter heißt das als 
Suchbegriff, least mean square, also kleinstes Quadratmittel, mit dem 
man sich dem Störsignal annähert.

[Christoph Kessler (db1uq) (Gast)]

Es ist ja auch in der analogen Filtertechnik nicht einfach, ein 
mehrkreisiges Filter durchstimmbar aufzubauen. Man muß sich nur mal 
einen professionellen Funkempfänger aus der Röhrenzeit ansehen, 
gegeneinander verspannte Zahnräder, Kurvenscheiben, eine teure 
Feinmechanik um sämtliche Filter gleichlaufend zu verstellen. Die 
Erfindung des Superhet-Empfängers hat das vereinfacht, das hochselektive 
Filter ist fest auf die Zwischenfrequenz abgeglichen.

[Thomas (Gast)]

Damit kannst Du für alle möglichen Filter die Filterkoeffizienten
Berechnen. Dann mußt die Die Koeffizienten einfach in Deine Biquad- 
Gleichung einsetzen.

/* Simple implementation of Biquad filters -- Tom St Denis
 *
 * Based on the work

Cookbook formulae for audio EQ biquad filter coefficients
---------------------------------------------------------
by Robert Bristow-Johnson, [e-mail]  a.k.a. [e-mail]

 * Available on the web at

http://www.smartelectronix.com/musicdsp/text/filters005.txt

 * Enjoy.
 *
 * This work is hereby placed in the public domain for all purposes, whether
 * commercial, free [as in speech] or educational, etc.  Use the code and please
 * give me credit if you wish.
 *
 * Tom St Denis -- http://tomstdenis.home.dhs.org
*/

/* this would be biquad.h */
#include <math.h>
#include <stdlib.h>

#ifndef M_LN2
#define M_LN2   0.69314718055994530942
#endif

#ifndef M_PI
#define M_PI3.14159265358979323846
#endif

/* whatever sample type you want */
typedef double smp_type;

/* this holds the data required to update samples thru a filter */
typedef struct {
    smp_type a0, a1, a2, a3, a4;
    smp_type x1, x2, y1, y2;
}
biquad;

extern smp_type BiQuad(smp_type sample, biquad * b);
extern biquad *BiQuad_new(int type, smp_type dbGain, /* gain of filter */
                          smp_type freq,             /* center frequency */
                          smp_type srate,            /* sampling rate */
                          smp_type bandwidth);       /* bandwidth in octaves */

/* filter types */
enum {
    LPF, /* low pass filter */
    HPF, /* High pass filter */
    BPF, /* band pass filter */
    NOTCH, /* Notch Filter */
    PEQ, /* Peaking band EQ filter */
    LSH, /* Low shelf filter */
    HSH /* High shelf filter */
};

/* Below this would be biquad.c */
/* Computes a BiQuad filter on a sample */
smp_type BiQuad(smp_type sample, biquad * b)
{
    smp_type result;

    /* compute result */
    result = b->a0 * sample + b->a1 * b->x1 + b->a2 * b->x2 -
        b->a3 * b->y1 - b->a4 * b->y2;

    /* shift x1 to x2, sample to x1 */
    b->x2 = b->x1;
    b->x1 = sample;

    /* shift y1 to y2, result to y1 */
    b->y2 = b->y1;
    b->y1 = result;

    return result;
}

/* sets up a BiQuad Filter */
biquad *BiQuad_new(int type, smp_type dbGain, smp_type freq,
smp_type srate, smp_type bandwidth)
{
    biquad *b;
    smp_type A, omega, sn, cs, alpha, beta;
    smp_type a0, a1, a2, b0, b1, b2;

    b = malloc(sizeof(biquad));
    if (b == NULL)
        return NULL;

    /* setup variables */
    A = pow(10, dbGain /40);
    omega = 2 * M_PI * freq /srate;
    sn = sin(omega);
    cs = cos(omega);
    alpha = sn * sinh(M_LN2 /2 * bandwidth * omega /sn);
    beta = sqrt(A + A);

    switch (type) {
    case LPF:
        b0 = (1 - cs) /2;
        b1 = 1 - cs;
        b2 = (1 - cs) /2;
        a0 = 1 + alpha;
        a1 = -2 * cs;
        a2 = 1 - alpha;
        break;
    case HPF:
        b0 = (1 + cs) /2;
        b1 = -(1 + cs);
        b2 = (1 + cs) /2;
        a0 = 1 + alpha;
        a1 = -2 * cs;
        a2 = 1 - alpha;
        break;
    case BPF:
        b0 = alpha;
        b1 = 0;
        b2 = -alpha;
        a0 = 1 + alpha;
        a1 = -2 * cs;
        a2 = 1 - alpha;
        break;
    case NOTCH:
        b0 = 1;
        b1 = -2 * cs;
        b2 = 1;
        a0 = 1 + alpha;
        a1 = -2 * cs;
        a2 = 1 - alpha;
        break;
    case PEQ:
        b0 = 1 + (alpha * A);
        b1 = -2 * cs;
        b2 = 1 - (alpha * A);
        a0 = 1 + (alpha /A);
        a1 = -2 * cs;
        a2 = 1 - (alpha /A);
        break;
    case LSH:
        b0 = A * ((A + 1) - (A - 1) * cs + beta * sn);
        b1 = 2 * A * ((A - 1) - (A + 1) * cs);
        b2 = A * ((A + 1) - (A - 1) * cs - beta * sn);
        a0 = (A + 1) + (A - 1) * cs + beta * sn;
        a1 = -2 * ((A - 1) + (A + 1) * cs);
        a2 = (A + 1) + (A - 1) * cs - beta * sn;
        break;
    case HSH:
        b0 = A * ((A + 1) + (A - 1) * cs + beta * sn);
        b1 = -2 * A * ((A - 1) + (A + 1) * cs);
        b2 = A * ((A + 1) + (A - 1) * cs - beta * sn);
        a0 = (A + 1) - (A - 1) * cs + beta * sn;
        a1 = 2 * ((A - 1) - (A + 1) * cs);
        a2 = (A + 1) - (A - 1) * cs - beta * sn;
        break;
    default:
        free(b);
        return NULL;
    }

    /* precompute the coefficients */
    b->a0 = b0 /a0;
    b->a1 = b1 /a0;
    b->a2 = b2 /a0;
    b->a3 = a1 /a0;
    b->a4 = a2 /a0;

    /* zero initial samples */
    b->x1 = b->x2 = 0;
    b->y1 = b->y2 = 0;

    return b;
}
/* crc==3062280887, version==4, Sat Jul  7 00:03:23 2001 */