Array einsynchronisieren

Gast #3162557
Lesenswert?

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
1
type ELEMENT is array (0 to 1) of std_ulogic_vector(3 downto 0);
2
type TYP_CS is array (0 to 1) of ELEMENT;
3
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:
1
SYNC : process (CLK)
2
  begin
3
    if rising_edge(CLK) then
4
      if RESET = '1' then
5
   
6
        S_CS        <= (others =>(others => '0'));
7
        ENABLE      <= '0';
8

9
      else
10

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

14
        if ENABLE = '1' then
15
          S_CS (1)            <= S_CS (0); -- 2. Stufe
16
          ENABLE                <= '1';
17
        end if;  
18
      end if;    
19
    end if;      
20

21
  end process SYNC;

So recht will das ganze nicht klappen, villeicht kann mir jemand 
weiterhelfen.
Danke.
Moderator (Firma: Titel) Persönliche Seite #3163327
Lesenswert?

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?
Gast #3163382
Lesenswert?

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
Moderator (Firma: Titel) Persönliche Seite #3163428
Lesenswert?

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?
Gast #3163469
Lesenswert?

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?
Moderator (Firma: Titel) Persönliche Seite #3163537
Lesenswert?

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...
Gast #3163596
Lesenswert?

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

Reset:
1
S_CS <= (others =>(others => '0'));

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

Zugriff auf Elemente:
z.B. Synchronisierter Wert von In2 in zweiter Synchronisierungsstufe:
1
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)

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren