FIR-Filter mit Eingangsrate > Ausgangsrate

[Jan (Gast)]

Moin zusammen!

Ich versuche gerade folgendes FIR-Filter zu implementieren:
  H(z)=0.25 * [(1-z^-4) / (1-z^-1)]
Der Ausgang sollte also so aussehen:
  y(n)=0.25*x(n) + y(n-1) - 0.25*x(n-4)
Für den 1.Term shifte ich das Eingangssignal um 2 Bits nach rechts.
Der 2.Term gebe ich das Ausgangssignal y(n) auf ein Register und
für den 3. Term shifte ich um 2 Bits nach rechts und gebe das Signal auf 
ein Shift-Register mit 4 Stufen.

Soweit kein Problem.
Jedoch soll das Filter eine Verhältnis von Eingangs- zu Ausgangsfrequenz 
von 4 haben und der Ausgang ein Bit breiter sein.
  Z.B. Eingang: 16Bit@32MHz, Ausgang: 17Bit@8MHz
Meine Idee war nun, dass ich in diesem Fall das Schieberegister mit 4 
Stufen auf ein Register mit Enable-Signal reduzieren kann und ein 
gleiches Register für den Ausgang benutze.

Meine Frage ist erstmal, ob ich bis hierhin schon einen Denkfehler 
gemacht habe, oder sich das alles so richtig anhört :)

[J. S. (engineer)]

Wozu brauchst du das Schieberegister? Du verdrahtest in VHDL direkt um.

Oder ist das Wortregister = Wertespeicher gemeint?

Bei einer DDC, die Du faktisch durchführst, ignorierst Du einfach 3 von 
4 Worten. Dazu schiebst Du die Werte nacheinander durch eine pipeline 
und greifst die Taps direkt ab.

Der Filter schaut mir aber etwas komisch aus für diese Anwendung. Wenn 
das ein Dezimationsfilter werden soll, siehe mal nach CIC.

[Jan (Gast)]

Hi,

mit Schieberegister meinte ich dann Wortregister. Ich muss den 
Eingangswert viermal verzögern, wegen x(n-4).

Jürgen S. schrieb:
> Bei einer DDC, die Du faktisch durchführst, ignorierst Du einfach 3 von
> 4 Worten. Dazu schiebst Du die Werte nacheinander durch eine pipeline
> und greifst die Taps direkt ab.
Ich dachte, dass ich so ggf. Register einsparen kann, in dem ich am 
Register nur zu jedem vierten Takt den Eingangswert übernehme.

Der Filter soll erstmal nur zum Ausprobieren sein, weil ich noch keine 
Filter in VHDL implementiert habe.

Ist meine Ausführung denn in der Theorie soweit richtig?

[J. S. (engineer)]

Wenn das DDC gelingen soll, musst Du vorher Filtern. Du musst also eine 
entsprechende Zahl von Registern füttern und auswerten. Um die kommst Du 
nicht herum. Du bekommst dann für jeden neuen Wert einen neuen 
gefilterten Wert aus der pipeline, von denen Du jeden 4. nutzt. Wenn Du 
schon am Eingang vor der Filterung verwirfst, hast Du Aliaseffekte.

[Jan (Gast)]

Ich habe das ganze mal in vhdl geschrieben, dabei werden alle Werte 
verarbeitet, aber am Ausgangsregister nur jede 4. Wert gespeichert.
Habe ich das so richtig verstanden?

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity filter2 is
    port(
        CLK : in  std_logic;                    --Clock
        X   : in  std_logic_vector(8 downto 0); --9Bit input
        Y   : out std_logic_vector(14 downto 0) --15bit output
    );
end filter2;

architecture Behavioral of filter2 is
    signal y_0 : std_logic_vector(14 downto 0);
    signal y_1 : std_logic_vector(14 downto 0);
    signal x_1 : std_logic_vector(8 downto 0);
    signal x_2 : std_logic_vector(8 downto 0);
    signal x_3 : std_logic_vector(8 downto 0);
    signal x_4 : std_logic_vector(8 downto 0);
    signal xsum  : std_logic_vector(8 downto 0);
    signal xsumq : std_logic_vector(14 downto 0);
    signal cnt : std_logic_vector(1 downto 0);

begin
    --Sum of x(n), x(n-4) ;  8bit addition
    xsum <= std_logic_vector(signed(X)-signed(x_4));
    
    --Quarter of xsum & 8bit -> 15bit
    --       positiv                                             negative
    xsumq <= "00000000" & xsum(8 downto 2) when xsum(8)='0' else "11111111" & xsum(8 downto 2);
    
    --Registers
    Registers : process(CLK, X, y_0)
    begin
        if rising_edge(CLK) then
            y_1 <= y_0;
            
            x_1 <= X;
            x_2 <= x_1;
            x_3 <= x_2;
            x_4 <= x_3;
            
            --Output register ;   15bit addition
            if cnt="11" then
                y_0 <= std_logic_vector(signed(xsumq)+signed(y_1));
            else
                y_0 <= y_0;
            end if;--cnt
        end if;--CLK
    end process Registers;
    
    --Counter
    Counter : process(CLK)
    begin
        if rising_edge(CLK) then
            cnt <= std_logic_vector(unsigned(cnt)+1);
        end if;--CLK
    end process Counter;
    
    --Y output
    Y <= y_0;
    
end Behavioral;

[Johannes E. (cpt_nemo)]

Jan schrieb:
> Ich versuche gerade folgendes FIR-Filter zu implementieren:
>   H(z)=0.25 * [(1-z^-4) / (1-z^-1)]

Das sieht für mich eher nach einem IIR-Filter aus...

> if cnt="11" then
>     y_0 <= std_logic_vector(signed(xsumq)+signed(y_1));
> else
>     y_0 <= y_0;
> end if;--cnt

Das ist so nicht richtig. Du berechnest Y_0 nur in jedem 4. Takt und das 
wird dann in y_1 kopiert. Damit ist die Übertragungsfunktion nicht so 
wie gewünscht.
Definiere besser y_0 als Variable, die ständig berechnet wird, danach 
kommt die Zuweisung y_1 = y_0.

Für die Abtastung mit langsamerer Frequenz definierst du dann noch ein 
Ausgangsregister, z.B. y_out = y_0, das mit cnt="11" enabled wird. 
Wichtig ist, dass das langsame Register nur für den Ausgang verwendet 
wird und nicht für die Berechnung innerhalb des Filters.

[Jan (Gast)]

Super, danke euch beiden für die Hilfe!

[Mirco (Gast)]

Johannes E. schrieb:
> Das sieht für mich eher nach einem IIR-Filter aus...
Für mich auch und zwar nach einem unnötig kompliziert formulitertem..