Kategorie: Effects (page 2 of 3)

Digitaler Chorus-Effekt

26. November 2019 / solocan / Noch kein Kommentar

Ein Choruseffekt (engl. für Chor-Effekt) ist ein Modulationseffekt, der das Eingangssignal kopiert und dessen Tonhöhe (Pitch) mit einem Niedrigfrequenzoszillator (LFO: engl. Low-frequency oscillator) ändert. Somit entsteht eine „imperfekte“ Kopie vom Eingangssignal, das dem Ausgangssignal beigemischt wird. Dadurch entsteht der sogenannte Chor-Effekt. Im folgenden ist das Grundprinzip eines Chorus aufgezeigt.

Im obigen Diagramm gibt es nur eine Kopie des Eingangssignals (single-tap). Es ist auch üblich mehrere Kopien zu machen und mit verschiedenen Parametern einen „mehrköpfigen“ Chor zu erzielen.

Parameter

Folgende Kontrollparameter sind für einen Chorus-Effekt üblich:

Frequenz

Mit der Frequenz kontrolliert man die Geschwindigkeit der Frequenzmodulation. Üblicherweise in Hertz [Hz]. Typische Werte zwischen 1Hz und 25Hz.

Tiefe (Depth)

Mit diesem Parameter kontrolliert man die Wirksamkeit der Modulation. Sie wird in Prozent oder in Millisekunden (Delay-Zeit) angegeben. Wenn z.B. die Basis-Delayzeit 25ms ist und die Tiefe 50%, dann bedeutet das, dass das Delay zwischen 12,5ms und 37,5ms moduliert wird.

Wet/Dry

Hiermit wird kontrolliert, wie stark das modulierte Signal ins Ausgangssignal beigemischt werden soll.

Multi-Tap

Man kann das Eingangssignal auch mehr als ein mal abzweigen und modulieren. Wenn man die Einstellungen nicht für jeden Tap vornehmen will, kann man diese algorithmisch beliebig zusammensetzen.

Modulation mit LFO

Ein LFO ist nichts anderes als ein Signalgenerator, der in der Regel ein niederfrequentes Sinus-Signal generiert. Diese Signalquelle nutzt man u. a. zur Modulation eines Signals.

Im Fall eines Chorus moduliert man „die Abtastfrequenz“. Konkret tut man das, in dem man die Delay-Zeit kontinuierlich erhöht und reduziert. Diese Delay-Zeit ist in der Regel sehr kurz und liegt im Fall von Chorus in der Regel 5-50ms. Man nimmt eine Referenzdelayzeit. Z.b. 20ms und moduliert diese mit LFO zwischen 10ms und 30ms. Dadurch verlangsamt und beschleunigt das Signal und es entsteht eine Frequenzverschiebung. Dies wird musikalisch als eine Intonation wahrgenommen.

Implementierung

LFO

Für das Chorus-Puffer wird ein Kreispuffer benötigt, in dem Eingangssignal aufgenommen wird. Beim Multi-tap-Chorus braucht man nicht mehrere Puffer sondern nur mehrere LFOs und mehrere Zeiger auf das Puffer.

/*
LFO
*/
float c_chorus::lfo(void){

	float y_lfo;

	//Calculate LFO value
	y_lfo=sin(a_lfo);

	//Update angle
	a_lfo+=a_step;
	if(a_lfo>=2*PI){
		a_lfo=a_lfo-2*PI;
	}

	return y_lfo;
}

/*
Calculate rotating delay
*/
float c_chorus::get_current_delay(void){

	//Calculate time
	float t;
	t=d_base+depth*lfo();

	//Return the delay time
	return t;

}

LFO

float c_chorus::lfo(void){

float y_lfo;

//Calculate LFO value

y_lfo=sin(a_lfo);

//Update angle

a_lfo+=a_step;

if(a_lfo>=2*PI){

a_lfo=a_lfo-2*PI;

}

return y_lfo;

}

Calculate rotating delay

float c_chorus::get_current_delay(void){

//Calculate time

float t;

t=d_base+depth*lfo();

//Return the delay time

return t;

}

Hauptroutine

Der Algorithmus vom Chorus ist vergleichbar mit einem Delay-Algorithmus ohne Feedback und mit variabler Delay-Zeit.

/*
Main chorus single tap
*/
float c_chorus::process(float x){

	float y;

	float t_c;	//Current delay

	//Get tap distance
	t_c=get_current_delay(); //Tap distance

	//Calculate the position of the pointer
	int wptr;

	wptr=cptr-lrint(t_c*FSms);

	if(wptr<0){
		wptr+=chorus_len;
	}

	//Calculate output
	y=G_d*x + G_w*cbuf[wptr];

	//Update the buffer
	cbuf[cptr]=x;

	//Increment
	cptr++;
	if(cptr>=chorus_len){
		cptr-=chorus_len;
	}

	return y;
}

Main chorus single tap

float c_chorus::process(float x){

float y;

float t_c; //Current delay

//Get tap distance

t_c=get_current_delay(); //Tap distance

//Calculate the position of the pointer

int wptr;

wptr=cptr-lrint(t_c*FSms);

if(wptr<0){

wptr+=chorus_len;

}

//Calculate output

y=G_d*x + G_w*cbuf[wptr];

//Update the buffer

cbuf[cptr]=x;

//Increment

cptr++;

if(cptr>=chorus_len){

cptr-=chorus_len;

}

return y;

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre - Rythmus Chorus - Depth: 10 - Rate: 7Hz

Gitarre - Rythmus Chorus - Depth: 50 - Rate: 7Hz

Gitarre - Rythmus Chorus - Depth: 90 - Rate: 7Hz

Gitarre - Rythmus Chorus - Depth: 50 - Rate: 2Hz

Gitarre - Rythmus Chorus - Depth: 50 - Rate: 15Hz

Digitales Delay

22. November 2019 / solocan / Noch kein Kommentar

Ein Delay (Engl. für Verzögerung) ist in digitaler Ausführung -im Gegensatz zu analog- ein recht simpel zu implementierender Effekt. In der Grundform ohne Rückkopplung verzögert es das Eingangssignal um einen voreingestellten Zeitversatz und mischt das verzögerte Signal zum Eingangssignal (trockenes Signal) bei. Dabei entsteht ein Delay-Effekt. Mit der Rückkopplung, siehe Abbildung, wird das verzögerte Signal durch ein Feedbackverstärkung $G_{FB}$ abgeschwächt und zum Eingangssignal der Verzögerungseingang $a[n]$ zurückgemischt.

Parameter

Folgende Kontrollparameter sind für einen Flanger-Effekt üblich:

Delay-Zeit

Einstellung der Delay-Zeit. Üblicherweise in Millisekunden. Oft wird zur Angabe der Delay-Zeit eine „Tapping“ Funktion zur Verfügung gestellt, mit der der Benutzer den Takt mit einem Taster vorgeben kann und dieser Takt wird in die Zeit umgerechnet.

Takt

Der Parameter, ob der angetippter Takt als z.B. als Viertel, Achtel oder Sechszehntel zu verstehen ist.

Rückkopplungsdämpfung (Feedback gain)

Mit diesem Parameter kontrolliert man die Dämpfung der Rückkopplung. Aus Stabilitsgründen muss sich diese im Intervall von

(1) $\begin{equation*} 0 \leq G_{FB} <1 \end{equation*}$

befinden.

Multi-Tap

Man kann das Eingangssignal auch mehr als ein mal abzweigen und verzögern. Wenn man die Einstellungen nicht für jeden Tap vornehmen will, kann man diese algorithmisch beliebig zusammensetzen (lassen).

Pre-Delay

Die Verzögerung des trockenen Signals.

Wet/Dry

Hiermit wird kontrolliert, wie stark das verzögerte Signal ins Ausgangssignal beigemischt werden soll.

Implementierung

Für das Delay wird ein großes Kreispuffer für $z^{-M}= benötigt, in dem Delay-Signal aufgenommen wird.

/*Main process of delay line */
float c_delay::process(float x){

	float y;

	//Calculate output
	y=dbuf[dptr]*G_w+x*G_d;

	//Update buffer
	dbuf[dptr]=x+dbuf[dptr]*G_fb;

	//Increment pointer (circular buffer)
	dptr++;

        //Reset pointer (circular buffer)
	if(dptr>=n_distance){
		dptr=0;
	}

	return y;
}

/*Main process of delay line */

float c_delay::process(float x){

float y;

//Calculate output

y=dbuf[dptr]*G_w+x*G_d;

//Update buffer

dbuf[dptr]=x+dbuf[dptr]*G_fb;

//Increment pointer (circular buffer)

dptr++;

//Reset pointer (circular buffer)

if(dptr>=n_distance){

dptr=0;

}

return y;

}

Die Variable n_distance ist das Delay time umgerechnet in Anzahl der Samples und berechnet sich (nach jedem Delay-Time update) folgendermaßen:

/*
Routine for setting the delay time
*/
void c_delay::set_time(float *time){

        //Delay time is incoming as milliseconds
	delay_time=*time
	n_distance=(unsigned long)(*time*FSms);

	//Security for delay length
	if(n_distance>delay_max){
		n_distance=delay_max;
	}

	reset_buffer();

}

Routine for setting the delay time

void c_delay::set_time(float *time){

//Delay time is incoming as milliseconds

delay_time=*time

n_distance=(unsigned long)(*time*FSms);

//Security for delay length

if(n_distance>delay_max){

n_distance=delay_max;

}

reset_buffer();

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre - Rythmus Delay-Time: 600ms - Feedback: 0.5 - Wet gain:0.2

Gitarre - Rythmus Delay-Time: 300ms - Feedback: 0 - Wet gain:0.2

Gitarre - Rythmus Delay-Time: 300ms - Feedback: 0.5 - Wet gain:0.2

Gitarre - Rythmus Delay-Time: 300ms - Feedback: 0.9 - Wet gain:0.2

Digitales Allpassfilter

21. November 2019 / solocan / Noch kein Kommentar

Das Allpassfilter lässt alle Frequenzen durch, verursacht allerdings eine Phasenverschiebung, welches als Verzögerungselement verwendet werden kann.

Die Übertragungsfunktion eines digitalen Allpassfilters 2. Ordnung kann als

(1) $\begin{equation*} H(s)=\frac{s^2-\frac{1}{Q}s+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} (1-\alpha) \\ b_{n,1}&=\frac{1}{a_0} (-2 \cos(w_0))\\ b_{n,2}&=1\\ 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=1;
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=1;

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 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

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.