Elektrotechnik Bericht

Herleitung eines digitalen Tiefpasses 2. Ordnung

Von der analogen Übertragungsfunktion zur diskreten Implementierung

Digitale Filter sind ein zentraler Bestandteil moderner Signalverarbeitung – von Audio-Anwendungen bis zur Regelungstechnik. Ein besonders effizienter und weit verbreiteter Ansatz ist der IIR-Filter 2. Ordnung (Biquad).

In diesem Artikel zeige ich Schritt für Schritt, wie aus einer analogen Übertragungsfunktion ein digitaler Filter entsteht und wie dieser direkt in Code umgesetzt werden kann.

Praxis: Digitale Filter berechnen – Biquad-Koeffizienten aus Grenzfrequenz und Abtastrate (mit Rechner)

Was ist ein IIR-Filter (kurz erklärt)

Ein IIR-Filter (Infinite Impulse Response) nutzt vergangene Ausgangswerte zur Berechnung des aktuellen Signals. Dadurch kann mit wenig Rechenaufwand ein starkes Filterverhalten erreicht werden.

1. Analoge Ausgangsbasis

Ein normierter Tiefpass 2. Ordnung wird beschrieben durch:

\[ G(s) = \frac{1}{a s^2 + b s + 1} \]

Hier bestimmt \(a\) im Wesentlichen die Grenzfrequenz und \(b\) die Dämpfung bzw. Güte.

2. Bilineare Transformation

Zur Digitalisierung wird die bilineare Transformation verwendet:

\[ s = \frac{2}{T_s}\cdot\frac{1-z^{-1}}{1+z^{-1}} \]

Mit \(c = \frac{2}{T_s}\) erhält man für den z-Bereich:

\[ H(z) = \frac{z^{-2} + 2z^{-1} + 1}{(a c^2 - b c + 1) z^{-2} + (2 - 2a c^2) z^{-1} + (b c + a c^2 + 1)} \]

3. Differenzgleichung (IIR, 2. Ordnung)

Mit Eingang \(U_E[k]\) und Ausgang \(U_A[k]\):

\[ U_A[k] = U_E[k] + 2U_E[k-1] + U_E[k-2] - vU_A[k-1] - uU_A[k-2] \]

mit:

\[ u = a c^2 - b c + 1,\quad v = 2 - 2a c^2,\quad w = b c + a c^2 + 1 \]

Das entspricht einem klassischen Biquad-IIR-Filter. Dieselbe Struktur lässt sich in der üblichen Standardnotation mit \(b_0, b_1, b_2\) und \(a_1, a_2\) schreiben, wenn die Werte aus der Herleitung entsprechend normiert werden (siehe unten).

Vom mathematischen Modell zum Code

Die Differenzgleichung in allgemeiner Form (Eingang \(x[k]\), Ausgang \(y[k]\)):

\[ y[k] = b_0 x[k] + b_1 x[k-1] + b_2 x[k-2] - a_1 y[k-1] - a_2 y[k-2] \]

Sie beschreibt den Filter rein mathematisch. Damit daraus lauffähiger Code wird, muss man sie in Speicher und Ablauf übersetzen.

1. Bedeutung der Terme

• \(x[k]\) – aktueller Eingangswert
• \(x[k-1]\), \(x[k-2]\) – vergangene Eingangswerte
• \(y[k-1]\), \(y[k-2]\) – vergangene Ausgangswerte

Wichtig: Der Rechner kennt keine „Vergangenheit“ von allein – vergangene Samples müssen in Variablen gespeichert werden.

2. Speicher (Zustände) definieren

Für die Vergangenheit braucht man typischerweise:

x1 = x[k-1]
x2 = x[k-2]
y1 = y[k-1]
y2 = y[k-2]

Das sind genau die Zustände des Filters.

3. Gleichung direkt in Code übersetzen

Die Formel lässt sich nahezu 1:1 übernehmen:

y = b0 * x
  + b1 * x1
  + b2 * x2
  - a1 * y1
  - a2 * y2;

Das ist dieselbe Differenzgleichung – nur in Codeform.

4. Zustände aktualisieren

Nach der Berechnung werden die gespeicherten Werte für den nächsten Abtastschritt weitergeschoben:

x2 = x1;
x1 = x;

y2 = y1;
y1 = y;

So wird aus dem aktuellen Wert beim nächsten Durchlauf der „vergangene“ Wert.

5. Ablauf pro Sample

Für jedes neue Eingangssample läuft derselbe Zyklus:

1. neuen Eingang \(x[k]\) einlesen
2. Ausgang \(y[k]\) berechnen
3. Zustände aktualisieren

Genau das übernimmt typischerweise eine Funktion wie biquad_process().

6. Intuition

Der Filter „merkt sich“ die letzten Werte und gewichtet sie mit den Koeffizienten: Feedforward über aktuelle und frühere Eingänge (\(b_0, b_1, b_2\)), Feedback über frühere Ausgänge (\(a_1, a_2\)). So entsteht das typische Filterverhalten (z. B. Tiefpass).

7. Typische Fehler

• Zustände nach der Ausgabe nicht aktualisieren → falsches oder instabiles Verhalten
• falsche Reihenfolge beim Verschieben der Zustände
• Vorzeichen bei \(a_1, a_2\) in der Implementierung vergessen (in der Standardform stehen sie subtrahiert in der Gleichung)
• nicht normierte Koeffizienten verwenden, obwohl die Rekursion normiert erwartet wird

Kurz zum Übergang Gleichung → Code: Formel hinlegen → Zustände speichern → jedes Sample berechnen → Zustände verschieben. Das ist das Grundprinzip digitaler IIR-Filter in Direktform II (Biquad).

Implementierung in Code (IIR-Filter 2. Ordnung)

Die zuvor hergeleitete Differenzgleichung lässt sich direkt in Software umsetzen. Ein IIR-Filter 2. Ordnung (Biquad) benötigt nur wenige Speicherwerte und ist sehr effizient.

Allgemeine Form und Koeffizienten

\[ y[k] = b_0 x[k] + b_1 x[k-1] + b_2 x[k-2] - a_1 y[k-1] - a_2 y[k-2] \]

• \(b_0, b_1, b_2\) – Feedforward-Anteil (Zähler / Eingangspfad)
• \(a_1, a_2\) – Feedback-Anteil (Nenner / Rückkopplung; \(a_0\) ist typischerweise 1 nach Normierung)

Beispiel in C (Embedded / Mikrocontroller)

typedef struct {
    float b0, b1, b2;
    float a1, a2;
    float x1, x2;
    float y1, y2;
} Biquad;

float biquad_process(Biquad *f, float x) {
    float y = f->b0 * x
            + f->b1 * f->x1
            + f->b2 * f->x2
            - f->a1 * f->y1
            - f->a2 * f->y2;

    /* Zustände aktualisieren */
    f->x2 = f->x1;
    f->x1 = x;
    f->y2 = f->y1;
    f->y1 = y;

    return y;
}

Vorteile: sehr wenige Operationen pro Sample, gut vorhersagbare Laufzeit – ideal für Echtzeit (DSP, Mikrocontroller).

Beispiel in Python (Analyse / Simulation)

class Biquad:
    def __init__(self, b0, b1, b2, a1, a2):
        self.b0, self.b1, self.b2 = b0, b1, b2
        self.a1, self.a2 = a1, a2
        self.x1 = self.x2 = 0.0
        self.y1 = self.y2 = 0.0

    def process(self, x):
        y = (self.b0 * x +
             self.b1 * self.x1 +
             self.b2 * self.x2 -
             self.a1 * self.y1 -
             self.a2 * self.y2)

        self.x2 = self.x1
        self.x1 = x
        self.y2 = self.y1
        self.y1 = y

        return y

Zusammenhang mit der Herleitung

In der Herleitung treten die Parameter \(a\), \(b\) (analog) und \(c = 2/T_s\) sowie die diskreten Koeffizienten \(u\), \(v\), \(w\) auf. Daraus wird zunächst \(H(z)\) gebildet; für die Implementierung werden die Terme in die Standard-Biquad-Form mit \(b_0, b_1, b_2, a_1, a_2\) überführt – üblicherweise durch Normierung auf den führenden Nennerkoeffizienten (\(a_0 = 1\)).

Wichtig: Die Laufzeit-Rekursion arbeitet durchgehend mit diesen normierten Koeffizienten.

Praktische Hinweise

• Numerik: Bei hohen Frequenzen oder geringer Dämpfung können Rundungsfehler stärker ins Gewicht fallen.
• Fixed-Point vs. Float: Controller ohne FPU nutzen oft Festkomma-Arithmetik mit angepasster Skalierung.
• Initialwerte: \(x_1, x_2, y_1, y_2\) zu Beginn typischerweise auf 0 setzen (ruhender Start).
• Überlauf: Bei hoher Verstärkung oder Integer-Arithmetik auf Sättigung achten.

Fazit zur Implementierung

Die Umsetzung eines IIR-Filters 2. Ordnung ist strukturell einfach und sehr effizient; die eigentliche Komplexität liegt in der korrekten Berechnung und Normierung der Koeffizienten. Biquads sind deshalb der Standard in Audioverarbeitung, Regelungstechnik und Echtzeit-DSP.

Parameterwahl und Werkzeuge

Die kontinuierlichen Parameter der analogen Vorgabe (\(a\), \(b\) in \(G(s)\)) werden nach Grenzfrequenz und Dämpfung gewählt; \(T_s\) folgt aus der Abtastrate. Für Entwurf, Simulation und Verifikation eignen sich weiterhin u. a. Python/NumPy, MATLAB/Simulink und dedizierte DSP-Umgebungen.

Fazit

Die Herleitung zeigt, wie ein digitaler Tiefpass systematisch aus einer analogen Beschreibung entsteht. Mit der Biquad-Struktur erhält man eine sehr effiziente und praxisnahe Implementierung, die sich direkt in Embedded-Systemen, Audioanwendungen und Regelungen einsetzen lässt.

Besonders wichtig ist dabei die korrekte Berechnung und Normierung der Koeffizienten – sie bestimmen das tatsächliche Filterverhalten.

Mehr dazu findest du im Artikel: Biquad-Koeffizienten aus Grenzfrequenz berechnen