Componente mit CLK und OHNE CLK

Es gibt verschiedene Style/Coding-Guidelines, die sequentielle von
kombinatorischer Logik trennen. Register/Memory ist sequentiell,
Verknüpfungen (ohne Rückkopplung) kombinatorisch (wie ja auch Bool.
Operationen,Addition, etc.). Soweit ist Deine Komponente also wohl
kombinatorischer Natur.

Ich gehe mal davon aus, dass Du eigentich streamen statt pipelinen
möchtest, sonst müsstest Du ja die Komponente in Teilschritte
zerlegen. Du hast also eine Aufgabe wie z.B. r[i] = F(a[i] ,b[i],..)
oder dergleichen. Also muss Deine sequentielle Logik z.B. zu jeder
Taktflanke die Indices der Parameter berechnen und Deine Komponente
mit den Signalen a[i],b[i],.. "versorgen" während die Komponente selbst
den r[i]-Wert berechnet:

1

signal index_reg : integer := 0;

2

signal index_next: integer := 0;

3

4

signal a: what_ever_array_type := {4711,4712,4713,..};

5

signal b: what_ever_array_type := {0815,0816,0817,..};

6

signal r: what_ever_array_type;

7

signal r_next: what_ever_type;

8

9

signal a_in : what_ever_type;

10

signal b_in : what_ever_type;

11

signal r_out: what_ever_type;

12

13

inst__dein_filter:deine_filter

14

  port map

15

  (

16

    a <= a_in,

17

    b <= b_in,

18

    r <= r_out

19

  );

20

21

process(CLK , nRESET)

22

begin

23

  if rising_edge(CLK) then

24

    count_reg <= count_next;

25

    r[count_reg] <= r_next;

26

  end if;

27

end process;

28

29

count_next  <= count_reg + 1 when count_reg /= STREAM_WIDTH-1 else 0;

30

finish_flag <= '0' when count_reg /= STREAM_WIDTH-1 else '1';

31

32

a_in   <= a[count_reg];

33

b_in   <= b[count_reg];

34

r_next <= r_out;

Zu jeder pos.Taktflanke werden also die Indices für die Parameter
berechnet, dann wird in der kombinatorischen Logik entsprechend
den neuen Parametern r_next berechnet, was sich bis zur nächsten
Taktflanke stabilisieren sollte (=>max Frequenz) und dort dann das
Ergebnis der Filterung im r-Array abgelegt wird.

Danke für deine Mühe doch zuerst mal ist nicht der Filter die Comp, 
sondern die Addierer und Multis des Filters. Ist auch eigentlich egal.
Nein ich möchte wirklich Pipelinen. Adder wird zerlegt und mit Registern 
versorgt. Habe herausgefunden, dass ich irgendwo ein verzögerungsglied 
zuviel bzw. zu wenig drin habe. man man eine sch...arbeit

trotzdem herzlichsten dank

Dann ist Deine Aufgabe aber mit der des Streamens vergleichbar.
Statt Register-Arrays werden dann die Register zwischen den
Pipelinestufen verwendet, die Logik muss dann nur die entsprechenden
Register "aktivieren",z.B. über Multiplexer. Mein Code sollte ja nur
die Idee verdeutlichen, trotzdem noch viel Spass (oder viel Mühe??)