Verilog-Zuweisung

[Heinze (Gast)]

Hi,

habe folgende Verilog-Zeilen in einer Testbench: siehe Anhang

Kann mir jemand dabei helfen, die Verilog-Beschreibung zum besseren 
Verständnis in VHDL umzuschreiben ?

vielen dAnk.

gruss,
Heinze

[Inkassounternehmer (Gast)]

Bei Aldec.com gibt es ein schönes Verilog-Tutorial (interaktiv). Das hat 
mir auch schon geholfen, Verilog-Beschreibungen passend zu meinen 
Anwendungen zu modifizieren.

[Heinze (Gast)]

Na dann dürfte das ja kein Problem für dich sein ... für mich schon,
deswegen frage ich hier

[Günter -. (guenter)]

Schau mal im Verilog Artikel unter:

Verkettung:

http://www.mikrocontroller.net/articles/Verilog#Skalar.2C_Vektor.2C_Bit-Splitting.2C_Verkettung.2C_Wiederholung

Entscheidungsoperator:

http://www.mikrocontroller.net/articles/Verilog#Entscheidungsoperation_mit_if-else_und_.3F_:

Das ganz sind Multiplexer. Die tx_data_gen slices werden mit 0 gemuxed. 
Das Ergebnis wird verkettet und bildet den Eingang zum Ausgangsmux. Der 
muxed die Verkettung mit dem ganzen tx_data_gen.

Das ganze sieht etwa so aus:

tx_data_gen[7:0] -->M      
                    M--------|
               0 -->M        |
                             |
tx_data_gen[15:8]-->M        |
                    M--------|
               0 -->M        |
                             |
tx_data_gen[23:16]-->M       |
                     M-------|
                0 -->M       |
                             |
tx_data_gen[31:24]-->M       |---->M
                     M-------|     M
                0 -->M             M
                                   M
                                   M
                                   M
                                   M
                                   M---> data
                                   M
                   tx_data_gen --->M

[Günter -. (guenter)]

tx_data_gen wird also data zugewiesen und durch die Multiplexer ist es 
möglich immer 8-bit slices auf 0 zu setzen.

[Inkassounternehmer (Gast)]

Hätte ja sein können, dass es dich nur am Rande so interessiert. Ehe ich 
in Regress genommen werde, wollte ich es dir selbst ans Herzchen legen.

[Christoph db1uq K. (christoph_kessler)]

<verilog>
assign #1 data =  (err_word == err_cnt) ?
({(err_byte == 4'h3) ? 8'b0 : tx_data_gen[31:24],
 (err_byte == 4'h2) ? 8'b0 : tx_data_gen[23:16],
 (err_byte == 4'h1) ? 8'b0 : tx_data_gen[15:8],
 (err_byte == 4'h0) ? 8'b0 : tx_data_gen[7:0]})
  : tx_data_gen;
</verilog>
Syntax-Highlighting scheint hier nicht zu gehen ?

Das #1 ist anscheinend das Verzögerungszeichen #, das kenne ich aus der 
Synthese nicht, das braucht man nur zur Simulation.

Da sind zwei Entscheidungsoperationen ineinandergeschachtelt - sehr 
übersichtlich! Zuerst kommt die Zuweisung falls wahr, nach dem 
Doppelpunkt falls falsch.
data wird gleich tx_data_gen  wenn  err_word ungleich err_cnt

bei Gleichheit werden je 4 Bit von err_byte abgefragt und je 8 Bit der 
32 Bit von data entweder Null oder aus je 8Bit von tx_data_gen (32Bit 
breit) gebildet

[Christoph db1uq K. (christoph_kessler)]

nein data ist natürlich 8 Bit breit
und falls err_byte tatsächlich ein Byte breit ist, wird nur die untere 
Hälfte benutzt

[Heinze (Gast)]

Hallo,

danke für die Erklärungen. Ist jetzt klar.

In VHDL also in etwa so:


process(tx_data_gen, err_word, err_cnt, err_byte)
begin
   data <= tx_data_gen;

   if err_word = err_cnt then

      if err_byte="0011" then
         data(31 downto 24) <= (others => '0');
      end if;

      if err_byte="0010" then
         data(23 downto 16) <= (others => '0');
      end if;

      if err_byte="0001" then
         data(15 downto 8) <= (others => '0');
      end if;

      if err_byte="0000" then
         data(7 downto 0) <= (others => '0');
      end if;

   end if;
end process;

[Marcus H. (mharnisch)]

Achtung: Der Verilog Conditional Operator (?:) hat die Eigenschaft, 
unbekannte Werte entsprechend durchzureichen (x-propagation). Das war 
möglicherweise auch der Grund für den Autor, das in dieser Form zu 
formulieren. Diese Fähigkeit in VHDL nachzubilden, kann etwas längeren 
Code erfordern.

Aber falls es darauf nicht ankommt, ist der Code oben schon OK. Ich 
würde wahrscheinlich eine case-Anweisung bevorzugen.

Gruß
Marcus
http://www.doulos.com/