Butterworth-Filter programmieren (DSP)

Hi,

BW2 benötigt unterschiedliche Koeffizienten in den beiden Filterstufen

;-) Detlef

Klar, man macht zwei Druchläufe 1. Ordnung hintereinander.

Nein, üblicherweise implementiert man Filter 2. Ordnung (Biquads).

Siehe hier, quasi das "Standardwerk" zur DSP-Programmierung:

http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt

Halo,

info's und Programmbeispiele findest du z.b. auf den Webseiten von TI.

Willst du das wirklich selbst programmieren ?? von den Herstellern gibts
fertige Routinen die in den eigenen Sourcecode eingebaut und verwendet werden können.

Grüße
Thomas

tede (Beitrag #4) schrieb:

Willst du das wirklich selbst programmieren ?? von den Herstellern gibts fertige Routinen die in den eigenen Sourcecode eingebaut und verwendet werden können.

Es soll immer noch Ketzer geben, die so etwas "lernen" und nicht "anwenden" möchten.

@Alligator:
1.) Filterdesign lernen Phase 1: Filter 1. Ordnung hintereinanderschalten ergibt keine schwingfähigen Filter, ein Butterworth ist damit nicht möglich
2.) Filterdesign lernen Phase 2: für Filter höherer Ordnung braucht es eine vernünftige Koeffizientenerzeugung; für altegediente Analogelektroniker bietet sich da die bilineare Transformation an
3.) Dein Ziel heißt Biquad-Filter. Die Struktur ist einfach und verständlich, wie man sie möglichst effektiv auf einem DSP umsetzt ist gelegentlich ziemlich kompliziert.

Jeder DSP ist anders und kennt andere Befehle, kann eine unterschiedliche Menge an Befehlen pro Takt, etc. Und weil Ingenieure von Natur aus faul sind, haben sowohl TI als auch Analog (und möglicherweise auch andere) spezielle "Audioprozessoren" im Programm, die sich mit einer grafischen Umgebung programmieren lassen. Trotzdem ist es nicht verkehrt, sich allgemein mit der grundsätzlichen Programmierung vertraut zu machen. Ich musste doch tatsächlich neulich ein eigenes Modul für das Texas-Modell schreiben (und stellte nachher fest, dass das komplett überflüssig war, 6h für die Katz - so ist das Leben).

Für ein funktionierendes Code-Beispiel auf ganz allgemeinen von-Neumann-Prozessoren schau mal in diesen Quellcode:
http://cvs.berlios.d...=1.1.1.1&view=markup

Filter 1. Ordnung hintereinanderschalten ergibt keine schwingfähigen Filter, ein Butterworth ist damit nicht möglich

Genau das ist es, selbiges Drama hatte ich schon mit Analogfilter-Schaltung erlebt.

Mit der Programmierung des Prozessor tue ich mich noch etwas schwer.
Der Prozessor, den ich verwende, ist der auf der Creative Audigy2, folgende Eckdaten sind bekannt:

48kHz Samplingrate
32 Bit Wortlänge

Die "Programmierungebung" sind die Kx-Teiber.

Wieviele Operationen pro Sampling möglich sind, weiß ich derzeit nicht, ich hoffe, ich stoße nicht plötzlich an eine Leistungsgrenze, es laufen diverse Kerbfilter und Delays parallel, bisher hat er alle Aufagen problemlos geschafft.

Wegen Lernen und Anwenden:

Beides werde ich hier kombinieren, läuft der Filter irgendwann, wird er auch eingesetzt.
Ich möchte die Trennung zw. Hochton und Mittelton eine Stufe steiler gestalten, damit das Rundstrahlverhalten noch besser wird.

Es wäre nicht schlimm, wenn ich es länger nicht schaffe, dann muss halt so weiter Hören, wie bisher.
HT und MT sind ja recht dicht zusammen (10cm) und haben gerade mal 2000 Hz Trennfrequenz.

Bisher ist ein Linkwitz-Riley 4.Ordnung als fertiger Baustein im DSP für die Trennung HT zu MT.
Der Versuch, den Linkwitz-Riley-Baustein auf 8. Ordnung aufzublasen gelang nur mäßig, es verhielt sich wie zwei Linkwitz-Riley kaskadiert.

Daher wollte ich mal etwas tiefer Einsteigen ins Programmieren solcher Filter, als Zwischenziel wollte ich erstmal allgemein einen richtigen Filter 2. Ordnung programmieren.
Bisher habe ich immer die fertigen Bausteine verwendet, die klickt man in Tat schnall zusammen und schon läufts.

Sag doch gleich dass es darum geht. Genau das hab ich vor einiger Zeit nämlich auch gemacht.

input in; output out; ;filter coefficients static b0_1=0.481211083877581, b1_1=-0.943019938328317, b2_1=0.463832264803109, a1_1=0.943019938328317, a2_1=-0.445043348680689; static b0_2=0.500190892419578, b1_2=-0.999423819761777, b2_2=0.499318557741597, a1_2=0.999423819761777, a2_2=-0.499509450161175; static b0_3=0.391705873203728, b1_3=-0.066878090382742, b2_3=-0.133308774349389, a1_3=0.066878090382742, a2_3=0.241602901145660; ;buffers static x1_1=0, x2_1=0; static x1_2=0, x2_2=0; static x1_3=0, x2_3=0; static y2=0; static scal=2; temp t; ; Code ;Filter #1 macs 0, 0, in, b0_1; accum = in * b0 macmv x2_1, x1_1, x2_1, b2_1; accum += x2 * b2 macmv x1_1, in, x1_1, b1_1; accum += x1 * b1 macmv 0, 0, x2_2, a2_1; accum += (y2 * a2) macs t, accum, x1_2, a1_1; t = accum + (y1 * a1) macints t, 0, t, scal; t *= scal ;Filter #2 macs 0, 0, t, b0_2; macmv x2_2, x1_2, x2_2, b2_2; macmv x1_2, t, x1_2, b1_2; macmv 0, 0, x2_3, a2_2; macs t, accum, x1_3, a1_2; macints t, 0, t, scal; ;Filter #3 macs 0, 0, t, b0_3; macmv x2_3, x1_3, x2_3, b2_3; macmv x1_3, t, x1_3, b1_3; macmv y2, out, y2, a2_3; macs t, accum, out, a1_3; macints out, 0, t, scal;

Hier mein Assembler-Code für 3 Mono-Biquads in Folge, implementiert nach dem EQ-Cookbook für den DSP der Audigy2ZS. Die Koeffizienten sind nach dem Cookbook berechnet und hardgecoded.
Der Code verwendet das theoretische Minimum an Ressourcen (pro Filterstufe 6 Operationen und 7 Register).
Möglich ist das, weil der DSP gleichzeitig eine Multiplikation, eine Addition und eine Verschiebung (mit dem Befehl macmv) durchführen kann.
Auf Stereo zu erweitern sollte keine große Herausforderung sein, der Code benötigt dann pro Filterstufe 12 Operationen und 9 Register.
Für mehr Filter einfach die 2. Stufe duplizieren und die Registerindizes anpassen.

Ich habe dazu auch ein Code-Generator-Tool in Basic geschrieben, das für eine beliebige Anzahl an Filterstufen die Koeffizienten berechnet und den Assemblercode generiert. Braucht man dann nur noch per Copy&Paste in Dane einfügen und kompilieren. Bei Interesse einfach melden.

Jetzt staune ich aber.

Ich hatte das Ganze erstmal ohne Hintergrund gelassen, weil ich dachte, dass macht eh keiner mehr, weil viele doch andere Lösungen (DCX2496).

Übrigens war ich gestern auch noch zu einem Biquad gekommen.
Nach dem ich mich weiter belesen habe, war mir klar, dass in dem Linkwitz 4.Ordnung-Baustein zwei dieser Biquads enthalten sein muss.

Theoretisch wäre ich nun Programmtechnisch gerüstet. wenn da nicht die Koeffizienten wären.
Bei dem Linkwitz 4.Ordnung-Baustein geschieht die Rechnung der Koeffizienten irgendwie "außenherum", der Schieber für Frequenz verändert alle passend zu einander mit.

Ansonsten müsste ich die Koeffizienten aus einer Analogschaltung mit dem Zielverhalten bilinear transformieren und passend skalieren.
Das Transformieren ist nun nicht ganz so einfach, so richtig sehe ich da weder Anfang noch Ende, auch das Skalieren ist mir noch unklar.
Offenbar scheinen die Werte zw. -1 und 1 zu liegen, sieht man ja auch an dem Programm von orangenhaut.

Interesse an einem Koeffizienten-Recher hätte ich definitiv, sonst müsste ich sie durch schrittweises Annähern ermitteln.

An dieser Stelle möchte ich mich schon mal für die Hilfe bedanken.

Weiter oben habe ich doch bereits das EQ-Cookbook verlinkt. Da steht alles drin was du brauchst, genauso wie beschrieben: Ausgehend von der s-Übertragungsfunktion der Analog-Filter gehts über BLT in die z-Ebene, es wird beschrieben wie man Frequency Warping kompensiert und die Bandwitdth anpasst.

Schlussendlich gibts dann da für die Koeffizientenberechnung eine Handvoll Formeln für jeden Biquad-Typ. Einsetzen, fertig.

Nur um das nochmal klarzustellen: Die Berechnung der Koeffizienten findet NICHT im DSP statt. Der DSP bekommt die einfach so "vorgesetzt". Die Berechnung findet im Voraus durch ein externes Programm oder ein KX-Plugin in der CPU statt.

Dabei auf ausreichende Genauigkeit achten - werden die Koeffizienten zu ungenau berechnet, weisen die Filter erhöhtes Rauschen auf oder fangen im dümmsten Fall an, instabil zu werden.

Die Koeffizienten liegen nicht wirklich immer zwischen -1 und 1, die können durchaus auch größer werden. Da der Audigy-DSP mit Festkomma arbeitet, muss man die Koeffizienten passend skalieren (Faktor "scal" im obigen Beispiel). Ferner sind die Koeffizienten bei mir nach a0 normiert (Direct Form 1). Ferner wurden a1 und a2 mit -1 multipliziert, damit der DSP eine einfache Additon durchführen kann. Aber das alles findet wie gesagt NICHT im DSP statt, sondern bei der Koeffizientenberechnung.

Nachtrag: Den Post EQ-Cookbook habe gerade erst gesehen...

Die Koeffizienten liegen nicht wirklich immer zwischen -1 und 1

Die nicht, aber der Zahlenbereich des Prozessors schon, oder sehe ich da was falsch?
-1 entspricht Hex 0x80000000, 1 entspricht Hex 0x7fffffff, so meine bisherige Erkenntnis.

Ok, dann hatte ich dich missverstanden:
Ja, der EMU10K2 (endlich nochmal den Namen des DSP nachgeschaut) rechnet mit Festkomma, d.h. alle Kommazahlen müssen zwischen -1 und 1 sein. Da die Koeffizienten aber größer werden können, ist die Skalierung notwendig.

Nach einigen Versuchen filtert es immer noch wie es will.

Ich vermute mal, dass beim Skalieren der Koeffizienten etwas schief läuft.
Beim Skalieren wird der größte Koeffizienten-Betrag als Teiler für alle anderen hergenommen, somit ist der größte Wert -1 oder +1, die anderen Werte werden entsprechend herunter skaliert.

Das Widerspricht sich aber etwas mit der Normierung nach a0, dieser müsste ja mit skaliert werden.

Nehme ich a0 als Skalier-Teiler, passen die anderen Werte nicht in den Prozessor, wenn sie größer a0 sind. (Siehe Excel-Maske mit a1)

Hier mal meine Excel-Maske, die einen Tiefpass 2. Ordnung mit f0 = 1 kHz errechnen sollte(!)




Der damit erzeugte Biquad antwortet so:



Diese Bild zeigt sich bei diversen f0-Werten, lediglich der Pegel ändert sich.


Der Filter von orangenhaut zeigt dieses Verhalten:



Nachdem ich die Koeffzienten genauer angeguckt habe, finde ich diese Antwort passend.
Es liegen offensichtlich drei verschiedene Peak-EQ-Filter vor, man erkennt es daran, dass b1 und a1 die gleichen Beträge haben.

Ich habe dazu auch ein Code-Generator-Tool in Basic geschrieben, das für eine beliebige Anzahl an Filterstufen die Koeffizienten berechnet und den Assemblercode generiert. Braucht man dann nur noch per Copy&Paste in Dane einfügen und kompilieren. Bei Interesse einfach melden.

Das Angebot würde ich gerne nutzen, mit den richtigen Werten könnte ich meinen Rechen-Vorgang korregieren.

Hmm, es tut mir leid, ich musste feststellen, dass ich das Code-Generator-Tool nicht auf meinem Notebook habe, sondern nur auf meinem PC. Da der ein paar Hundert km entfernt steht, komme ich da erst wieder in 2 Wochen dran. Wenn du dann immer noch interessiert bist, kann ich ihn dir dann gerne schicken.

Bis dahin kann ich dir aber denke ich auch so weiterhelfen.
Könntest du dazu die Formeln, die du in Excel eingegeben hast, sichtbar machen?

Einen Fehler sehe ich schonmal: Die Skalierung.
Wie du richtig erkannt hast, gibt es zwei Arten der Skalierung. Zum Ersten die Normalisierung nach a0, also einfach alle anderen Koeffizienten durch a0 teilen. Hier muss nichts kompensiert werden, da das beim Übergang in den Zeitbereich über die DF1 berücksichtigt wird.

Zum Anderen dann die Skalierung, die sich durch den beschränkten Wertebereich des DSP ergibt. Wie du richtig erkannt hast, müssen alle Koeffizienten betragsmäßig <1 sein.
Diese Skalierung muss allerdings im DSP kompensiert werden, da du sonst insgesamt am Schluss einen negativen Gain hast.
Der DSP kann aber Zahlen >1 nur als Integer darstellen, also als ganze Zahlen. Das heißt aber, dass dein Skalierungsfaktor eben eine ganze Zahl sein muss, in den meisten Werten passt 2, nur bei extremen Filtern werden die Koeffizienten noch größer.
Also: Bei der Berechnung alle Koeffizienten durch 2 teilen, im DSP dann am Schluss der Filterstufe das Endergebnis wieder per macints mit 2 multiplizieren.

Aber dieser Fehler würde nur zu einem gewissen Gain führen, also muss noch irgendwas anderes nicht stimmen. Hast du meinen Code verwendet? Gerne führen kleine Tippfehler zu so einem Verhalten.
Oder ein Vorzeichenfehler... Oder was anderes. Dazu müsste ich dann wie gesagt am besten deine Excelformeln sehen ;).

Edit: Darauf achten, dass du mit mind. 11 gültigen Ziffern rechnest! Alles Andere führt zu verringertem SNR bzw. instabilen Filtern.

Hmm, es tut mir leid, ich musste feststellen, dass ich das Code-Generator-Tool nicht auf meinem Notebook habe, sondern nur auf meinem PC. Da der ein paar Hundert km entfernt steht, komme ich da erst wieder in 2 Wochen dran. Wenn du dann immer noch interessiert bist, kann ich ihn dir dann gerne schicken.

Ich würde es am Liebsten auch ohne den Joker lösen können.



Hier mal meine Formeln:



Für Alpha habe ich den Fall Q genommen, die Beschreibeung vestehe ich nicht so ganz.
Auch Q habe ich noch nicht durchblickt.

Die drei b-Werte kommen mir irgendwie auch zu klein vor.

Ich hatte in Excel immerhin 15 Nachkommastellen eingegeben, solche Werte standen bei dir im Beispiel auch drin.


Zum Skalieren:

Das bedeutet, die Werte werden mit a0 dividiert, die Werte a1 und a2 mit -1 multipliziert und anschließend alles noch mal mit 2 dividiert.

Hast du meinen Code verwendet

Ja, ich habe den Code auf einen Biquad heruntergbrochen.

Ok, das sieht soweit alles ganz gut aus.

Ich hatte in Excel immerhin 15 Nachkommastellen eingegeben

Aber deine Zwischenwerte (w0, cos(w0) etc) scheinen weniger Nachkommastellen zu haben (oder werden die nur nicht angezeigt?). Ich bin nicht der Excelspezialist, kann mich nur erinnern das damals mit OpenOffice versucht zu haben. Und das hat intern glaube ich zu ungenau gerechnet, bzw. wusste ich nicht wie ich das einstellen kann.

Aber gut, das sollte jetzt nicht das größte Problem sein, das Filter sollte trotzdem funktionieren.

Nur um das nochmal abzuklären: Du würdest im DSP-Code bei deinem Beispiel folgende Koeffizienten angeben (gerundet, wollte nicht alles abtippen, nur zur Verdeutlichung):

b0 = 0,0020075
b1 = 0,0040150
b2 = 0,0020075
a1 = 0,9305819
a2 = -0,4386118
scal = 2

Ich hab die selbst nicht probiert, daher unter Vorbehalt, aber ich würde meinen, dass diese Koeffizienten funktionieren sollten.

Wenn nicht, dann poste doch mal deinen reduzierten Code. Nicht dass ich dir das Reduzieren auf 1 Biquad nicht zutrauen würde, aber gerade bei solchen Assemblergeschichten vertut man sich sehr gerne (diese Erfahrung hab ich damals auch schmerzlich gemacht), und einem 2. Augenpaar fällt vielleicht eher der Fehler auf.

Mein Biquad:

input in; output out; static b0_1=0.002138784656547, b1_1=0.004277569313095, b2_1=0.002138784656547; static a1_1=0.991444861373810, a2_1=-0.467298435384928, x1_1=0x0; static x2_1=0x0, x1_2=0x0, x2_2=0x0; static x1_3=0x0, x2_3=0x0, y2=0x0; static scal=0x2; temp t ; Code macs 0x0, 0x0, in, b0_1; macmv x2_1, x1_1, x2_1, b2_1; macmv x1_1, in, x1_1, b1_1; macmv 0x0, 0x0, x2_2, a2_1; macs t, accum, x1_2, a1_1; macints out, 0x0, t, scal; end

Und dieser Filter antwortet so:

Nur um das nochmal abzuklären: Du würdest im DSP-Code bei deinem Beispiel folgende Koeffizienten angeben (gerundet, wollte nicht alles abtippen, nur zur Verdeutlichung): b0 = 0,0020075 b1 = 0,0040150 b2 = 0,0020075 a1 = 0,9305819 a2 = -0,4386118 scal = 2

Sind diese Werte durch 2 geteilt oder durch a1? Beides liegt in diesen Fall nahe zusammen.

Nachtrag: Durch a1 kanns nicht sein, dann wäre es ja 1.
Durch 2 sind meine Werte aus dem Code oben jedenfalls.

Die Werte sind zunächst nach a0 normalisiert (=durch a0 geteilt). Dieser Schritt ist NICHT optional, wäre es auch nicht auf einem Fließkomma-DSP. Der direkte Übergang auf die Differenzengleichung (EQ 4 im Cookbook) ist nur in der DF1 der z-Ü-Fkt möglich, daher MÜSSEN alle Koeffizienten normalisiert werden.
Der Koeffizient a0 ist ja so bei dir noch überhaupt nicht berücksichtigt.

Korrekterweise müssten die Koeffizienten im DSP-Code eigentlich nicht a1, a2 ... benannt sein, sondern a1/a0, a2/a0 ... Der Einfachheit halber habe ich mir das damals gespart.

Anschließend findet die Skalierung mit 2 statt.

Ansonsten scheint mir vom kurzen Hinschauen her alles zu stimmen, du müsstest also nur noch alle deine Koeffizienten durch a0 teilen, dann sollte was Ähnliches rauskommen wie in meinem letzten Beitrag.

Anders gesagt, der Wert a0 ist immer glatt 0,5.
Jetzt wirds mir klar, warum das alles so skaliert sein muss.

Hm, es filtert immer noch so wie oben zu sehen.

Könnte der Q Faktor in meiner Berechnung falsch sein?

Mit Alpha bin ich mir auch noch nicht so sicher.

Anders gesagt, der Wert a0 ist immer glatt 0,5.

Nein, ich glaube ich hab dich jetzt vollkommen verwirrt ;).

Die Koeffizientenberechnung mal Schritt für Schritt von vorne:

1.
a0, a1, a2, b0, b1, b2 nach dem Cookbook berechnen

2.
a1, a2, b0, b1, b2 durch a0 teilen

3.
a1, a2, b0, b1, b2 durch 2 teilen

4.
a1, a2 mit -1 multiplizieren

Dann sollten die Koeffizienten für dein Beispiel genau die von mir oben sein, nur mit mehr Kommastellen:

b0 = 0,0020075 b1 = 0,0040150 b2 = 0,0020075 a1 = 0,9305819 a2 = -0,4386118

Ist das denn der Fall?

Und diese Werte sollten dann mit meinem Code funktionieren.

Den Q-Faktor hast du schon richtig aufgefasst und verwendet. Abgesehen davon sollte das Filter für weitgehend beliebige Qs stabil sein.

Was du aber misst schaut mir stark nach sinc-Funktion aus, die entweder durch einen Programmierfehler oder instabile Koeffizienten zustandekommt.

Ist das denn der Fall?

Meine Werte stimmen exakt überein, nur halt mehr Nachkommastellen.
Da ich a0 immer mit berechne kommt stets 0,5 raus, ich gebe es aber nicht in den Prozessor ein, das ist klar.

Was du aber misst schaut mir stark nach sinc-Funktion aus, die entweder durch einen Programmierfehler oder instabile Koeffizienten zustandekommt.

Programmierfehler könnte man ja ermitteln.
Ich hatte ja oben deinen Filter einzeln durchlaufen lassen und gemessen, ich hoffe, man erkennt deine Funktion wieder.

Habe den Fehler gefunden, das hatte ich beim groben drüberschaun glatt überlesen.

Was du übersehen hattest: Bei kaskadierten Filtern entsprechen ja die Ausgangswerte (yn) den Eingangswerten der folgenden Filterstufe (xn). Daher werden die in meinem Code nicht extra gepuffert.
Lediglich in der letzten Filterstufe muss y2 gepuffert werden, weil es ja keinen darauffolgenden Filter gibt. (y1 entspricht out und muss daher nicht extra gepuffert werden). Das hattest du vergessen zu ergänzen.

So sollte es funktionieren (identisch zu deinem Code, nur die y-Pufferung eingebaut und die Veriablen etwas übersichtlicher benannt):

input in; output out; static b0=..., b1=..., b2=...; static a1=..., a2=-...; static x1=0, x2=0; static y2=0; static scal=2; temp t; ; Code macs 0, 0, in, b0; macmv x2, x1, x2, b2; macmv x1, in, x1, b1; macmv y2, out, y2, a2; macs t, accum, out, a1; macints out, 0, t, scal;

Es funktioniert mit den neuen Code.

Ich werde erstmal experimentieren, der Filter hat ein leichtes überschwingen, vermutlich muss ich Q etwas senken.
Ansonsten fällt die Amplitude erwartungsgemäß mit 12db/okt.

Nochmals danke für Mühen, ich hätte selber wohl Wochen gebraucht, bis da mal den ersten Filter mit einer definierten Grenzfrequenz hinbekomen hätte.

Was mich noch unglaublich nervt ist, dass der Editor mir ständig sämtliche Kommentare entfernt und den Code ohne Zwischenräume und Einrücken hinhaut.

Übersicht? Suchen Sie besser woanders.

Ich werde mir auch mal einen Code-Generator machen.
Evtl. kann man die Koeffizienten in Control-Register speichern und im Automations-Menü auf MIDI-Kanäle legen.

Naja, Assembler-Code ist ja nicht unbedingt dazu da, übersichtlich zu sein ;).

Die Sache über MIDI klingt interessant, hab in die Richtung noch nie probierrt. Wenn was dabei rauskommt würde mich das interessieren.

Ansonsten wünsche ich noch recht viel Vergnügen mit dem DSP. Mich wundert immer, warum so wenige Leute KX verwenden, angesichts der Möglichkeiten!

So, ich habe mal etwas getüftelt.

Ich habe nun einen Filter 8. Ordnung, nur komme nicht ganz auf einen "richtigen" Linkwitz, der -6db an der Grenzfrequenz hat.
Meiner dümpelt eher bei -9 db herum und Schwingt dabei immer noch etwas über um ca. +0,3db.
Vielleicht werden nun langsam irgenwelche Rundungen seitens Excel sichtbar.


Ansonsten suche ich nach einer Möglichkeit, aus dem Tiefpass den passenden Hochpass abzuleiten, in den fertigen Bausteinen wirds auch irgendwie so gemacht.

out_high = in - out-low hatte ich schon versucht, ganz so einfach scheint es nicht zu sein.

Mich wundert immer, warum so wenige Leute KX verwenden, angesichts der Möglichkeiten!

Ich finde, die Karten sind ab Werk nicht so wirklich gut.

Ich habe meine aufbohren müssen, damit sie sich reibungslos einfügt:

- Symetrische Ausgangstreiber (keine Brummschleifen mehr)
- Optischer Digitaleingang (keine Ausetzer bei der Übertragung im Vergleich zum Kupferkabel)
- Einsatz in einem Mini-PC mit WinXp auf CF-Karte (keine Geräusche, vorallem wenn im Haupt-PC irgenwelche Grafikkarten daneben sitzen, wo gerne mal 100A gepulst werden)

LR-24-Trennung (Linkwitz-Riley) ist relativ einfach zu bewerkstelligen.
Einfach 2x BW-12 (Butterworth) in Serie. Also konkret für eine LR-24-Trennung bei 1kHz:

HP:
f0=1000 hz
Q=0,5
TP:
f0=1000 hz
Q = 0,5
Jeweils 2 davon in Serie.

LR-48 wird schon schwieriger, man müsste jeweils 2 BW-24 in Serie schalten. Q und f0 sind dann etwas "krummere" Werte, könnte man sich ausrechnen oder in der Literatur nachschlagen. Hab das aber nie gemacht, weil ich nie die Notwendigkeit gesehen habe, steiler als LR-24 zu trennen. Obendrein holt man sich damit Gruppenlaufzeiten dazu.

Hi,

orangenhaut (Beitrag #28) schrieb:

LR-24-Trennung (Linkwitz-Riley) ist relativ einfach zu bewerkstelligen. Einfach 2x BW-12 (Butterworth) in Serie. :...

Jau.
Aber:

...Also konkret für eine LR-24-Trennung bei 1kHz HP: f0=1000 hz Q=0,5 TP: f0=1000 hz Q = 0,5 Jeweils 2 davon in Serie...

Für Butterworth 2nd order ist das Q = 0.71 (nicht 0.5),
d.h. jedes Einzelfilter -3 dB bei Fo, in der Summe dann wie gewünscht -6 dB.

Gruss,
Michael

Nun aber :




Das gefällt mir schon mal richtig gut, rauscht nicht mehr als der fertige Linkwitz-4-Baustein, trifft die -6db genau bei f0 und schwingt Null über.

Ich habe mir jetzt auch einen Filter-Klopfer geschrieben, der berechnet momentan aus Q und f0 zwei Butterworth 4. Ordnung und kaskadiert sie.
Es kommt am Ende schon eine fertige .da-Datei raus, die man nur registrieren und im Prozessor verschalten muss.


Wer sich schonmal die .kx-Dateien (Inhalt des DSP) mit dem Text-Editor angeguckt hat, sieht auch hier noch Automatisierungs-Potential.
Die GUI des DSP ist nicht gerade flüssig zu bedienen, weil bei mir die Audigy mit kleinem Industrie-Mainboard mit sehr schwacher CPU (AMD LX800) läuft.
Durch den Remote-Desktop, über welchen ich den KX-Treiber-PC bediene, ruckelt die Grafik schon ziemlich.

Für Butterworth 2nd order ist das Q = 0.71 (nicht 0.5),

Sorry, du hast natürlich recht. Das hab ich durcheinandergebracht.