noen fortelle meg hva som er galt med denne Verilog koden??

angjohn · Jun 24, 2001

Følgende kode er skrevet med Verilog:

/ / CU
modul Controlunit (Z, restarte, CMP, opcode, CLK);

output [14:0] Z;
wire [14:0] Z;
input reset;
input CMP;
input [7:0] opcode;
input CLK;/ / intern FSM staten erklæringer, PS = nåværende status, NS = neste tilstand
reg [4:0] PS;
wire [4:0] NS;/ / stat kodinger
parameter S0 = 5'b00000;
parameter S1 = 5'b00001;
parameter S2 = 5'b00010;
parameter S3 = 5'b00011;
parameter S4 = 5'b00100;
parameter S5 = 5'b00101;
parameter S6 = 5'b00110;
parameter S7 = 5'b00111;
parameter S8 = 5'b01000;
parameter S9 = 5'b01001;
parameter S10 = 5'b01010;
parameter S11 = 5'b01011;
parameter S12 = 5'b01100;
parameter S13 = 5'b01101;
parameter S14 = 5'b01110;
parameter S15 = 5'b01111;
parameter S16 = 5'b10000;
parameter S17 = 5'b10001;
parameter S18 = 5'b10010;
parameter S19 = 5'b10011;

wire [1:0] a;
wire [1:0] b;
wire c;
wire d;
wire [3:0] e;

tildele en = opcode [7:6];
tildele b = opcode [5:4];
tildele c = opcode [3];
tildele d = opcode [2];
tildele e = opcode [7:4];/ / combinational logikk

function [19:0] FSM;
input [1:0] fsm_a;
input [1:0] fsm_b;
input fsm_c;
input fsm_d;
input [3:0] fsm_e;
input [4:0] fsm_PS;
input fsm_CMP;

reg [14:0] fsm_Z;
reg [4:0] fsm_NS;

begynne
case (fsm_PS)
S0:
begynne
fsm_NS = S1;
fsm_Z = 15'b010000000000000;
slutt
S1:
begynne
fsm_NS = S2;
fsm_Z = 15'b000000000000000;
slutt
S2:
begynne
fsm_Z = 15'b101000000000000;
if (fsm_a == 2'b00 | fsm_a == 2'b01)
begynne
fsm_NS = S3;
slutt
else if (fsm_a == 2'b10)
begynne
fsm_NS = S10;
slutt
else if (fsm_a == 2'b11)
begynne
fsm_NS = S19;
slutt
slutt
S3:
begynne
fsm_Z = 15'b000000000000000;
case (fsm_e)
4'b0000:
begynne
fsm_NS = S4;
slutt
4'b0001:
begynne
fsm_NS = S5;
slutt
4'b0010:
begynne
fsm_NS = S6;
slutt
4'b0011:
begynne
fsm_NS = S7;
slutt
4'b0100:
begynne
fsm_NS = S8;
slutt
default:
begynne
fsm_NS = S9;
slutt
endcase
slutt
S4:
begynne
fsm_NS = S1;
if (fsm_c == 1'b0)
begynne
fsm_Z = 15'b000000010001000;
slutt
ellers
begynne
fsm_Z = 15'b000000001001000;
slutt
slutt
S5:
begynne
fsm_NS = S1;
if (fsm_c == 1'b0)
begynne
fsm_Z = 15'b000000010001001;
slutt
ellers
begynne
fsm_Z = 15'b000000001100001;
slutt
slutt
S6:
begynne
fsm_NS = S1;
if (fsm_c == 1'b0)
begynne
fsm_Z = 15'b000000010001010;
slutt
ellers
begynne
fsm_Z = 15'b000000001001010;
slutt
slutt
S7:
begynne
fsm_NS = S1;
if (fsm_c == 1'b0)
begynne
fsm_Z = 15'b000000010001011;
slutt
ellers
begynne
fsm_Z = 15'b000000001001011;
slutt
slutt
S8:
begynne
fsm_NS = S1;
if (fsm_c == 1'b0)
begynne
fsm_Z = 15'b000000010000100;
slutt
ellers
begynne
fsm_Z = 15'b000000001100100;
slutt
slutt
S9:
begynne
fsm_NS = S1;
if (fsm_c == 1'b0)
begynne
fsm_Z = 15'b000000010000101;
slutt
ellers
begynne
fsm_Z = 15'b000000001100101;
slutt
slutt
S10:
begynne
fsm_Z = 15'b000000000000110;
fsm_NS = S11;
slutt
S11:
begynne
fsm_Z = 15'b001000100000110;
case (fsm_b)
2'b00:
begynne
fsm_NS = S12;
slutt
2'b01:
begynne
fsm_NS = S15;
slutt
2'b10:
begynne
fsm_NS = S17;
slutt
default:
begynne
fsm_NS = S18;
slutt
endcase
slutt
S12:
begynne
hvis fsm_d (== 1'b0)
begynne
fsm_NS = S14;
fsm_Z = 15'b000000000000110;
slutt
ellers
begynne
fsm_Z = 15'b000010000000110;
fsm_NS = S13;
slutt
slutt
S13:
begynne
fsm_NS = S14;
fsm_Z = 15'b000010100000110;
slutt
S14:
begynne
fsm_NS = S1;
if (fsm_c == 1'b0)
begynne
fsm_Z = 15'b000000010010110;
slutt
ellers
begynne
fsm_Z = 15'b000000001010110;
slutt
slutt
S15:
begynne
fsm_NS = S16;
if (fsm_c == 1'b0)
begynne
fsm_Z = 15'b000011000000110;
slutt
ellers
begynne
fsm_Z = 15'b000011000100110;
slutt
slutt
S16:
begynne
fsm_NS = S1;
fsm_Z = 15'b000010000000110;
slutt
S17:
begynne
fsm_NS = S1;
fsm_Z = 15'b000100000010110;
slutt
S18:
begynne
fsm_NS = S1;
hvis fsm_CMP (== 1'b1)
begynne
fsm_Z = 15'b000100000010110;
slutt
ellers
begynne
fsm_Z = 15'b000000000000000;
slutt
slutt
S19:
begynne
fsm_NS = S1;
fsm_Z = 15'b000000000000000;
slutt
endcase

FSM = (fsm_Z, fsm_NS);
slutt
endfunction/ / revurdere combinational logikken når opcode eller nåværende status endringer
tildele (Z, NS) = FSM (a, b, c, d, e, PS, CMP);/ / klokke staten flip flop
alltid @ (negedge CLK)
begynne
if (reset == 1'b1)
PS = S0;
ellers
PS = NS;
slutt

endmoduleTakk for hjelpen!!

Thomson · Jun 24, 2001

(1) Ved uttalelser skal være komplett som betyr at du bør omfatte alle mulige muligheter, eller du kan inneholde Standard oppgaver stedet der NS = PS; andre variabler 'assignemnts avhenge de virkelige forholdene.

(2) Ikke bruk tildele uttalelser vilkårlig siden for VCS og Verilog-XL disse uttalelsene 'kjøring mekanisme avvike fra alltid prosedyrer, derfor må du bruke alltid prosedyrer som mulig.Dette påvirker hovedsakelig din simuleringer resultater hvis du bruker forskjellige simulatorer.

echo47 · Jun 24, 2001

Når du legger inn koden til dette forumet, kan du bruke ""-knappen slik at vi kan se innrykk.

nand_gates · Jun 24, 2001

Her er korrigert koden!
Dette er hva som er ment av Mr. Thomson ..
Jeg gjorde det lite lesbar ved å fjerne uønskede begynne slutterCode:

/ / CU

modul Controlunit (Z, restarte, CMP, opcode, CLK);output [14:0] Z;

reg [14:0] Z;

input reset;

input CMP;

input [7:0] opcode;

input CLK;/ / intern FSM staten erklæringer, PS = nåværende status, NS = neste tilstand

reg [4:0] PS;

reg [4:0] NS;/ / stat kodinger

parameter S0 = 5'b00000;

parameter S1 = 5'b00001;

parameter S2 = 5'b00010;

parameter S3 = 5'b00011;

parameter S4 = 5'b00100;

parameter S5 = 5'b00101;

parameter S6 = 5'b00110;

parameter S7 = 5'b00111;

parameter S8 = 5'b01000;

parameter S9 = 5'b01001;

parameter S10 = 5'b01010;

parameter S11 = 5'b01011;

parameter S12 = 5'b01100;

parameter S13 = 5'b01101;

parameter S14 = 5'b01110;

parameter S15 = 5'b01111;

parameter S16 = 5'b10000;

parameter S17 = 5'b10001;

parameter S18 = 5'b10010;

parameter S19 = 5'b10011;wire [1:0] a;

wire [1:0] b;

wire c;

wire d;

wire [3:0] e;tildele en = opcode [7:6];

tildele b = opcode [5:4];

tildele c = opcode [3];

tildele d = opcode [2];

tildele e = opcode [7:4];/ / combinational logikk

/ / revurdere combinational logikken når opcode eller nåværende status endringer

alltid @ (CMP eller PS eller a eller b eller c, eller d eller e)

begynne

NS = PS;

Z = 15'b000000000000000;

case (PS)

S0:

begynne

NS = S1;

Z = 15'b010000000000000;

slutt

S1:

begynne

NS = S2;

Z = 15'b000000000000000;

slutt

S2:

begynne

Z = 15'b101000000000000;

if (a == 2'b00 | a == 2'b01)

NS = S3;

else if (a == 2'b10)

NS = S10;

else if (a == 2'b11)

NS = S19;

slutt

S3:

begynne

Z = 15'b000000000000000;

saken (e)

4'b0000: NS = S4;

4'b0001: NS = S5;

4'b0010: NS = S6;

4'b0011: NS = S7;

4'b0100: NS = S8;

standard: NS = S9;

endcase

slutt

S4:

begynne

NS = S1;

if (c == 1'b0)

Z = 15'b000000010001000;

ellers

Z = 15'b000000001001000;

slutt

S5:

begynne

NS = S1;

if (c == 1'b0)

Z = 15'b000000010001001;

ellers

Z = 15'b000000001100001;

slutt

S6:

begynne

NS = S1;

if (c == 1'b0)

Z = 15'b000000010001010;

ellers

Z = 15'b000000001001010;

slutt

S7:

begynne

NS = S1;

if (c == 1'b0)

Z = 15'b000000010001011;

ellers

Z = 15'b000000001001011;

slutt

S8:

begynne

NS = S1;

if (c == 1'b0)

Z = 15'b000000010000100;

ellers

Z = 15'b000000001100100;

slutt

S9:

begynne

NS = S1;

if (c == 1'b0)

Z = 15'b000000010000101;

ellers

Z = 15'b000000001100101;

slutt

S10:

begynne

Z = 15'b000000000000110;

NS = S11;

slutt

S11:

begynne

Z = 15'b001000100000110;

case (b)

2'b00: NS = S12;

2'b01: NS = S15;

2'b10: NS = S17;

standard: NS = S18;

endcase

slutt

S12:

begynne

if (d == 1'b0)

begynne

NS = S14;

Z = 15'b000000000000110;

slutt

ellers

begynne

Z = 15'b000010000000110;

NS = S13;

slutt

slutt

S13:

begynne

NS = S14;

Z = 15'b000010100000110;

slutt

S14:

begynne

NS = S1;

if (c == 1'b0)

Z = 15'b000000010010110;

ellers

Z = 15'b000000001010110;

slutt

S15:

begynne

NS = S16;

if (c == 1'b0)

Z = 15'b000011000000110;

ellers

Z = 15'b000011000100110;

slutt

S16:

begynne

NS = S1;

Z = 15'b000010000000110;

slutt

S17:

begynne

NS = S1;

Z = 15'b000100000010110;

slutt

S18:

begynne

NS = S1;

if (CMP == 1'b1)

Z = 15'b000100000010110;

ellers

Z = 15'b000000000000000;

slutt

S19:

begynne

NS = S1;

Z = 15'b000000000000000;

slutt

endcase

end / / alltid @ (.../ / klokke staten flip flop

alltid @ (negedge CLK)

begynne

if (reset == 1'b1)

PS <= S0;

ellers

PS <= NS;

sluttendmodule

Thomson · Jun 24, 2001

(3) annet problem kanskje finnes hvis du ikke tar vare å skrive RTL koder, som er at det blokkerer oppgaver er et bedre alternativ til ikke-blokkerende seg siden den forrige willn't indusere løpene (som betyr slike oppdrag gjør 'nt avhengig av din prosedyren i rekkefølge som til simulering).for eksempel følgende to de vil forårsake raser:
alltid @ (posedge klokke)
begynne
a = b;
slutt
alltid @ (posedge klokke)
begynne
c = a;
slutt

resultatene kan være forskjellig for forskjellige leverandører 'simulatorer, selv for den samme simulatoren, hvis versjonen skiller resultatene kan likevel være forskjellig.Fordi kjøring rekkefølgen på over to alltid blokkene er tilfeldig, årsak hvis du bruker VCS simulator resultatene lik den neste:
alltid @ (posedge klokke)
begynne
a = b;
c = a;
sluttså hvis mulig, ved hjelp av blokkere oppgaver kan redusere slike skrive-lese løp og rekkefølgen på blokkene kan ignoreres.Du kan se noen bestilling disscussing slike spørsmål om hvordan du unngår løpene under writting prosessen.Lagt etter 21 minutter

4) Vær oppmerksom på de standard oppgaver: NS = PS stedet for NS = S0 please.
Gitt vilkåret om at selv om noen stimuli oppstår men slike stimuli endrer ikke dagens tilstand, derfor NS = PS er det riktige.

angjohn · Jun 24, 2001

takk for alle svar ur og hjelp, takk!men nå har jeg 1 flere problem som jeg hadde skrevet dette programmet telleren i VHDL så jeg vil at modulen skal være i Verilog men jeg hadde noe problem writting i Verilog, Følgende er VHDL-koden, og også Verilog koden som jeg fikk skrive, men ansikt noe problem med det.så kan noen gi meg noen råd om hvordan du kan gjøre Verilog koden ligner på VHDL kode, PLEASE!

Code:VHDL:

- PrgmCounter

library IEEE;

bruk IEEE.std_logic_1164.all;

bruk IEEE.std_logic_arith.all;

bruk IEEE.std_logic_unsigned.all;enhet PrgmCounter er

port (

data: in STD_LOGIC_VECTOR (7 downto 0);

q: out STD_LOGIC_VECTOR (7 downto 0);

clrreg: i STD_LOGIC;

loadreg: i STD_LOGIC;

increg: i STD_LOGIC;

CLK: in STD_LOGIC

);

end PrgmCounter;arkitektur PrgmCounter_arch av PrgmCounter ersignal temp: STD_LOGIC_VECTOR (7 downto 0);begynne

process (clk, clrreg, loadreg, increg)

begynne

hvis clrreg = '1 'deretter temp <= (andre => '0');

ellers

if (clk 'event and clk = '1') then

hvis loadreg = '1 'deretter temp <= data;

ellers

hvis increg = '1 'deretter temp <= temp 1;

else temp <= temp;

end if;

end if;

end if;

end if;

end process;

q <= temp;end PrgmCounter_arch;Verilog:

/ / PrgmCounter

modul PrgmCounter (data, q, clrreg, loadreg, increg, CLK);input [7:0] data;

output [7:0] q;

wire [7:0] q;

input clrreg;

input loadreg;

input increg;

input CLK;reg [7:0] temp;alltid @ (CLK eller clrreg eller loadreg eller increg)

begynne

if (clrreg == 1'b1)

begynne

temp <= (8 (1'b0));

slutt

ellers

begynne

if (CLK == 1'b1)

begynne

if (loadreg == 1'b1)

begynne

temp <= data;

slutt

ellers

begynne

if (increg == 1'b1)

begynne

temp <= temp 1;

slutt

ellers

begynne

temp <= temp;

slutt

slutt

slutt

slutt

slutt

tildele q = temp;

endmodule

jelydonut · Jun 24, 2001

3. gang prøver å svare på dette ..stupid Mandrake ..

anyways ..

måten du skrev din alltid blokkere det ville i utgangspunktet syntetisere å kombinatorisk logikk kanskje med en antatt låsen eller to.I didn't pay attention ..Hva du kommer til er en kant utløst klokke hendelse ..

reg [7:0] uansett;

; alltid @ (posedge clk); sync tilbakestille tilstand
alltid @ (posedge clk eller posedge rst_cond); ASYNC tilbakestille tilstand ..
if (rst_cond)
uansett <= 8'b0000_0000;
ellers
begynne
if (ld_cond)
uansett <= data_in;
ellers
if (inc_cond)
uansett <= alt 1'b1;
slutt

som skal gjøre det ..

du også virkelig ikke trenger å gå gale på begynner-ender ..den eneste gangen det er nødvendig er hvis du har 2 uttalelser inbetween gren, eller hvis du har 2 grenen forholdene under et annet sted ..

eksempel ..

ellers
begynne
if (inc_cond)
uansett <= alt 1'b1;
ellers
if (dec_cond)
uansett <= uansett - 1'b1;
sluttjelydonut

Thomson · Jun 24, 2001

Det er noen råd om vering / VHDL Coding stiler:
(1) Tenk på maskinvaren når kodingen design
(2) Noen avvik virkelig eksisterer blant Verilog and VHDL Syntax.Den tidligere alltid bruke posedge / negedge clk å indikere en klokke hendelse, mens sistnevnte ofter bruk egenskap av signalet for å indikere en klokke hendelse som clock'event.Hvis du er en nyere til de to språkene, vil du bedre koden din design når du vil forstå betydningen av effekten av sigans "hendelsene på gjennomføringen av prosessen (VHDL) eller alltid (Verilog).
(3) Det vil ikke antyde låsene hvis du bruker non-blocking oppdrag.Låsene antyde ofte oppstår under combinationatory logikken generasjonen blokker som tildeler og alltid blokker, der hvis følsomheten listen ikke er komplett eller forholdene er ikke komplett, da låsene vil bli infered og tidspunktet analysen vil komplisere og forskjellen mellom den RTL simulering og netlist simulering kan (må) forekomme.

angjohn · Jun 24, 2001

takk fyrene for hjelpen!!jeg står nå overfor et annet problem, bruker jeg denne Altera Ram (LPM_RAM_DQ) og følgende er koden jeg skrevet og det fungerer, men på grunn av syntaks: "defparam" jeg bruker i koden noen av kompilatoren kan ikke innse at syntaksen.Så kan noen foreslå til meg hvordan jeg skal erstatte den "defparam" syntaks med en mer generell syntaks så jeg kan bruke koden med det meste av kompilatoren, takk!Følgende er kodeCode:modul RAM (

adresse,

vi,

klokke,

data,

q);input [7:0] adresse;

input vi;

input clock;

input [7:0] data;

output [7:0] q;wire [7:0] sub_wire0;

wire [7:0] q = sub_wire0 [7:0];lpm_ram_dq lpm_ram_dq_component (

. adresse (adresse),

. inclock (klokke),

. data (data),

. vi (vi),

. q (sub_wire0));

defparam

lpm_ram_dq_component.intended_device_family = "FLEX10K",

lpm_ram_dq_component.lpm_width = 8,

lpm_ram_dq_component.lpm_widthad = 8,

lpm_ram_dq_component.lpm_indata = "registrert",

lpm_ram_dq_component.lpm_address_control = "registrert",

lpm_ram_dq_component.lpm_outdata = "UNREGISTERED",

lpm_ram_dq_component.use_eab = "ON",

lpm_ram_dq_component.lpm_hint = "MAXIMUM_DEPTH = 256",

lpm_ram_dq_component.lpm_type = "LPM_RAM_DQ",

lpm_ram_dq_component.lpm_file = "nabilcpu.mif";endmodule

angjohn · Jun 24, 2001

hey guys!jeg fikk skrive følgende modulen i VHDL og det fungerer godtCode:

- Flag

library IEEE;

bruk IEEE.std_logic_1164.all;

bruk IEEE.std_logic_arith.all;enhet Flag er

port (

FlagIn: i STD_LOGIC_VECTOR (16 downto 0);

ldOut: i STD_LOGIC;

- ldStatus: i STD_LOGIC;

FlagOut: out STD_LOGIC_VECTOR (15 downto 0);

CLK: in STD_LOGIC

);

end Flag;arkitektur Flag_arch av flagg er

begynne

Process (clk)

variabel C, Z, N, V: STD_LOGIC;

begynneif (clk 'event and clk = '1') then

hvis ldOut = '1 'da

hvis FlagIn = "00000000000000000" da

Z: = '1 ';

ellers

Z: = '0 ';

end if;- Bank: = FlagIn (11);

N: = FlagIn (15);

C: = FlagIn (16);

V: = N xor C;FlagOut <= C & N & V & Z & "000000000000";

end if;- Hvis ldStatus = '1 'da

- FlagOut <= FlagIn (15 downto 0);

- end if;end if;end process;

end Flag_arch;

nand_gates · Jun 24, 2001

Hei Jeg har ur problem ...
Den oversatte koden gir samlealbum feil ....
Her er korrigert koden ....

Code:

/ / Flag

modul Flag (FlagIn, ldOut, FlagOut, CLK);input [16:0] FlagIn;

input ldOut;

output [15:0] FlagOut;

reg [15:0] FlagOut;

input CLK;alltid @ (posedge CLK)

begin: junk

reg C;

reg Z;

reg N;

reg V;if (ldOut == 1'b1)

begynne

hvis FlagIn (== 17'b00000000000000000)

Z = 1'b1;

ellers

Z = 1'b0;N = FlagIn [15];

C = FlagIn [16];

V = N ^ C;

FlagOut <= (C, N, V, Z, 12'b000000000000);

slutt

slutt

endmodule

tigerliu · Jun 24, 2001

Hei,
nand_gates 'første del av koden er god.Dette er en foretrukket koding stil statemachine.For mer koding retningslinje, kan du gå til:
h ** p: / / www.sunburst-design.com/papers/tiger

noen fortelle meg hva som er galt med denne Verilog koden??

angjohn

Guest

Thomson

Guest

echo47

Guest

nand_gates

Guest

Thomson

Guest

angjohn

Guest

jelydonut

Guest

Thomson

Guest

angjohn

Guest

angjohn

Guest

nand_gates

Guest

tigerliu

Guest

Welcome to EDABoard.com

Sponsor

Online statistics

Forum statistics

noen fortelle meg hva som er galt med denne Verilog koden??

angjohn

Guest

Thomson

Guest

echo47

Guest

nand_gates

Guest

Thomson

Guest

angjohn

Guest

jelydonut

Guest

Thomson

Guest

angjohn

Guest

angjohn

Guest

nand_gates

Guest

tigerliu

Guest

Log in

Welcome to EDABoard.com

Sponsor