verilog código ..

[smileysam]

Iam tentar um contador espasmódico que um dos problemas do exercício em um livr prob é que a declaração desativar "main_counter_loop desativar," nunca é evocado, conduzindo a transbordar.

O código é o seguinte:/ / Contador jerky
main_jerky_counter módulo (out_count, relógio);
output [7:0] out_count;
relógio inout;
jerky_counter i1 (out_count, relógio);
clock_gen i2 (relógio);
endmodule

jerky_counter módulo (out_count, relógio);
output [7:0] out_count;
clock de entrada;
count integer;
shift_count inteiro;
reg [7:0] out_count;
inicial
começo
count = 1;
shift_count = 1;
out_count = 8'b0;
fim
always @ (posedge clock)
begin: main_counter_loop
if (count% 2 == 1)
começo
out_count <= 8'b1;
count = count 1;
fim
diferente
começo
if (out_count> = 8'b10000000)
começo
main_counter_loop desativar;
out_count <= 8'b11111111;
shift_count <= 1;
count <= 1;
fim
diferente
começo
out_count <= (8'b1 <<shift_count);
shift_count = shift_count 1;
count = count 1;
fim
fim
fim
endmodule

clock_gen módulo (relógio);
relógio de saída;
relógio de registro;
inicial
clock = 0;
sempre
# 50 clock = clock ~;
endmodule

 

[SVHB]

Eu não sei se é isso que você está depois, é só querer compartilhar um pouco da minha experiência com projeto de lógica.

Primeiro você começa com algum recorte apropriado de seu código.
Nunca é uma boa idéia de misturar banco de ensaio com a implementação, o banco de ensaio não deve ter nenhum entradas / saídas
Você sempre precisa de uma redefinição do seu sistema.Você precisa começar em algum estado conhecido.

Um relógio e reset sempre são entradas para o sistema, não inout como no seu exemplo.Se você dividir o código em um banco de ensaio separados que você não precisa desse truque.

Não use inteiro para o seu código synthesisable.Use reg com uma determinada largura.

O main_counter_loop desativar não é uma boa idéia quando você quiser fazer uma lógica que pode ser colocado em um chip.Você normalmente pode resolver isso com algum outro "normal" da lógica
Sempre use '<=' (non-blocking atribuição) para processos cronometrado.

Eu modifiquei o código de um littlebit, eu não mudei a parte principal da lógica, é preciso simular a si mesmo, e depurá-lo

Código:

/ / Contador jerky

main_jerky_counter módulo (out_count, relógio, reset);clock de entrada;

Reiniciado de entrada;

output [7:0] out_count;jerky_counter i1 (out_count, relógio, reset);/ / não precisa disto, será no testbench

/ / clock_gen i2 (relógio);endmodulejerky_counter módulo (out_count, relógio, reset);output [7:0] out_count;

clock de entrada;

Reiniciado de entrada;reg [xxx: 0 count];

reg [yyy: 0] shift_count;reg [7:0] out_count;always @ (relógio posedge ou redefinir posedge)

if (reset)

começo

count <= 1;

shift_count <= 1;

out_count <= 8'b0;

fim

diferente

begin: main_counter_loop

if (count% 2 == 1)

começo

out_count <= 8'b1;

count <= count 1;

fim

diferente

começo

if (out_count> = 8'b10000000)

começo

/ / Fazer diferente

/ main_counter_loop / desativar;

out_count <= 8'b11111111;

shift_count <= 1;

count <= 1;

fim

diferente

começo

out_count <= (8'b1 <<shift_count);

shift_count <= shift_count 1;

count <= count 1;

fim

fim

fimendmoduletestbench módulo ();relógio de registro;

Reiniciado reg;

wire [7:0] out_count;/ / instanciar o DUT (Device Under Test)

dur main_jerky_counter (out_count, relógio, reset);/ / gera clock e reset

initial begin

reset = 1;

clock = 0;

# 10;

reset = 0;

sempre clock # 50 = clock ~;

fimendmodule