Author: solocan (page 5 of 8)

Digitales Kerbfilter (Notch filter)

21. November 2019 / solocan / Noch kein Kommentar

Das Kerbfilter (engl. Notch filter) sperrt eine Frequenz bzw. einen sehr engen Frequenzbereich um $f_0$ , während es den Rest des Spektrums durchlässt.

Rendered by QuickLaTeX.com

Die Übertragungsfunktion eines digitalen Kerbfilters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=\frac{s^2+1}{s^2+\frac{1}{Q}s+1} \end{equation*}$

beschrieben werden.

Ermittlung der Koeffizienten für das Biquad-filter

Nach der bilinearen Transformation erhält man

(2) $\begin{equation*} \begin{align} a_0&=1+\alpha \\ b_{n,0}&=\frac{1}{a_0} \\ b_{n,1}&=\frac{1}{a_0} (-2 \cos(w_0))\\ b_{n,2}&=\frac{1}{a_0} \\ a_{n,1}&=\frac{1}{a_0} (-2 \cos(w_0))\\ a_{n,2}&=\frac{1}{a_0} (1-\alpha) \\ \end{align} \end{equation*}$

wobei

(3) $\begin{equation*} \begin{align} f_0 &: Grenzfrequenz\\ F_s&: Abtastrate\\ \omega_0&=2 \pi \frac{f_0}{F_s}\\ \frac{1}{Q}&=2 \sinh(\frac{\ln(2) BW}{2})\\ \alpha&=\frac{sin(\omega_0)}{2 Q} \end{align} \end{equation*}$

Implementierung

Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.

//Deklaration
double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen
A=pow(10,gain/40);
w0=2*PI*(f0/FS);
cosw0=cos(w0);
sinw0=sin(w0);
alpha=sinw0/(2*Q);

//Normalisierungsparameter
a0_inv=1/(1+alpha);

//Koeffizientenberechnung
bn0=a0_inv;
bn1=(float)((-2 cosw0)*a0_inv);
bn2=a0_inv;
an1=(float)((-2 cosw0)*a0_inv);
an2=(float)((1-alpha)*a0_inv);

//Deklaration

double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen

A=pow(10,gain/40);

w0=2*PI*(f0/FS);

cosw0=cos(w0);

sinw0=sin(w0);

alpha=sinw0/(2*Q);

//Normalisierungsparameter

a0_inv=1/(1+alpha);

//Koeffizientenberechnung

bn0=a0_inv;

bn1=(float)((-2 cosw0)*a0_inv);

bn2=a0_inv;

an1=(float)((-2 cosw0)*a0_inv);

an2=(float)((1-alpha)*a0_inv);

Am Code lassen sich manche Optimierungen erkennen.

Mehrmals vorkommende Variablen sind vorberechnet (z.B. trigonometrische Funktionen)
Anstatt jedes mal durch $a_0$ zu teilen, wird mit inversem (ein mal vorberechneten) Wert $a_0^{-1}$ multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.
Die Berechnungen erfolgen mit Gleitkommezahlen doppelter Präzision (double) und wird am Ende auf Float gecastet. Der Grund: Trigonometrischen Funktionen mit Single-Präzision (float) kann zu erheblichen numerischen Fehlern und dadurch zu unerwünschten Ergebnissen bzw. Instabilität führen.
Der Code ist optimiert für die Hardware-FPU von Cortex-M7 Mikroprozessor.

Digitales Bandpassfilter

21. November 2019 / solocan / Noch kein Kommentar

Das Bandpassfilter lässt einen Frequenzbereich um $f_0$ durch, während es die den Rest des Spektrums sperrt.

Rendered by QuickLaTeX.com

Die Übertragungsfunktion eines digitalen Bandpassfilters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=\frac{\frac{1}{Q}s}{s^2+\frac{1}{Q}s+1} \end{equation*}$

beschrieben werden.

Ermittlung der Koeffizienten für das Biquad-filter

Nach der bilinearen Transformation erhält man

(2) $\begin{equation*} \begin{align} a_0&=1+\alpha \\ b_{n,0}&=\frac{1}{a_0}\alpha \\ b_{n,1}&=0\\ b_{n,2}&=\frac{1}{a_0} (-\alpha)\\ a_{n,1}&=\frac{1}{a_0} (-2 \cos(w_0))\\ a_{n,2}&=\frac{1}{a_0} (1-\alpha) \\ \end{align} \end{equation*}$

wobei

Implementierung

Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.

//Deklaration
double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen
A=pow(10,gain/40);
w0=2*PI*(f0/FS);
cosw0=cos(w0);
sinw0=sin(w0);
alpha=sinw0/(2*Q);

//Normalisierungsparameter
a0_inv=1/(1+alpha);

//Koeffizientenberechnung
bn0=(float)(alpha*a0_inv);
bn1=0;
bn2=(float)(-alpha)*a0_inv;
an1=(float)((-2 cosw0)*a0_inv);
an2=(float)((1-alpha)*a0_inv);

//Deklaration

double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen

A=pow(10,gain/40);

w0=2*PI*(f0/FS);

cosw0=cos(w0);

sinw0=sin(w0);

alpha=sinw0/(2*Q);

//Normalisierungsparameter

a0_inv=1/(1+alpha);

//Koeffizientenberechnung

bn0=(float)(alpha*a0_inv);

bn1=0;

bn2=(float)(-alpha)*a0_inv;

an1=(float)((-2 cosw0)*a0_inv);

an2=(float)((1-alpha)*a0_inv);

Am Code lassen sich manche Optimierungen erkennen.

Mehrmals vorkommende Variablen sind vorberechnet (z.B. trigonometrische Funktionen)
Anstatt jedes mal durch $a_0$ zu teilen, wird mit inversem (ein mal vorberechneten) Wert $a_0^{-1}$ multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.
Die Berechnungen erfolgen mit Gleitkommezahlen doppelter Präzision (double) und wird am Ende auf Float gecastet. Der Grund: Trigonometrischen Funktionen mit Single-Präzision (float) kann zu erheblichen numerischen Fehlern und dadurch zu unerwünschten Ergebnissen bzw. Instabilität führen.
Der Code ist optimiert für die Hardware-FPU von Cortex-M7 Mikroprozessor.

Kuhschwanzfilter 2 – Low shelving filter

21. November 2019 / solocan / Noch kein Kommentar

Das Kuhschwanzfilter für Tiefenanpassung (engl. Low shelving filter) verstärkt oder dämpft einen Frequenzbereich unter $f_0$ gleichmäßig, während es die die höheren Frequenzen des Spektrums unverändert durchlässt.

Rendered by QuickLaTeX.com

Die Übertragungsfunktion eines digitalen Low-Shelving Filters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=A \frac{s^2+\frac{\sqrt{A}}{Q}s+A}{As^2+\frac{\sqrt{A}}{Q}s+1} \end{equation*}$

beschrieben werden.

Ermittlung der Koeffizienten für das Biquad-filter

Nach der bilinearen Transformation erhält man

(2) $\begin{equation*} \begin{align} a_0&=((A+1)+(A-1) \cos(w_0)+2 \sqrt{A} \alpha) \\ b_{n,0}&=\frac{1}{a_0}((A ((A+1)-(A-1) \cos(w_0)+2 \sqrt{A} \alpha)) \\ b_{n,1}&=\frac{1}{a_0}(2 A ((A-1)-(A+1) \cos(w_0)))\\ b_{n,2}&=\frac{1}{a_0}((A ((A+1)-(A-1) \cos(w_0)-2 \sqrt{A} \alpha)) \\ a_{n,1}&=\frac{1}{a_0} (-2 ((A-1)+(A+1) \cos(w_0)))\\ a_{n,2}&=\frac{1}{a_0} ((A+1)+(A-1) \cos(w_0)-2 \sqrt{A} \alpha) \\ \end{align} \end{equation*}$

wobei

Implementierung

Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.

//Deklaration
double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen
A=pow(10,gain/40);
w0=2*PI*(f0/FS);
cosw0=cos(w0);
sinw0=sin(w0);
alpha=sinw0/(2*Q);

//Normalisierungsparameter
a0_inv=1/((A+1)+(A-1)*cosw0+2*sqrt(A)*alpha);

//Koeffizientenberechnung
bn0=(float)((A*((A+1)-(A-1)*cosw0+2*sqrt(A)*alpha))*a0_inv);
bn1=(float)((2*A*((A-1)-(A+1)*cosw0))*a0_inv);
bn2=(float)((A*((A+1)-(A-1)*cosw0-2*sqrt(A)*alpha))*a0_inv);
an1= (float)((-2*((A-1)+(A+1)*cosw0))*a0_inv);
an2=(float)(((A+1)+(A-1)*cosw0-2*sqrt(A)*alpha)*a0_inv);

//Deklaration

double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen

A=pow(10,gain/40);

w0=2*PI*(f0/FS);

cosw0=cos(w0);

sinw0=sin(w0);

alpha=sinw0/(2*Q);

//Normalisierungsparameter

a0_inv=1/((A+1)+(A-1)*cosw0+2*sqrt(A)*alpha);

//Koeffizientenberechnung

bn0=(float)((A*((A+1)-(A-1)*cosw0+2*sqrt(A)*alpha))*a0_inv);

bn1=(float)((2*A*((A-1)-(A+1)*cosw0))*a0_inv);

bn2=(float)((A*((A+1)-(A-1)*cosw0-2*sqrt(A)*alpha))*a0_inv);

an1= (float)((-2*((A-1)+(A+1)*cosw0))*a0_inv);

an2=(float)(((A+1)+(A-1)*cosw0-2*sqrt(A)*alpha)*a0_inv);

Am Code lassen sich manche Optimierungen erkennen.

Mehrmals vorkommende Variablen sind vorberechnet (z.B. trigonometrische Funktionen)
Anstatt jedes mal durch $a_0$ zu teilen, wird mit inversem (ein mal vorberechneten) Wert $a_0^{-1}$ multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.
Die Berechnungen erfolgen mit Gleitkommezahlen doppelter Präzision (double) und wird am Ende auf Float gecastet. Der Grund: Trigonometrischen Funktionen mit Single-Präzision (float) kann zu erheblichen numerischen Fehlern und dadurch zu unerwünschten Ergebnissen bzw. Instabilität führen.
Der Code ist optimiert für die Hardware-FPU von Cortex-M7 Mikroprozessor.

Klangbeispiele

Gitarre - Rythmus trocken

Gitarre - Rythmus Low shelf 10db 400Hz

Gitarre - Rythmus Low shelf -10db 400Hz

Kuhschwanzfilter 1 – High shelving filter

21. November 2019 / solocan / Noch kein Kommentar

Das Kuhschwanzfilter für Höhenanpassung (engl. High shelving filter) verstärkt oder dämpft einen Frequenzbereich über $f_0$ gleichmäßig, während es die die tieferen Frequenzen des Spektrums unverändert durchlässt.

Rendered by QuickLaTeX.com

Die Übertragungsfunktion eines digitalen High-Shelving Filters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=A \frac{A s^2+\frac{\sqrt{A}}{Q}s+1}{s^2+\frac{\sqrt{A}}{Q}s+A} \end{equation*}$

beschrieben werden.

Ermittlung der Koeffizienten für das Biquad-filter

Nach der bilinearen Transformation erhält man

(2) $\begin{equation*} \begin{align} a_0&=((A+1)-(A-1) \cos(w_0)+2 \sqrt{A} \alpha) \\ b_{n,0}&=\frac{1}{a_0}((A ((A+1)+(A-1) \cos(w_0)+2 \sqrt{A} \alpha)) \\ b_{n,1}&=\frac{1}{a_0}(-2 A ((A-1)+(A+1) \cos(w_0)))\\ b_{n,2}&=\frac{1}{a_0}((A ((A+1)+(A-1) \cos(w_0)-2 \sqrt{A} \alpha)) \\ a_{n,1}&=\frac{1}{a_0} 2 ((A-1)-(A+1) \cos(w_0))\\ a_{n,2}&=\frac{1}{a_0} ((A+1)-(A-1) \cos(w_0)-2 \sqrt{A} \alpha) \\ \end{align} \end{equation*}$

wobei

Implementierung

Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.

//Deklaration
double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen
A=pow(10,gain/40);
w0=2*PI*(f0/FS);
cosw0=cos(w0);
sinw0=sin(w0);
alpha=sinw0/(2*Q);

//Normalisierungsparameter
a0_inv=1/((A+1)-(A-1)*cosw0+2*sqrt(A)*alpha);

//Koeffizientenberechnung
bn0=(float)((A*((A+1)+(A-1)*cosw0+2*sqrt(A)*alpha))*a0_inv);
bn1=(float)((-2*A*((A-1)+(A+1)*cosw0))*a0_inv);
bn2=(float)((A*((A+1)+(A-1)*cosw0-2*sqrt(A)*alpha))*a0_inv);
an1= (float)((2*((A-1)-(A+1)*cosw0))*a0_inv);
an2=(float)(((A+1)-(A-1)*cosw0-2*sqrt(A)*alpha)*a0_inv);

//Deklaration

double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen

A=pow(10,gain/40);

w0=2*PI*(f0/FS);

cosw0=cos(w0);

sinw0=sin(w0);

alpha=sinw0/(2*Q);

//Normalisierungsparameter

a0_inv=1/((A+1)-(A-1)*cosw0+2*sqrt(A)*alpha);

//Koeffizientenberechnung

bn0=(float)((A*((A+1)+(A-1)*cosw0+2*sqrt(A)*alpha))*a0_inv);

bn1=(float)((-2*A*((A-1)+(A+1)*cosw0))*a0_inv);

bn2=(float)((A*((A+1)+(A-1)*cosw0-2*sqrt(A)*alpha))*a0_inv);

an1= (float)((2*((A-1)-(A+1)*cosw0))*a0_inv);

an2=(float)(((A+1)-(A-1)*cosw0-2*sqrt(A)*alpha)*a0_inv);

Am Code lassen sich manche Optimierungen erkennen.

Mehrmals vorkommende Variablen sind vorberechnet (z.B. trigonometrische Funktionen)
Anstatt jedes mal durch $a_0$ zu teilen, wird mit inversem (ein mal vorberechneten) Wert $a_0^{-1}$ multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.
Die Berechnungen erfolgen mit Gleitkommezahlen doppelter Präzision (double) und wird am Ende auf Float gecastet. Der Grund: Trigonometrischen Funktionen mit Single-Präzision (float) kann zu erheblichen numerischen Fehlern und dadurch zu unerwünschten Ergebnissen bzw. Instabilität führen.
Der Code ist optimiert für die Hardware-FPU von Cortex-M7 Mikroprozessor.

Klangbeispiele

Gitarre - Rythmus trocken

Gitarre - Rythmus High shelf 10db 4kHz

Gitarre - Rythmus High shelf -10db 4kHz

Glockenfilter (Peak Filter)

21. November 2019 / solocan / Noch kein Kommentar

Das Glockenfilter (engl. peak filter oder peaking filter) verstärkt oder schwächt einen Frequenzbereich um $f_0$ , während es die den Rest des Spektrums durchlässt.

Rendered by QuickLaTeX.com

Die Übertragungsfunktion eines digitalen Glockenfilters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=\frac{s^2+s\frac{A}{Q}+1}{s^2+s\frac{1}{A Q}+1} \end{equation*}$

beschrieben werden.

Ermittlung der Koeffizienten für das Biquad-filter

Nach der bilinearen Transformation erhält man

(2) $\begin{equation*} \begin{align} a_0&=1+\frac{\alpha}{A} \\ b_{n,0}&=\frac{1}{a_0} (1+\alpha A) \\ b_{n,1}&=\frac{1}{a_0} (-2 \cos(w_0))\\ b_{n,2}&=\frac{1}{a_0} (1-\alpha A) \\ a_{n,1}&=\frac{1}{a_0} (-2 \cos(w_0))\\ a_{n,2}&=\frac{1}{a_0} (1-\frac{\alpha}{A}) \\ \end{align} \end{equation*}$

wobei

Implementierung

Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.

//Deklaration
double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen
A=pow(10,gain/40);
w0=2*PI*(f0/FS);
cosw0=cos(w0);
sinw0=sin(w0);
alpha=sinw0/(2*Q);

//Normalisierungsparameter
a0_inv=1/(1+alpha);

//Koeffizientenberechnung
bn0=(float)((1+alpha*A)*a0_inv);
bn1=(float)((-2*cosw0)*a0_inv);
bn2=(float)(1-alpha*A)*a0_inv;
an1= bn1;
an2=(float)((1-alpha/A)*a0_inv);

//Deklaration

double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen

A=pow(10,gain/40);

w0=2*PI*(f0/FS);

cosw0=cos(w0);

sinw0=sin(w0);

alpha=sinw0/(2*Q);

//Normalisierungsparameter

a0_inv=1/(1+alpha);

//Koeffizientenberechnung

bn0=(float)((1+alpha*A)*a0_inv);

bn1=(float)((-2*cosw0)*a0_inv);

bn2=(float)(1-alpha*A)*a0_inv;

an1= bn1;

an2=(float)((1-alpha/A)*a0_inv);

Am Code lassen sich manche Optimierungen erkennen.

Mehrmals vorkommende Variablen sind vorberechnet (z.B. trigonometrische Funktionen)
Anstatt jedes mal durch $a_0$ zu teilen, wird mit inversem (ein mal vorberechneten) Wert $a_0^{-1}$ multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.
Die Berechnungen erfolgen mit Gleitkommezahlen doppelter Präzision (double) und wird am Ende auf Float gecastet. Der Grund: Trigonometrischen Funktionen mit Single-Präzision (float) kann zu erheblichen numerischen Fehlern und dadurch zu unerwünschten Ergebnissen bzw. Instabilität führen.
Der Code ist optimiert für die Hardware-FPU von Cortex-M7 Mikroprozessor.

Klangbeispiele

Gitarre - Rythmus trocken

Gitarre - Rythmus Peakfilter 10dB 250Hz

Gitarre - Rythmus Peakfilter -10dB 250Hz

Gitarre - Rythmus Peakfilter 10dB 4000Hz

Gitarre - Rythmus Peakfilter -10dB 4000Hz

Digitales Hochpassfilter (HPF)

21. November 2019 / solocan / Noch kein Kommentar

Das Hochpassfilter filtert die tieferen Frequenzen als die Grenzfrequenz $f_0$ heraus und lässt die Höheren durch.

Rendered by QuickLaTeX.com

Die Übertragungsfunktion eines digitalen Hochpassfilters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=\frac{s^2}{s^2+\frac{s}{Q}+1} \end{equation*}$

beschrieben werden.

Ermittlung der Koeffizienten für das Biquad-filter

Nach der bilinearen Transformation erhält man

(2) $\begin{equation*} \begin{align} a_0&=1+\alpha \\ b_{n,0}&=\frac{1}{1+\alpha} \frac{1+\cos(w_0)}{2} \\ b_{n,1}&=\frac{1}{1+\alpha} (-1-\cos(w_0))\\ b_{n,2}&=\frac{1}{1+\alpha} \frac{1+\cos(w_0)}{2} \\ a_{n,1}&=\frac{1}{1+\alpha} (-2 \cos(w_0))\\ a_{n,2}&=\frac{1}{1+\alpha} (1-\alpha)\\ \end{align} \end{equation*}$

wobei

(3) $\begin{equation*} \begin{align} f_0 &: Grenzfrequenz\\ F_s&: Abtastrate\\ \omega_0&=2 \pi \frac{f_0}{F_s}\\ \alpha&=\frac{sin(\omega_0)}{2 Q} \end{align} \end{equation*}$

Implementierung

Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.

//Deklaration
double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen
A=pow(10,gain/40);
w0=2*PI*(f0/FS);
cosw0=cos(w0);
sinw0=sin(w0);
alpha=sinw0/(2*Q);

//Normalisierungsparameter
a0_inv=1/(1+alpha);

//Koeffizientenberechnung
bn0=(float)((1+cosw0)*0.5*a0_inv);
bn1=(float)((-1-cosw0)*a0_inv);
bn2=bn0;
an1=(float)((-2*cosw0)*a0_inv);
an2=(float)((1-alpha)*a0_inv);

//Deklaration

double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen

A=pow(10,gain/40);

w0=2*PI*(f0/FS);

cosw0=cos(w0);

sinw0=sin(w0);

alpha=sinw0/(2*Q);

//Normalisierungsparameter

a0_inv=1/(1+alpha);

//Koeffizientenberechnung

bn0=(float)((1+cosw0)*0.5*a0_inv);

bn1=(float)((-1-cosw0)*a0_inv);

bn2=bn0;

an1=(float)((-2*cosw0)*a0_inv);

an2=(float)((1-alpha)*a0_inv);

Am Code lassen sich manche Optimierungen erkennen.

Mehrmals vorkommende Variablen sind vorberechnet (z.B. trigonometrische Funktionen)
Anstatt jedes mal durch $a_0$ zu teilen, wird mit inversem (ein mal vorberechneten) Wert $a_0^{-1}$ multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.
Die Berechnungen erfolgen mit Gleitkommezahlen doppelter Präzision (double) und wird am Ende auf Float gecastet. Der Grund: Trigonometrischen Funktionen mit Single-Präzision (float) kann zu erheblichen numerischen Fehlern und dadurch zu unerwünschten Ergebnissen bzw. Instabilität führen.
Der Code ist optimiert für die Hardware-FPU von Cortex-M7 Mikroprozessor.

Klangbeispiele

Gitarre - Rythmus trocken

Gitarre - Rythmus Hochpass 150Hz

Gitarre - Rythmus Hochpass 400Hz

Bilineare Transformation

21. November 2019 / solocan / 1 Kommentar

Wenn die Filterfunktionen im zeitkontinuierlichen Raum vorliegen, müssen diese zur Implementierung als digitales Filter in den zeitdiskreten Raum transformiert werden. Der Grund dafür ist, dass wir bei der digitalen Signalverarbeitung zeitlich abgetastete Signale haben. Das erfolgt durch die Ersetzung der Punkte $s$ in der S-Ebene:

(1) $\begin{equation*} \begin{aligned} s &\leftarrow K \frac{1-z^{-1}}{1+z^{-1}} \text{ mit } \\ K&\approx \frac{2}{T} \end{aligned} \end{equation*}$

wobei $T$ das zeitliche Abtastintervall, also der Kehrwert von der Abtastrate ist: $F_s=\frac{1}{T}$ .

Zur Frequenzentzerrung muss wird $K$ folgendermaßen ersetzt:

(2) $\begin{equation*} K\approx \frac{\omega_0}{\tan(\frac{\omega_0\ T}{2}} \end{equation*}$

Somit können die Variablen der zeitkontinuerlichen Achse $s$ ersetzt werden, um die Gleichung in den z-Bereich zu transformieren.

Diese führt jedoch zu sehr komplexen Gleichungen, wonach die analytische Berechnung der Koeffizienten ohne Softwarehilfe sehr schwierig wird. Daher müssen manche Vereinfachungen vorgenommen werden. Dazu wurden die $s$ –Ersatzgleichungen von Robert Bristow-Johnson aus seinem Audio-Kochbuch genommen.

Vereinfachung der Entzerrung nach Robert Bristow-Johnson

Hierfür wurde zur Entzerrung folgender Ersatz genommen.

(3) $\begin{equation*} K\approx \frac{1}{\tan(\frac{\omega_0}{ 2})} \end{equation*}$

mit

(4) $\begin{equation*} \begin{aligned} \tan(\frac{\omega_0}{ 2})&=\frac{\sin(\omega_0)}{1+\cos(\omega_0)} \text{ und } \\ \tan^2(\frac{\omega_0}{ 2})&=\frac{1-\cos(\omega_0)}{1+\cos(\omega_0)} \end{aligned} \end{equation*}$

ergeben sich die Ersatzgleichungen

(5) $\begin{equation*} \begin{aligned} s &\leftarrow \frac{\sin(\omega_0)}{1+\cos(\omega_0)} \cdot \frac{1-z^{-1}}{1+z^{-1}} \\ s^2 &\leftarrow \frac{1-\cos(\omega_0)}{1+\cos(\omega_0)} \cdot \frac{1-2z^{-1}+z^{-2}}{1+2z^{-1}+z^{-2}} \end{aligned} \end{equation*}$

Wenn man nun einen weiteren Vereinfachungsschritt vornimmt und alle Gleichungen mit

(6) $\begin{equation*} $(1+\cos(\omega_0))\cdot (1+2z^{-1}+z^{-2}) \end{equation*}$

multipliziert, erhält man

(7) $\begin{equation*} \begin{aligned} 1 &\leftarrow (1-\cos(\omega_0))\cdot (1+2z^{-1}+z^{-2})\\ s &\leftarrow (1-z^{-2}) \sin(\omega_0) \\ s^2 &\leftarrow (1-2z^{-1}+z^{-2}) (1+\cos(\omega_0)) \text{.} \end{aligned} \end{equation*}$

Nun können die $s$ in der zeitkontinuerlichen Übertragungsfunktion ersetzt und die zeitdiskrete Differentialgleichungen berechnet werden.

Digitales Tiefpassfilter (LPF)

19. November 2019 / solocan / Noch kein Kommentar

Das Tiefpassfilter filtert die höheren Frequenzen als die Grenzfrequenz $f_0$ heraus und lässt die Tieferen durch.

Rendered by QuickLaTeX.com

Die Übertragungsfunktion eines digitalen Tiefpassfilters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=\frac{1}{s^2+\frac{s}{Q}+1} \end{equation*}$

beschrieben werden.

Ermittlung der Koeffizienten für das Biquad-filter

Nach der bilinearen Transformation erhält man

(2) $\begin{equation*} \begin{align} a_0&=1+\alpha \\ b_{n,0}&=\frac{1}{1+\alpha} \frac{1-\cos(w_0)}{2} \\ b_{n,1}&=\frac{1}{1+\alpha} (1-\cos(w_0))\\ b_{n,2}&=\frac{1}{1+\alpha} \frac{1-\cos(w_0)}{2} \\ a_{n,1}&=\frac{1}{1+\alpha} (-2 \cos(w_0))\\ a_{n,2}&=\frac{1}{1+\alpha} (1-\alpha)\\ \end{align} \end{equation*}$

wobei

(3) $\begin{equation*} \begin{align} f_0 &: Grenzfrequenz\\ F_s&: Abtastrate\\ \omega_0&=2 \pi \frac{f_0}{F_s}\\ \alpha&=\frac{sin(\omega_0)}{2 Q} \end{align} \end{equation*}$

Implementierung

Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.

//Deklaration
double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen
A=pow(10,gain/40);
w0=2*PI*(f0/FS);
cosw0=cos(w0);
sinw0=sin(w0);
alpha=sinw0/(2*Q);

//Normalisierungsparameter
a0_inv=1/(1+alpha);

//Koeffizientenberechnung
bn0=(float)((1-cosw0)*0.5*a0_inv);
bn1=(float)((1-cosw0)*a0_inv);
bn2=bn0;
an1=(float)((-2*cosw0)*a0_inv);
an2=(float)((1-alpha)*a0_inv);

//Deklaration

double A,w0,cosw0,sinw0,alpha,a0;

//Hilfsvariablen

A=pow(10,gain/40);

w0=2*PI*(f0/FS);

cosw0=cos(w0);

sinw0=sin(w0);

alpha=sinw0/(2*Q);

//Normalisierungsparameter

a0_inv=1/(1+alpha);

//Koeffizientenberechnung

bn0=(float)((1-cosw0)*0.5*a0_inv);

bn1=(float)((1-cosw0)*a0_inv);

bn2=bn0;

an1=(float)((-2*cosw0)*a0_inv);

an2=(float)((1-alpha)*a0_inv);

Am Code lassen sich manche Optimierungen erkennen.

Mehrmals vorkommende Variablen sind vorberechnet (z.B. trigonometrische Funktionen)
Anstatt jedes mal durch $a_0$ zu teilen, wird mit inversem (ein mal vorberechneten) Wert $a_0^{-1}$ multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.
Die Berechnungen erfolgen mit Gleitkommezahlen doppelter Präzision (double) und wird am Ende auf Float gecastet. Der Grund: Trigonometrischen Funktionen mit Single-Präzision (float) kann zu erheblichen numerischen Fehlern und dadurch zu unerwünschten Ergebnissen bzw. Instabilität führen.
Der Code ist optimiert für die Hardware-FPU von Cortex-M7 Mikroprozessor.

Klangbeispiele

Gitarre - Rythmus trocken

Guitar Rythmus Tiefpass 4kHz

Guitar Rythmus Tiefpass 2kHz

Biquad Filter

17. November 2019 / solocan / Noch kein Kommentar

Biquad Filter sind das Herzstück vieler digitalen Filterimplementierungen. Es ist -wie der Name sagt- ein „biquadratisches Filter“. Das heißt, sowohl der Nenner als auch der Zähler sind von der zweiten Ordnung.

Es ist ein Filter mit unendlicher Impulsantwort (IIR=Infinite impulse response). Die IIR-Filter können im Gegensatz zu FIR-Filter (Finite impulse response) instabil werden. Je höher die Ordnung, desto problematischer ist die Stabilität. Doch, die Filter erster und zweiter Stufe sind recht einfach Stabil zu bekommen, bzw. zu berechnen. Genau aus dem Grund sind die Biquad-Filter sehr beliebt. Um Filter höherer Ordnungen zu erreichen, kann man Biquad-Filter kaskadieren. Zudem für viele Standardfilter sind einzelne Biquad-Blöcke vollkommen ausreichend.

Mathematische Beschreibung

Im z-Bereich kann man ein Biquad-Filter folgendermaßen beschreiben:

(1) $\begin{equation*} H(z)=\frac{Y(z)}{X(z)}=\frac {b_0+b_1 z^{-1}+b_2 z^{-2}} {a_0+a_1 z^{-1}+a_2 z^{-2}} \end{equation*}$

Das führt zur Differentialgleichung:

(2) $\begin{equation*} y[n] = \frac {1}{a_0} (b_0 x[n]+b_1 x[n-1]+b_2 x[n-2] -a_1 y[n-1] - a_2 y[n-2]) \end{equation*}$

oder normalisiert durch $\frac{1}{a_0}$ ergibt

(3) $\begin{equation*} y[n] = \frac {b_0}{a_0} x[n]+\frac {b_1}{a_0} x[n-1]+\frac {b_2}{a_0} x[n-2] -\frac {a_1}{a_0} y[n-1] - \frac {a_2}{a_0} y[n-2]) \end{equation*}$

Der Regelkreis der 1. direkten Form sieht folgendermaßen aus.

In dieser Form kann man das Filter implementieren. Eine C++ Funktion könnte so aussehen:

/*Main process*/
float c_biquad::process(float *x){

	//Process biquad filter
	y=
		 *x*bn0
		+x1*bn1
		+x2*bn2
		-y1*an1
		-y2*an2;

	//Update the history array
	x2=x1;
	y2=y1;
	x1=*x;
	y1=y;

	return y;

}

/*Main process*/

float c_biquad::process(float *x){

//Process biquad filter

*x*bn0

+x1*bn1

+x2*bn2

-y1*an1

-y2*an2;

//Update the history array

x2=x1;

y2=y1;

x1=*x;

y1=y;

return y;

}

Das heißt, bei einer pro Zeitschritt werden 5 Multiplikationen, 4 Additionen und je nach Optimierung des Compilers im Besten Fall 4 Speicherkopiervorgänge gebraucht. Bei einem DSP mit MAC-Operationen je nach verfügbaren Befehlsätzen reduziert sich die Zyklen dementsprechend, die man für eine Biquad-Berechnung braucht.

Soweit relativ einfach verständlich. Nun müssen die Parameter für unsere erwünschte Filter ermitteln. Das ist das große Gebiet des Filter-Designs. Wir müssen dafür die Übertragungsfunktion im Frequenzbereich $H(s)$ von unserem erwünschten Filter ermitteln. Danach können wir dies durch bilineare Transformation in den z-Bereich führen und daraus die zeitdiskreten Differentialgleichungen ableiten und implementieren.

Also ein typischer Ablauf des Filterdesigns ist:

Ermittlung der Übertragungsfunktion
1. Mit Hilfe der analogen Filter
2. Sonstige mathematische Ansätze
3. Durch vorhandenen Regelkreis
Vom Frequenzbereich in z-Bereich umwandeln
1. z-Transformation
2. Bilineare Transformation (BLT)
Im z-Bereich die Koeffizienten berechnen.
Implementieren

Das komplizierteste davon ist der erste Punkt: Ermittlung der Übertragungsfunktion. Die Übertragungsfunktionen für Audio-Filter sind u. a. hier oder hier ermittelt. Anbei eine Übersicht für die wichtigsten Filter und dessen Berechnungsroutinen.

Tiefpassfilter
Hochpassfilter
Bandpassfilter
Notch-Filter
Allpassfilter
Peak-Filter
Shelf-Filter (Kuhschwanzfilter)
- Low-Shelf-Filter
- High-Shelf-Filter

Embedded

17. November 2019 / solocan / Noch kein Kommentar

Übersicht Embedded