Array einsynchronisieren

[Chris (Gast)]

Hallo,

ich habe 4 parallele Eingänge die ich in 2 Stufen einsynchronisieren 
will.
Ich baue mir also ein Array mit einer Breite von 4 Elementen und mache 
es 2 Bit tief.

1. steigende Flanke

2.Stufe   1.Stufe
0     <-     0
0     <-     1
0     <-     1
0     <-     0


2. steigende Flanke

2.Stufe   1.Stufe
0     <-     0
1     <-     1
1     <-     1
0     <-     0

type ELEMENT is array (0 to 1) of std_ulogic_vector(3 downto 0);
type TYP_CS is array (0 to 1) of ELEMENT;
signal S_CS  : TYP_CS;

Im ersten Schritt will ich das Array mit 0en initialisieren.
Im zweiten Schritt weise ich den Eingangsvektor zu
und im dritten Schritt will ich den Inhalt des 2D-Arrays an die zweite 
Stelle schieben.

Anbei mein Prozess:

SYNC : process (CLK)
  begin
    if rising_edge(CLK) then
      if RESET = '1' then
   
        S_CS        <= (others =>(others => '0'));
        ENABLE      <= '0';

      else

        S_CS (0)     <= I_CS; -- 1. Stufe
        ENABLE       <= '1';

        if ENABLE = '1' then
          S_CS (1)            <= S_CS (0); -- 2. Stufe
          ENABLE                <= '1';
        end if;  
      end if;    
    end if;      

  end process SYNC;

So recht will das ganze nicht klappen, villeicht kann mir jemand 
weiterhelfen.
Danke.

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

Chris schrieb:
> 4 parallele Eingänge ... in 2 Stufen einsynchronisieren
Sind die Eingänge voneinander abhängig?
Gehören die Bits zu einem 4-Bit-Wert?
Falls ja: so geht das nicht.

In welcher Beziehung steht ENABLE zu diesen Daten?
Hast du mal ein Timig-Diagramm?
Welche Datenrate hast du?
Welche Taktfrequenz hast du?

> So recht will das ganze nicht klappen
Was klappt da nicht?
Was erwartest du?
Was bekommst du?

[Chris (Gast)]

Hallo,

danke für deine Antwort.
Die Eingänge sind voneinander unabhängig, d.h. die einzelnen 
Vektorsignale
kommen zu unterschiedlichen Zeiten.
4 Bits also vier Eingänge.
Die Typdeklaration hätte ich folgendermaßen geschrieben:

type ELEMENT is array (0 to 3) of std_ulogic_vector(1 downto 0);
signal S_CS  : TYP_CS;

Das wäre dann ja folgende Matrix, oder?
00
00
00
00

Den Enable verwende ich um die Daten in der zweiten Stufe zu 
synchronisieren.
Die Taktfrequenz liegt bei ca. 5 MHz, also relativ moderat.
Timmingdiagramm habe ich leider nicht.

Ich will eigentlich nur die vier parallenen Eingänge zur steigenden 
Flanke und aktiven Enable Signal in die zweite Spalte der Matrix 
schieben.
 2.Stufe   1.Stufe
0     <-     0
0     <-     1
0     <-     1
0     <-     0

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

Chris schrieb:
> und aktiven Enable Signal
Das ist eigentlich immer aktiv, nur bei der ersten Taktflanke nicht. Und 
ab der 2. Flanke würdest du sowieso die Daten da rüberschieben...

> type ELEMENT is array (0 to 3) of std_ulogic_vector(1 downto 0);
> signal S_CS  : TYP_CS;
Was passt da nicht?

> Das wäre dann ja folgende Matrix, oder?
Ja.
Aber du willst eher so eine:
0000
0000
Um damit das zu machen:
1. Stufe 0110
           |
           v
2. Stufe 0000


Nochmal:
>> So recht will das ganze nicht klappen
> Was klappt da nicht?
> Was erwartest du?
> Was bekommst du?

[Chris (Gast)]

Hallo,

ich will die Daten von der zweiten Stufe abgreifen und mit diesen
synchronisierten Daten weiterarbeiten.

Ok, die Deklaration klappt und passt soweit nur wie greife ich auf
die einzelnen Array Elemente in Stufe zwei zu?
z.b. ich würde Element 0 in der zweiten Sufe, also zweiten Zeile 
erwarten.

1. Stufe 0110
           |
           v
2. Stufe 0110


signal spi_temp : std_logic;
.
.
temp <= cs_spi(1,0);
.
.

Wäre das so richtig?

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

Chris schrieb:
> Wäre das so richtig?
Am Simulator siehst du das schnell, also einfach ausprobieren...  ;-)

Ich verwende, um solchen Verwirrungen aus dem Weg zu gehen am liebsten 
dann einfach dedizierte Schieberegister für jeden einzelnen Eingang. 
Diesen kann ich dann auch gleich sinnvolle Namen geben und weiß immer, 
was ich da gerade wohin schiebe. Und mit wenig Aufwand gleich eine 
Flankenerkennung und Entprellung drauf machen...

[Schlumpf (Gast)]

type ELEMENT is array (0 to 1) of std_logic_vector(3 downto 0);
signal S_CS  : ELEMENT;

Reset:

S_CS <= (others =>(others => '0'));

Takt:

S_CS(0) <= In3 & In2 & In1 & In0;
S_CS(1) <= S_CS(0);

Zugriff auf Elemente:
z.B. Synchronisierter Wert von In2 in zweiter Synchronisierungsstufe:

xxx <= S_CS(1)(2)

also so:

Pin:      S_CS(0)(3 downto 0):     S_CS(1)(3 downto 0):
-------------------------------------------------------
In0  -->  S_CS(0)(0)     -->       S_CS(1)(0)
In1  -->  S_CS(0)(1)     -->       S_CS(1)(1)
In2  -->  S_CS(0)(2)     -->       S_CS(1)(2)     --> xxx
In3  -->  S_CS(0)(3)     -->       S_CS(1)(3)

[Chris (Gast)]

Perfekt, danke für deine Hilfe.

[Schlumpf (Gast)]

Die Antwort kam ja schneller, als mein Browser die Seite neu aufgebaut 
hat ;-)

Gerne geschehen!