Die Leistungsstufe von Flex 500 beinhaltet ein 500W-starker Class-D Verstärker, versorgt von einem 600W Schaltnetzteil von Connex electronics.
Für die Leistungen bis <200W ist ein höherwertiger Class-AB-Verstärker aus der eigenen Entwicklung verfügbar. Dieser Class-AB Verstärker ist ein Bestandteil des analogen Vorgängers Flex-150.
Die Kleinsignalstufe vom Flex 500 sind unten dokumentiert.
Die Ressourcen sind frei verfügbar:
Die SPICE-Simulationsdateien für die Kleinsignalstufe herunterladen
Die Dynamikkompression (engl. Dynamic range compression) ist ein Prozess, der die Dynamik komprimiert bzw. reduziert. Das wird gemacht, indem die lauten Bereiche, die einen Schwellwert überschreiten, leiser gemacht werden, während die leiseren Bereiche unreduziert passieren. Die Charakteristik der Kompression lässt sich am Besten in einer Dynamikkurve darstellen, die die Beziehung zwischen der Einganglautstärke und Ausgangslautstärke beschreibt.
Die Steigung 
beschreibt die Kompressionsrate, mit der das Signal abgeschwächt wird. Dies greift ab dem Überschreiten eines Threshold-Werts.
Das Herzstück eines Kompressors ist ein spannungskontrollierter Verstärker (VCA). Im analogen Design, wird das mit komplexen Schaltungen realisiert. In der Digitaltechnik ist dies ein simpler Verstärkungsfaktor, mit dem das Signal multipliziert wird. Dieser Verstärkungsfaktor wird in einem parallelen Pfad berechnet. Der parallele Pfad besteht aus einem Lautstärkendetektor (in der Regel realisiert mit Effektivleistung, RMS) und einer Logik, die die Reduktion aus der Lautstärke berechnet (Gain computer).
Einer der wichtigsten Bestandteile einer Kompression ist die Berechnung der Lautstärke, Hier wird kontinuierlich ermittelt, wie hoch die empfundene Lautstärke ist. Gängigste Methode dafür ist der Effektivwert als quadratischer Mittelwert des relevanten Sampleabschnitts.
(1) 
Der RMS-Wert dient als Eingang für den Gain-Computer. Der Gain-Computer berechnet daraus die Verstärkung, die dem Signal appliziert werden soll. Es appliziert die Dynamikkurve, s. oben.
Folgende Kontrollparameter sind für einen Kompressor Effekt üblich:
Die Eingangsverstärkung wird auf das Eingangssignal appliziert, um das Signalniveau in einen gewünschten Platz in der Dynamikkurve zu platzieren. Alternativ kann man auch Threshold verschieben.
Der Threshold (dt. für Schranke/Grenze) ist der Grenzwert, ab dessen Überschreitung eine Gain-Reduktion erfolgt, s. Diagramm.
Sie beschreibt die Stärke der Gain-Reduktion nach Threshold, in der Dynamikkurve ist dies als Tangenzwert gezeigt.
Ab einem Wert von 60:1 wird von einem Limiter gesprochen.
Der Gain-Computer appliziert eine Gain-Reduktion. Das bedeutet, die gesamte Lautstärke des Signals sinkt. Um das ältere Lautstärkenniveau zu erreichen, wird ein Make-Up Gain am Ausgang appliziert.
Ab dem Threshold ändert sich die Verstärkung, die man appliziert. Dieser Übergang, der in der Dynamikkurve oben scharf gezeichnet wurde, kann auch mild erfolgen. So dass die Gain-Reduktion langsam eintritt.
Der Attack-Wert bestimmt, wann die Gain-Reduktion nach einer Überschreitung eintreten soll. Sie liegt im Bereich von 5 bis 250 ms.
Der Release-Wert bestimmt, wann nach einer Unterschreitung des Tresholds die Gain-Reduktion wieder aussetzen soll. Sie liegt üblicherweise im Bereich von 5 bis 100ms.
Im folgenden ist die Prozessroutine eines Kompressors gezeigt:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 |
/* Compressor main process */ float c_compressor::process(float x){ x*=input_gain; //Calculate RMS //Subtract oldest the value (rmsbuf[rptr]) from the sum rms_sum-=(rmsbuf[rptr]*rmsbuf[rptr])/(float)rms_len; //Add the newest value to the sum rms_sum+=(x*x)/rms_len; if(rms_sum<0){ printf("Warning: RMS sum negaive %f\n",rms_sum); rms_sum=0; } //Update the RMS Value c_rms=fast_sqroot(rms_sum); //Get logarithmic value c_rms=fast_log2(c_rms); //Update the buffer rmsbuf[rptr]=x; //Increment rptr++; if(rptr>=rms_len){ rptr=0;; } //Update main buf //Output is the last value on the buffer float y; y=buf[ptr]; //Set the new value to the buffer buf[ptr]=x; //Increment ptr++; if(ptr>=delay_len){ ptr=0;; } //Calculating attenuation float exponent; if(c_rms>threshold){ //Calculating exponent according Udo Zölzer exponent=-1*(c_rms-threshold)*slope; //Exponents smaller than -1500 are making fast algorithms unstable if(exponent<-100){ target_gain=0; }else{ target_gain=fastPow(2,exponent); // target_gain=pow(2,exponent); } }else{ target_gain=1; } //Attack and release if(comp_gain>target_gain){ //Attack comp_gain-=stepsize_attack; //Break decreasing if(comp_gain<=target_gain){ comp_gain=target_gain; } }else{ //Release comp_gain+=stepsize_release; //Break increasing if(comp_gain>=1){ comp_gain=1; } } return y*comp_gain;; } |
Eine der wichtigsten Komponenten des Kompressors ist der RMS-Rechner. Der Aufwand der Berechnung der Quadratsumme ist eine Multiplikation und eine Addition. Hingegen ist die Quadratwurzelberechnung eine sehr aufwändige Berechnung, die den Flaschenhals darstellt. Hierzu gibt es effiziente Algorithmen, die dies übernehmen. Ein davon (hier eingesetzter) Algorithmus ist der berühmte „fastsqroot„-Algorithmus. Dieser Algorithmus ist ursprünglich für Videoverarbeitung entwickelt und mittlerweile gut analysiert und breit eingesetzt.
|
1 2 3 4 5 6 7 8 9 |
inline double fastPow(double a, double b) { union { double d; int x[2]; } u = { a }; u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447); u.x[0] = 0; return u.d; }; |
Der berechnete RMS-Wert wird in einen logarithmischen Wert umgerechnet, woraus sich die wahrgenommene Lautstärke 
ergibt. Jeder Mensch empfindet die Lautstärke anders. Mann kann den Logarithmus auf 2 Basis, 10 Basis oder natürlichen Logarithmus nehmen.
(2) 
Die Potenzberechnung der Gleitkommazahlen ist auch eine teure Operation. Die Funktion pow() der Mathe-Bibliothek ist selbst auf FPUs sehr langsam, da es für alle Zahlen eine gute Genauigkeit liefern muss. Wir brauchen aber keine sehr Hohe Genauigkeit, da wir nur ein Verstärkungsfaktor berechnen. Dafür gibt es schnellere Funktion, wie z.B. fastPow
|
1 2 3 4 5 6 7 8 9 |
inline double fastPow(double a, double b) { union { double d; int x[2]; } u = { a }; u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447); u.x[0] = 0; return u.d; }; |
Den Klang eines Kompressors sollte man im Optimalfall nicht hören. Dennoch hier ein paar Beispiele der sehr starken Komprimierung, wo die Kompression im Vergleich zum trockenen Signal erkennbar ist.
Der Wah-Wah-Effekt ist ein Filtereffekt, der die hohen Frequenzen im Signal herausfiltert (Tiefpass) oder abschwächt (Shelving Filter). Die Filterung wird
kontrolliert. Im Fall vom WahWah-Pedal wird die Pedalposition genutzt, um die Frequenz des Tiefpassfilters zu ermitteln. Im Fall vom Auto Wah wird die Frequenz aus dem LFO abgeleitet.
Im folgenden ist das Grundprinzip des Wah-Wah-Effekts aufgezeigt.
Folgende Kontrollparameter sind für einen Wah-Wah-Effekt üblich:
Hier wird gewählt, ob die Steuerung mit LFO (Auto Wah) oder mit einem Expression-Pedal erfolgen soll.
Mit diesem Parameter kontrolliert man die negative Verstärkung des Filters, im Falle eines Kuhschwanzfilters. (Shelving Filter) Hiermit wählt man, ob man einen milden oder starken Effekt haben möchte.
Mit diesem Parameter wählt man die Frequenzschranken der Filterung. Üblicherweise sind diese zwischen 500Hz und 4000Hz. Je breiter der Effekt, desto größer das Intervall.
LFO steuert das Tiefpassfilter. Nach jeder Änderung werden die Parameter des Tiefpassfilters aktualisiert.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
float c_autowah::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; } void c_autowah::update_wah_frequency(void){ float sin_x; sin_x=lfo(); if(i_update>=n_update_reset){ //Update filter frequency frequency=freq_low+(sin_x+1)*freq_scaler; wahfilter.set_freq(frequency); i_update=0; }else{ i_update++; } } |
Der Wah-Wah-Hauptalgorithmus ist dann einfach ein LP-Filter. (In dem Fall als Biquad-Filter implementiert)
|
1 2 3 4 5 6 7 8 |
/* Wah wah main routine */ float c_autowah::process(float x){ update_wah_frequency(); return wahfilter.process(input_gain*x); } |
Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.
Ein Tremolo-Effekt ändert zyklisch die Lautstärke eines Signals. Es wird je nach Parametrierung zum Erzeugen von „Country“-Sounds oder aber auch in starker Ausführung für spezielle Effekte wie „Boulevard of broken dreams“-Intro von Green day.
Im folgenden ist das Grundprinzip des Tremolo-Effekts aufgezeigt.
Folgende Kontrollparameter für den Tremolo-Effekt sind üblich:
Mit der Frequenz kontrolliert man die Geschwindigkeit der Verstärkungsmodulation. Üblicherweise in Hertz. Typische Werte zwischen 1Hz und 25Hz.
Mit diesem Parameter kontrolliert man die Wirksamkeit der Modulation. Üblicherweise in [%] angegeben. Bei 30% wird die Lautstärke zwischen 70% und 100% gesteuert. Bei 100% wird die Lautstärke zwischen 0 und 100% gesteuert (Also dabei teilweise ganz stummgeschaltet.)
Damit wird der Typ des LFO-Signals gewählt. Übliche Signale sind:
Während sonstige Tonhöhenmodulationseffekte wie Chorus, Flanger, Rotary mit einem Sinus-Signal kontrolliert wird, sind für den Tremolo-Effekt auch andere Signalquellen üblich. Die effiziente Implementierung dieser Signalgeneratoren sind unten gezeigt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
/* LFO */ float c_tremolo::lfo(void){ float y_lfo; //Calculate LFO value switch(type){ //Sinus case 0: y_lfo=0.5*(1+sin(i_lfo)); //Update angle i_lfo+=a_step; if(i_lfo>=2*PI){ i_lfo-=2*PI; } break; //Triangle case 1: y_lfo = fabs(fmod(i_lfo, 2) -1 ); i_lfo+=t_step; break; case 2: //Square y_lfo=fmod(i_lfo,2) < 1 ? 1 : 0; i_lfo+=t_step; break; } // printf("%.3f\n",y_lfo); return y_lfo; } /* Calculate the gain */ float c_tremolo::get_current_attenuation(void){ return 1-depth*lfo(); } |
Der Algorithmus vom Rotary-Effekt ist vergleichbar mit einem Chorus-Algorithmus ohne Signalkopie und Trockensignal / Effektsignal-Mischung.
|
1 2 3 4 |
float c_tremolo::process(float x){ return x*get_current_attenuation(); } |
Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.
Ein Rotary-Effekt ist ein Modulationseffekt, der die Frequenz bzw. die Tonhöhe (Pitch) des Eingangssignals mit einem Niedrigfrequenzoszillator (LFO: engl. Low-frequency oscillator) ändert. Somit entsteht eine Rotary bzw. je nach Parametrierung ein Vibrato-artiger Effekt.
Er ist sehr ähnlich zum Chorus-Effekt mit dem Unterschied, dass hierbei das Signal nicht kopiert wird sondern das trockene Signal verarbeitet wird: Ohne Kopieren und zurückmischen. Daher resultiert hierbei kein Phasenauslöschungseffekt.
Im folgenden ist das Grundprinzip des Rotary-Effekts aufgezeigt.
Folgende Kontrollparameter sind für einen Flanger-Effekt üblich:
Mit der Frequenz kontrolliert man die Geschwindigkeit der Frequenzmodulation. Üblicherweise in Hertz [Hz]. Typische Werte zwischen 1Hz und 25Hz.
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.
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 Rotary-Effekts 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.
Für das Rotary-Puffer wird ein Kreispuffer benötigt, in dem Eingangssignal aufgenommen wird.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
/* LFO */ float c_rotary::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_rotary::get_current_delay(void){ //Calculate time float t; t=d_base+depth*lfo(); //Return the delay time return t; } |
Der Algorithmus vom Rotary-Effekt ist vergleichbar mit einem Chorus-Algorithmus ohne Signalkopie und Trockensignal / Effektsignal-Mischung.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
/* Rotary main routine */ float c_rotary::process(float x){ float y; float t_c; //Current delay //Get current delay t_c=get_current_delay(); //Delay time //Calculate the position of the pointer int wptr; wptr=rptr-rint(t_c*FSms); if(wptr<0){ wptr+=rotary_len; } //Calculate output y=rbuf[wptr]; //Update the buffer rbuf[rptr]=x; //Increment rptr++; if(rptr>=rotary_len){ rptr-=rotary_len; } return y; } |
Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.
Ein Flangereffekt ist ein Modulationseffekt, der das Eingangssignal kopiert und dessen Tonhöhe (Pitch) mit einem Niedrigfrequenzoszillator (LFO: engl. Low-frequency oscillator) ändert. Der Unterschied zum Chorus-Effekt besteht darin, dass auf der Effektlinie eine Rückkopplung gibt. Da die Verzögerung im Bereich von paar Millisekunden liegt, resultieren daraus Phasenlöschungseffekte. Das gibt dem Flanger seinen charakteristischen Space-Sound.
Eine andere Eigenheit vom Flanger ist, dass hierbei üblicherweise auch das trockene Signal verzögert werden muss, um eine starke Phasenauslöschung und einen drehend empfundenen Sound zu erzielen.
Im folgenden ist das Grundprinzip eines Flangers aufgezeigt.
Folgende Kontrollparameter sind für einen Flanger-Effekt üblich:
Mit der Frequenz kontrolliert man die Geschwindigkeit der Frequenzmodulation. Üblicherweise in Hertz [Hz]. Typische Werte zwischen 1Hz und 25Hz.
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.
Die Verzögerung des trockenen Signals. Dies kann parametriert werden, um die Stärke und Charakteristik des Phasenauslöschungseffektes einzustellen.
Hiermit wird kontrolliert, wie stark das modulierte Signal ins Ausgangssignal beigemischt werden soll.
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.
Für das Flanger-Puffer wird ein Kreispuffer benötigt, in dem Eingangssignal aufgenommen wird.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
/* LFO */ float c_flanger::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_flanger::get_current_delay(void){ //Calculate time float t; t=(float)d_base+depth*lfo(); //Return the delay time return t; } |
Der Algorithmus vom Chorus ist vergleichbar mit einem Delay-Algorithmus ohne Feedback und mit variabler Delay-Zeit.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
/* Flanger main process */ float c_flanger::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=fptr-lrint(t_c*FSms); if(wptr<0){ wptr+=flanger_len; } //Calculate output y=G_d*drybuf[dryptr] + G_w*fbuf[wptr]; //Update the buffer fbuf[fptr]=x+G_fb*fbuf[wptr]; drybuf[dryptr]=x; //Increment fptr++; if(fptr>=flanger_len){ fptr=0; } dryptr++; if(dryptr>=l_drybuf){ dryptr=0; } return y; } |
Ein Prozess ohne Verzögerung vom trockenen Signal sieht folgendermaßen aus:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
/* Main process without delay on dry line */ float c_flanger::process_nondelay(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=fptr-lrint(t_c*FSms); if(wptr<0){ wptr+=flanger_len; } //Calculate output y=G_d*x + G_w*fbuf[wptr]; //Update the buffer fbuf[fptr]=x+G_fb*fbuf[wptr]; //Increment fptr++; if(fptr>=flanger_len){ fptr=0; } return y; } |
Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.
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.
Folgende Kontrollparameter sind für einen Chorus-Effekt üblich:
Mit der Frequenz kontrolliert man die Geschwindigkeit der Frequenzmodulation. Üblicherweise in Hertz [Hz]. Typische Werte zwischen 1Hz und 25Hz.
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.
Hiermit wird kontrolliert, wie stark das modulierte Signal ins Ausgangssignal beigemischt werden soll.
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.
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.
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
/* 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; } |
Der Algorithmus vom Chorus ist vergleichbar mit einem Delay-Algorithmus ohne Feedback und mit variabler Delay-Zeit.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
/* 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; } |
Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.
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 
abgeschwächt und zum Eingangssignal der Verzögerungseingang ![a[n]](https://cankosar.com/wp-content/ql-cache/quicklatex.com-57b83f257d39cfa36167fd12071282c1_l3.png "Rendered by QuickLaTeX.com")
zurückgemischt.
Folgende Kontrollparameter sind für einen Flanger-Effekt üblich:
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.
Der Parameter, ob der angetippter Takt als z.B. als Viertel, Achtel oder Sechszehntel zu verstehen ist.
Mit diesem Parameter kontrolliert man die Dämpfung der Rückkopplung. Aus Stabilitsgründen muss sich diese im Intervall von
(1) 
befinden.
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).
Die Verzögerung des trockenen Signals.
Hiermit wird kontrolliert, wie stark das verzögerte Signal ins Ausgangssignal beigemischt werden soll.
Für das Delay wird ein großes Kreispuffer für $z^{-M}= benötigt, in dem Delay-Signal aufgenommen wird.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
/*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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
/* 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(); } |
Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.
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) 
beschrieben werden.
Nach der bilinearen Transformation erhält man
(2) 
wobei
(3) 
Somit erhält man alle Koeffizienten, die man für die Implementierung braucht. Die Implementierung der Koeffizientenberechnung würde folgendermaßen aussehen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
//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.
zu teilen, wird mit inversem (ein mal vorberechneten) Wert 
multipliziert, da Multiplikation günstiger ist als Division für viele CPUs.Rechte © 2024 Can Kosar
Mit Unterstützung von Wordpress, QuickLaTeX und Design von Anders Noren — Seitenanfang ↑
