CIC Additionsknoten

[Marcel D. (diablokiller999)]

Hi Leutz!
Ich habe einen CIC Filter in VHDL implementiert, der an sich auch ganz 
gut funktioniert. Nur habe ich mir die Frage gestellt, ob die 
Implementierung richtig ist oder ich einen Denkfehler im Ablauf der 
Addition habe.

In der angehängten Zeichnung sieht man die Additionsknoten und die 
Register / Verzögerer. Momentan habe ich es so implementiert, dass ich 
die Additionen in einem Takt gemeinsam abarbeite, womit mir das aktuelle 
Ergebnis des vorherigen Knotens also nicht für die Berechnung des 
nachfolgenden Knotens zur Verfügung steht.

Integrator : process(nReset, iClk)
begin
  if (nReset = '0') then
    nCICTemp        <= (others => '0');
    nCICExpand      <= (others => '0');
    nIntegration    <= (others => (others => '0'));
    nNewValue       <= '0';
    nCount          <= x"000000";
    nNewValue      <= '0';  
    nDecTrigger     <= '0';   
    stateInt        <= idle;
  elsif (iClk = '1' and iClk'event) then
    nNewValue <= iNewValue;       
    case stateInt is
      when idle =>
                nDecTrigger <= '0';
        if nNewValue /= iNewValue and iNewValue = '0' then --trigger on the falling edge of iNewValue                      
                    stateInt    <= get_value;  
                end if;
                
            when get_value =>
                if (nShift = 0) then
                    stateInt    <= idle;  
                else                    
                    if (INPUT_SIGNED = 1) then
                        nCICTemp <= signed(iCIC);
                    else
                        nCICTemp <= signed(iCIC + x"8000");
                    end if;
                    stateInt    <= fill;            
                end if;
            when fill =>
               stateInt <= int1;
               nCICExpand  <= (others => nCICTemp(nCICTemp'left));
               nCICExpand(BIT_WIDTH-1 downto 0) <= signed(nCICTemp);   
               nIntegration(0) <= nCICExpand + nIntegration(0);
               nIntegration(1) <= nIntegration(0) + nIntegration(1); 
               nIntegration(2) <= nIntegration(1) + nIntegration(2);
               nIntegration(3) <= nIntegration(2) + nIntegration(3);
               nCOUNT <= nCount + '1';
               if nCOUNT = nDecimationFactor - '1' then
                  nCOUNT <= x"000000";
                  nDecTrigger <= '1';
               end if;
           when others =>
               stateInt <= idle;
    end case;
  end if;
end process Integrator;

Comb : process(nReset, iClk)
begin
    if (rising_edge(iClk)) then
        if (nReset = '0') then
            nCombIn         <= (others => (others => '0'));
            nCombDelay      <= (others => (others => '0'));
            nCombOut        <= (others => '0');
            stateComb       <= idle;
            oNewValue       <= '0';
            oCIC            <= (others => '0');
        else
            case stateComb is
                when idle =>
                    if (nShift = 0) then
                        oCIC <= iCIC;
                        oNewValue <= iNewValue;
                    else 
                        oNewValue <= '0';
                        if(nDecTrigger = '1') then
                            stateComb <= calc1;
                        end if;
                    end if;
                when calc1 =>
                    nCombIn(0) <= nIntegration(3);
                    nCombIn(1) <= nCombIn(0) - nCombDelay(0);
                    nCombDelay(0) <= nCombIn(0);
                    nCombIn(2) <= nCombIn(1) - nCombDelay(1);
                    nCombDelay(1) <= nCombIn(1);
                    nCombIn(3) <= nCombIn(2) - nCombDelay(2);
                    nCombDelay(2) <= nCombIn(2);
                    stateComb <= output;
                    nCombOut <= nCombIn(3) - nCombDelay(3);
                    nCombDelay(3) <= nCombIn(3);
                when output =>
                    stateComb <= idle;
                    oNewValue <= '1';
                    if (INPUT_SIGNED = 1) then
                        oCIC <= std_logic_vector(nCombOut(BIT_WIDTH-1+nShift downto nShift));
                    else
                        oCIC <= std_logic_vector(nCombOut(BIT_WIDTH-1+nShift downto nShift))- x"8000";
                    end if;
                when others =>
                    stateComb <= idle;
            end case;
        end if;
    end if;
end process Comb;

Alternativ wäre es aber auch denkbar, die Berechnung der Additionsknoten 
in je einem Takt zu bearbeiten und somit das Ergebnis dem nachfolgenden 
Additionsknoten zur Verfügung zu stellen, dieser muss dann nicht aufs 
nächste Sample warten um den neuen Wert zu verrechnen:

Integrator : process(nReset, iClk)
begin
  if (nReset = '0') then
    nCICTemp        <= (others => '0');
    nCICExpand      <= (others => '0');
    nIntegration    <= (others => (others => '0'));
    nNewValue       <= '0';
    nCount          <= x"000000";
    nNewValue      <= '0';  
    nDecTrigger     <= '0';   
    stateInt        <= idle;
  elsif (iClk = '1' and iClk'event) then
    nNewValue <= iNewValue;       
    case stateInt is
      when idle =>
                nDecTrigger <= '0';
        if nNewValue /= iNewValue and iNewValue = '0' then --trigger on the falling edge of iNewValue                      
                    stateInt    <= get_value;  
                end if;
                
            when get_value =>
                if (nShift = 0) then
                    stateInt    <= idle;  
                else                    
                    if (INPUT_SIGNED = 1) then
                        nCICTemp <= signed(iCIC);
                    else
                        nCICTemp <= signed(iCIC + x"8000");
                    end if;
                    stateInt    <= fill;            
                end if;
            when fill =>
                stateInt <= int1;
                nCICExpand  <= (others => nCICTemp(nCICTemp'left));
        nCICExpand(BIT_WIDTH-1 downto 0) <= signed(nCICTemp);   
      when int1 =>
        stateInt <= int2;
        nIntegration(0) <= nCICExpand + nIntegration(0);        
      when int2 =>    
         stateInt <= int3;
         nIntegration(1) <= nIntegration(0) + nIntegration(1); 
      when int3 => 
         stateInt <= int4;  
         nIntegration(2) <= nIntegration(1) + nIntegration(2);
      when int4 =>
         stateInt <= idle;
         nIntegration(3) <= nIntegration(2) + nIntegration(3);
         nCOUNT <= nCount + '1';
         if nCOUNT = nDecimationFactor - '1' then
             nCOUNT <= x"000000";
             nDecTrigger <= '1';
         end if;
      when others =>
        stateInt <= idle;
    end case;
  end if;
end process Integrator;

Comb : process(nReset, iClk)
begin
    if (rising_edge(iClk)) then
        if (nReset = '0') then
            
            nCombIn         <= (others => (others => '0'));
            nCombDelay      <= (others => (others => '0'));
            nCombOut        <= (others => '0');
            stateComb       <= idle;
            oNewValue       <= '0';
            oCIC            <= (others => '0');
        else
            case stateComb is
                when idle =>
                    if (nShift = 0) then
                        oCIC <= iCIC;
                        oNewValue <= iNewValue;
                    else 
                        oNewValue <= '0';
                        if(nDecTrigger = '1') then
                            nCombIn(0) <= nIntegration(3);
                            stateComb <= calc1;
                        end if;
                    end if;
                when calc1 =>
                    stateComb <= calc2;
                    nCombIn(1) <= nCombIn(0) - nCombDelay(0);
                    nCombDelay(0) <= nCombIn(0);
                when calc2 =>
                    stateComb <= calc3;
                    nCombIn(2) <= nCombIn(1) - nCombDelay(1);
                    nCombDelay(1) <= nCombIn(1);
                when calc3 =>
                    stateComb <= calc4;
                    nCombIn(3) <= nCombIn(2) - nCombDelay(2);
                    nCombDelay(2) <= nCombIn(2);
                when calc4 =>
                    stateComb <= output;
                    nCombOut <= nCombIn(3) - nCombDelay(3);
                    nCombDelay(3) <= nCombIn(3);
                when output =>
                    stateComb <= idle;
                    oNewValue <= '1';
                    if (INPUT_SIGNED = 1) then
                        oCIC <= std_logic_vector(nCombOut(BIT_WIDTH-1+nShift downto nShift));
                    else
                        oCIC <= std_logic_vector(nCombOut(BIT_WIDTH-1+nShift downto nShift))- x"8000";
                    end if;
                when others =>
                    stateComb <= idle;
            end case;
        end if;
    end if;
end process Comb;

Nun ist jedoch die Frage, welche Herangehensweise richtig ist. Oder 
macht das keinen Unterschied?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Marcel D. schrieb:
> Nun ist jedoch die Frage, welche Herangehensweise richtig ist.
> Oder macht das keinen Unterschied?
Die zweite Lösung ist halt generell langsamer, weil ja jeder Schritt 
nacheinander gemacht wird.

Im Resourcenverbrauch wirst du durch die zusätzliche FSM im zweiten Fall 
auch ein wenig schlechter, denn du brauchst ja trotzdem alle einzelnen 
Addierer. Nur tun die eben die meiste Zeit nichts...

> Nun ist jedoch die Frage, welche Herangehensweise richtig ist.
Mach die Nummer 1. Und wenn die zu langsam ist, dann denk über Pipelinig 
nach. Das funktioniert aber nicht wie die Lösung 2, sondern eher wie die 
Lösung 1 mit zwischengeschalteten Puffern.

[Martin O. (ossi-2)]

Wenn man das CIC-Filter so implementiert, wie in Deinem Bild des ersten 
Posts gezeigt, liegen (was die Signalverzögerung angeht) alle Addierer 
in Reihe. Wenn Du die Addierer 32 Bit breit machst und M=3 stufig 
arbeitest sind das 32*6=192 Bits, und alle Additionen müssen in einem 
Takt des CIC Filters erledigt sein. Das kann schnell problematisch 
werden.

Wenn es nichts ausmacht, dass das Signal 2M=6 Takte verzögert am Ausgang 
rauskommt, kannst Du so arbeiten, wie von Dir vorgeschlagen, und die 
jeweils nächste Stufe bekommt das Resultat der vorherigen Stufe einen 
Takt später. Das entspricht dem Einbau von z^-1 Gliedern hinter jeder 
Stufe.

Dein Bild zeigt übrigens nicht die übliche Form eines CIC Filters.
Normal erfolgt das Downsampling um R zwischen den Integrate und den Comb 
Anteilen. Dann braucht man die Comb Filter auch nur seltener berechnen.

Ich blick durch Deine Implementation nicht wirklich durch, ich habe den 
Eindruck, dass Du mit Hilfe von State-Maschinen Schritte in der 
Reihenfolge festlegen willst.

Hier Meine Implementation mit N=2, D=1, R einstellbar.

module cicTwoStageV01
 #(parameter width=16) 
 (input                  cic_clk_i       ,
  input                  inp_strobe_i    , // Integrate Taktfreigabe
  input                  out_strobe_i    , // Comb Taktfreigabe
  input signed [width-1:0]      inp_data_i      ,  
  output signed [width-1:0]     out_data_o
  );


reg signed [width-1:0] CICint1 ;
reg signed [width-1:0] CICint2 ;
always @(posedge cic_clk_i) begin
  if ( inp_strobe_i ) begin  CICint1 <= CICint1 + inp_data_i ;  end 
  end

always @(posedge cic_clk_i) begin
  if (  inp_strobe_i ) begin  CICint2 <= CICint2 + CICint1 ;   end
  end

reg signed [width-1:0] CICstore1a ;
reg signed [width-1:0] CICstore1b ; 
reg signed [width-1:0] CICdiff1 ;  
reg signed [width-1:0] CICstore2a ;
reg signed [width-1:0] CICstore2b ; 
reg signed [width-1:0] CICdiff2 ;  

always @(posedge cic_clk_i) begin  
  if ( out_strobe_i ) begin
    CICdiff1 <= CICint2-CICstore1b ;
    CICstore1b <= CICstore1a ;
    CICstore1a <= CICint2 ;
    end
  end
  
always @(posedge cic_clk_i) begin  
  if ( out_strobe_i ) begin
    CICdiff2 <= CICdiff1-CICstore2b ;
    CICstore2b <= CICstore2a ;
    CICstore2a <= CICdiff1 ;
    end
  end

assign out_data_o = CICdiff2 ; 

endmodule

[Marcel D. (diablokiller999)]

Mir ging es eher um eine allgemeine Frage über die Berechnung und ob 
diese zeitgleich an allen Knoten oder hintereinander durchgeführt werden 
muss. In meiner Implementierung sind die nCombIn die Subtraktionsknoten, 
die nCombDelay die vorwärts gerichteten Verzögerungselemente. Ich nutze 
3 Prozesse um die Config, Integrator und Comb parallel ablaufen zu 
lassen. Das ganze Teil soll ein 4 Stage CIC zur Dezimierung sein, den 
kompletten Code packe ich mal als Anhang bei.

Die Grundüberlegung war die, dass die Ergebnisse der Berechnung bei 
einzelnen SM-Stages ja weitaus schneller passieren, als sie eigentlich 
angedacht sind. Beim FIR oder IIR werden ja ebenfalls alle 
Multiplikationen und Additionen parallel ausgeführt, deswegen auch meine 
beiden Implementierungen. Funktionieren tun sie beide, nur stellt sich 
mir die Frage was richtig(er) ist :3

[Marcel D. (diablokiller999)]

Ich gehe momentan davon aus, dass diese Implementierung (#2) die 
richtige ist. Bei einem Dezimationsfaktor von 4 bekomme ich nach 4 
Werten eine Änderung am Ausgang, in der anderen Variante erst nach 20.

[Weltbester FPGA-Pongo (Gast)]

Wozu brauchst Du hier eine State Machine?
Ein CIC hat seinen Vorteil einzig in der resourcenschonenden 
Implementierung. Addieren, Differenzieren. Alle Verrenkungen drum herum 
gehören da raus und blähen nur auf.

[Marcel D. (diablokiller999)]

Also alles in einzelne Prozesse auslagern wie Ossi es gemacht hat?

[Weltbester FPGA-Pongo (Gast)]

Marcel D. schrieb:
> Also alles in einzelne Prozesse auslagern wie Ossi es gemacht hat?

Ganz sicher nicht. Wozu? Ist Dir klar, was Prozesse sind und wie sie 
wirken? Das Verlagern von Code in unterschiedliche Prozesse hat 
ergebnistechnisch in der Regel gar keine Wirkung und wenn, dann keine 
gute.

Bläht nur den Code auf.

Wir sind aber an einer anderen Stelle, nämlich dem Aufblähen der 
Funktion!

Daher nochmals meine Frage: Wozu eine state machine und ein stückweises 
Berechnen mit den calc stages?

Der Code zeigt mir wieder mal, dass hier nicht parallel gedacht wird 
sondern eine Implementierung eines sequenziellen Ablaufs wie man ihn in 
C laufen lassen müsste, übersetzt wurde.

Softwareentwickler sollten sich von FPGAs fernhalten.

[Marcel D. (diablokiller999)]

Weltbester FPGA-Pongo schrieb im Beitrag #5325604:
> Daher nochmals meine Frage: Wozu eine state machine und ein stückweises
> Berechnen mit den calc stages?

Um sicherzustellen, dass die Berechnung des vorherigen Knotens 
abgeschlossen ist und ich das Ergebnis der nachfolgenden Einheit zur 
Verfügung stellen kann, das ganze in einer getakteten Umgebung weil ich 
asynchrones Verhalten vermeiden will? Ich habe 10 Takte für die 
Berechnung bis ein neuer Wert kommt und mit dem as fast as possible 
Ansatz bin ich beim fitten leider schon auf die Schnauze gefallen.

Weltbester FPGA-Pongo schrieb im Beitrag #5325604:
> Der Code zeigt mir wieder mal, dass hier nicht parallel gedacht wird
> sondern eine Implementierung eines sequenziellen Ablaufs wie man ihn in
> C laufen lassen müsste, übersetzt wurde.

Für mich sieht der Aufbau eines CICs ziemlich seriell aus, könntest es 
mir ja erklären.

Weltbester FPGA-Pongo schrieb im Beitrag #5325604:
> Softwareentwickler sollten sich von FPGAs fernhalten.
Danke für diese Offenbarung, werde sofort meinen Job kündigen und alle 
Leute in meiner Umgebung warnen, niemals mit FPGAs anzufangen wenn sie 
schon mal eine Programmiersprache abseits von VHDL oder Verilog 
nutzten...