convertire da VHDL

[Kaiser]

Qualcuno mi può aiutare con questo codice VHDL io ..... voglio cnvert questo codice in un codice Verilog e io non so come .... HEELLLPPP

Questo è il codice VHDL in:

Codice:

vhdlmodule entità è

Porta (CLKIN: in std_logic;

AN3: std_logic InOut;

AN2: std_logic InOut;

AN1: std_logic InOut;

AN0: std_logic InOut;

LED: std_logic_vector out (6 downto 0));

vhdlmodule fine;architettura comportamentale è vhdlmodulesegnale CTR: std_logic_vector (12 downto 0);

iniziare

Processo (CLKIN)

iniziare

se CLKIN'event e CLKIN = '1 ', poi

if (CTR = "0000000000000"), allora

if (AN0 = '0 '), poi

AN0 <= '1 ';

LED <= "0101011";

AN1 <= '0 ';

elsif (AN1 = '0 '), poi

AN1 <= '1 ';

LED <= "0101011";

<AN2 = '0 ';

elsif (AN2 = '0 '), poi

<= '1 AN2 ';

LED <= "0001000";

<AN3 = '0 ';

elsif (AN3 = '0 '), poi

<AN3 = '1 ';

LED <= "0000110";

AN0 <= '0 ';

end if;

end if;

CTR CTR <= "0000000000001";

if (CTR> "1000000000000"), allora

CTR <= "0000000000000";

end if;

end if - CLK'event e CLK = '1 '

Termina processo;

Fine del comportamento

 

[dBUGGER]

Ciao Kaiser,' after always @posedge

Si prega di inserire un 'inizio'
dopo sempre posedge @
e una dichiarazione finale in occasione dell'ultimo endmodule prima.Provate questo.

Cordiali saluti,

 

[nand_gates]

Questo codice è privo di significato!Può spiegare che cosa hardware che si desidera
descrivere con questo codice??Aggiunto dopo 8 minuti:Se si desidera solo la traduzione quindi qui va .....
Codice:

ritmo modulo (CLK,

AN0,

AN1,

AN2,

AN3,

LED

);

InOut AN0, AN1, AN2, AN3;

ingresso CLK;

uscita [6:0] LED;

reg [6:0] LED;reg [12:0] contare;

reg AN0_r, AN1_r, AN2_r, AN3_r;

assegnare AN0 = AN0_r;

assegnare AN1 = AN1_r;

assegnare AN2 = AN2_r;

assegnare AN3 = AN3_r;sempre @ (posedge CLK)

if (count == 13'h0) cominciano

if (! AN0) iniziano

AN0_r <= 1'b1;

LED <= 7'b0010010; / / A

AN1_r <= 1'b0;

fine

else if (! AN1) iniziano

AN1_r <= 1'b1;

LED <= 7'b0110001; / / C

AN2_r <= 1'b0;

fine

else if (! AN2) iniziano

AN2_r <= 1'b1;

LED <= 7'b0011000; / / P

AN3_r <= 1'b0;

fine

else if (! AN3) iniziano

AN3_r <= 1'b1;

LED <= 7'b0110000; / / E

AN0_r <= 0;

fine

<Count = count 13'b1;

if (count> 13'h1000) cominciano

<Count = 13'h0;

fine

fine / / if (count == 13'h0)

endmodule

 

[Kaiser]

L'obiettivo di questo codice Sorce è quello di scrivere "PACE" sul-sette segmenti LED sulla scheda Spartan3 (starter kit da Xilinx)
Dal momento che a sette segmenti a LED sono a tempo multiplexati, ho bisogno di "qualcosa" per dirmi di scrivere il primo carattere, allora c'è qualcosa che dice di scrivere il secondo e così via.Questo sarà dato da un orologio.
Per il segnale di clock che uso l'orologio 50Mhz fornite sulla scheda.Purtroppo questo è troppo rapido per selezionare le cifre beteen sul pannello LED.Così sarà con un nome CTR contatore, ogni volta che il contatore raggiunge i 2 ^ 13 a cambiare la cifra da visualizzare, se io azzerare il contatore.

Ma è abituato lavoro ...... quando si scarica il file po 'sul bordo del mio 4 cifre diplay dont le informazioni corrette (PACE)
Sto utilizzando apposito modulo ISE Webpack Xilinx.
Se Gott qualsiasi codice che lo farà .... per favore mi mostri! (Con poche, spiega)

THXquesto è il monito io ottenere ..:

ATTENZIONE: xst: 1710 - FF / Latch <LED_6> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <AN0_r> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <AN1_r> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <LED_0> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <LED_1> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <LED_2> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <LED_3> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <LED_4> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <LED_5> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <count_0> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <AN2_r> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1895 - A causa di altri FF / Latch rifilatura, FF / Latch <AN3_r> (senza valore init) è costante in <pace> blocco.
ATTENZIONE: xst: 1291 - FF / Latch <count_1> è estraneo in <pace> blocco.

 

[nand_gates]

Check out con questo codice, questo dovrebbe funzionare!
Questo è scritto nei vecchi giorni PLD stile!

Codice:

ritmo modulo (CLK,

RST_n,

AN0,

AN1,

AN2,

AN3,

LED

);

Uscita AN0, AN1, AN2, AN3;

ingresso CLK;

ingresso RST_n;uscita [6:0] LED;

reg [6:0] LED;reg [12:0] contare;

reg AN0, AN1, AN2, AN3;sempre @ (CLK posedge o negedge RST_n) cominciano

if (! RST_n) iniziano

AN0 <= 1'b0;

AN1 <= 1'b0;

AN2 <= 1'b0;

<= AN3 1'b0;

<Count = 0;

end else begin

<Count = count 1'b1;

if (& count) cominciare

AN0 <= | ~ (AN0, AN1, AN2);

AN1 <= AN0;

<= AN2 AN1;

<= AN3 AN2;

fine / / if (count == 13'h0)

fine / / else:! if (! RST_n)

fine / / sempre @ (CLK posedge o negedge RST_n)

sempre @ (/ * come * / AN0 o AN1 o AN2 o AN3) cominciano

LED = 7'b0000000;

caso (1'b1) / / Synopsys parallel_case

AN0: LED = 7'b0010010; / / A

AN1: LED = 7'b0110001; / / C

AN2: LED 7'b0011000 = / / P

AN3: LED = 7'b0110000; / / E

endcase / / caso (1'b1)

fine

endmodule / / ritmo

 

[maxer]

uso x-hdl

molto utile

maxer

 

[echo47]

Ecco un altro approccio.Io di solito uso registrare valori iniziali al posto di un ingresso reset.
Codice:

alto modulo (sys_clk, LED_Digit, LED_Segment);

ingresso sys_clk;

reg [11:0 count] = 0;

uscita reg [3:0] LED_Digit = 0;

uscita reg [7:0] LED_Segment;sempre @ (posedge sys_clk) iniziano

count <count = 1;

if (count == 0) cominciare

if (! LED_Digit [2])

(LED_Digit, LED_Segment) <= (4'b0111, ~ 8'b11001110); / / P

else if (! LED_Digit [1])

(LED_Digit, LED_Segment) <= (4'b1011, ~ 8'b11101110); / / A

else if (! LED_Digit [0])

(LED_Digit, LED_Segment) <= (4'b1101, ~ 8'b10011100); / / C

else if (! LED_Digit [3])

(LED_Digit, LED_Segment) <= (4'b1110, ~ 8'b10011110); / / E

fine

fine

endmodule

 

[tkbits]

Codice:

if (count> 13'h1000) cominciano

<Count = 13'h0;

fine

 

[echo47]

13 è il numero di bit, e 'h1000 è il valore esadecimale.Così 13'h1000 è 1000000000000 e 0000000000000 13'h0 è.
contare registro, è 13 bit troppo, così il "if" è ok.

L'esempio di utilizzo di tale affermazione ha due e diverse assigments simultanea a contare.Che può funzionare (Verilog esegue non-blocking dichiarazioni dall'alto verso il basso), ma per motivi di chiarezza avevo evitare di farlo.