Contador de 4 Bits: Contagem Binária Eficiente de 0 a 15

O contador de 4 bits começa incrementando de 4'b0000 até 4'h1111 e então volta (rollover) para 4'b0000. Ele continuará contando enquanto for fornecido um clock em execução e o reset for mantido alto.

O rollover ocorre quando o bit mais significativo da adição final é descartado. Quando o contador está no valor máximo de 4'b1111 e recebe mais uma solicitação de contagem, o contador tenta alcançar 5'b10000, mas como suporta apenas 4 bits, o MSB será descartado resultando em 0.

0000 0001 0010 ... 1110 1111 rollover 0000 0001 ...

O projeto contém duas entradas: uma para o clock e outra para um reset ativo-baixo. Um reset ativo-baixo é aquele onde o projeto é resetado quando o valor do pino de reset é 0. Há uma saída de 4 bits chamada out que essencialmente fornece os valores do contador.

Projeto do Contador Eletrônico

module counter (
    input clk,        // Declara porta de entrada para clock para permitir contagem
    input rstn,       // Declara porta de entrada para reset para permitir reset do contador para 0 quando necessário
    output reg[3:0] out  // Declara porta de saída de 4 bits para obter valores do contador
);
// Este bloco always será disparado na borda de subida do clk (0->1)
// Uma vez dentro deste bloco, verifica se o reset é 0, se sim então muda out para zero
// Se reset é 1, então o projeto deve ser permitido contar, então incrementa o contador
always @ (posedge clk) begin
    if (!rstn) out <= 0;
    else out <= out + 1;
end
endmodule

O module counter tem um clock e reset ativo-baixo (denotado por n) como entradas e o valor do contador como saída de 4 bits. O bloco always é executado sempre que o clock transiciona de 0 para 1, o que significa uma borda de subida ou borda positiva. A saída é incrementada apenas se o reset for mantido alto ou 1, alcançado pelo bloco if-else. Se o reset for encontrado baixo na borda positiva do clock, a saída é resetada para um valor padrão de 4'b0000.

Testbench

Podemos instanciar o projeto em nosso módulo de testbench para verificar se o contador está contando conforme esperado.

O módulo de testbench é chamado tb_counter e portas não são necessárias já que este é o módulo superior na simulação. No entanto, precisamos ter variáveis internas para gerar, armazenar e conduzir clock e reset. Para esse propósito, declaramos duas variáveis do tipo reg para clock e reset. Também precisamos de um net do tipo wire para fazer a conexão com a saída do projeto, caso contrário, será padronizado para um net escalar de 1 bit.

O clock é gerado via bloco always que dará um período de 10 unidades de tempo. O bloco initial é usado para definir valores iniciais às nossas variáveis internas e conduzir o valor de reset ao projeto. O projeto é instanciado no testbench e conectado às nossas variáveis internas, para que receba os valores quando os conduzirmos do testbench. Não temos instruções $display em nosso testbench e, portanto, não veremos nenhuma mensagem no console.

module tb_counter;
reg clk;      // Declara variável interna do TB chamada clk para conduzir clock ao projeto
reg rstn;     // Declara variável interna do TB chamada rstn para conduzir reset ativo-baixo ao projeto
wire [3:0] out; // Declara um wire para conectar à saída do projeto
// Instancia o projeto counter e conecta com variáveis do Testbench
counter c0 (
    .clk(clk),
    .rstn(rstn),
    .out(out)
);
// Gera um clock que deve ser conduzido ao projeto
// Este clock inverterá seu valor a cada 5ns -> período = 10ns -> freq = 100 MHz
always #5 clk = ~clk;
// Este bloco initial forma o estímulo do testbench
initial begin
    // 1. Inicializa variáveis do testbench para 0 no início da simulação
    clk <= 0;
    rstn <= 0;
    // 2. Conduz o resto do estímulo, reset é asserido no meio
    #20 rstn <= 1;
    #80 rstn <= 0;
    #50 rstn <= 1;
    // 3. Finaliza o estímulo após 200ns
    #20 $finish;
end
endmodule

Log de Simulação

ncsim> run
[0ns] clk=0 rstn=0 out=0xx
[5ns] clk=1 rstn=0 out=0x0
[10ns] clk=0 rstn=0 out=0x0
[15ns] clk=1 rstn=0 out=0x0
[20ns] clk=0 rstn=1 out=0x0
[25ns] clk=1 rstn=1 out=0x1
[30ns] clk=0 rstn=1 out=0x1
[35ns] clk=1 rstn=1 out=0x2
[40ns] clk=0 rstn=1 out=0x2
[45ns] clk=1 rstn=1 out=0x3
[50ns] clk=0 rstn=1 out=0x3
[55ns] clk=1 rstn=1 out=0x4
[60ns] clk=0 rstn=1 out=0x4
[65ns] clk=1 rstn=1 out=0x5
[70ns] clk=0 rstn=1 out=0x5
[75ns] clk=1 rstn=1 out=0x6
[80ns] clk=0 rstn=1 out=0x6
[85ns] clk=1 rstn=1 out=0x7
[90ns] clk=0 rstn=1 out=0x7
[95ns] clk=1 rstn=1 out=0x8
[100ns] clk=0 rstn=0 out=0x8
[105ns] clk=1 rstn=0 out=0x0
[110ns] clk=0 rstn=0 out=0x0
[115ns] clk=1 rstn=0 out=0x0
[120ns] clk=0 rstn=0 out=0x0
[125ns] clk=1 rstn=0 out=0x0
[130ns] clk=0 rstn=0 out=0x0
[135ns] clk=1 rstn=0 out=0x0
[140ns] clk=0 rstn=0 out=0x0
[145ns] clk=1 rstn=0 out=0x0
[150ns] clk=0 rstn=1 out=0x0
[155ns] clk=1 rstn=1 out=0x1
[160ns] clk=0 rstn=1 out=0x1
[165ns] clk=1 rstn=1 out=0x2
Simulação completa via $finish(1) no tempo 170 NS + 0

Note que o contador reseta para 0 quando o reset ativo-baixo se torna 0, e quando o reset é desasssertido por volta de 150ns, o contador começa a contar a partir da próxima ocorrência da borda positiva do clock.

Esquemático de Hardware