Array einsynchronisieren

Gast #3162557
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
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
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
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
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
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
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

Eine eigene Frage? Dieser Thread ist über 13 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [vhdl]VHDL-Code[/vhdl]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.