Initial Block em Verilog: Rodando código de setup no início da simulação

Um bloco procedural one-shot

initial begin ... end é o irmão do always. A diferença: initial roda exatamente uma vez, começando no tempo 0, e depois termina. Não há lista de sensibilidade e não há looping.

Ele existe por uma razão: setup de testbench. Definir valores iniciais, disparar estímulo, abrir arquivos de log, chamar $finish depois de um tempo fixo de simulação - todas as coisas que você quer que aconteçam uma vez no início de uma execução, em uma ordem conhecida.

module simple_init;
    reg [7:0] data;

    initial begin
        $display("hello at time %0t", $time);
        data = 8'hA5;
        #10;
        $display("after 10 time units, data = %h", data);
        $finish;
    end
endmodule

Passo a passo do que o simulador faz:

1. O tempo avança para 0.
2. O bloco initial começa. O primeiro $display imprime.
3. data é setado para 8'hA5.
4. #10 avança o tempo simulado em 10 unidades.
5. O segundo $display imprime.
6. $finish termina a simulação.

O bloco rodou uma vez. Não há uma segunda passagem.

O esqueleto canônico de testbench

Quase todo testbench que você vai escrever usa um bloco initial assim:

module dut(
    input  wire        clk,
    input  wire        reset,
    input  wire [3:0]  in,
    output reg  [3:0]  out
);
    always @(posedge clk) begin
        if (reset) out <= 4'd0;
        else       out <= in;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [3:0] in;
    wire [3:0] out;

    dut u_dut(.clk(clk), .reset(reset), .in(in), .out(out));

    // Gerador de clock - separar initial/always para manter limpo.
    always #5 clk = ~clk;

    // Estimulo e ciclo de vida.
    initial begin
        $dumpfile("dump.vcd");
        $dumpvars(0, test);

        // Aplica reset por 2 ciclos.
        in = 4'd0;
        #20 reset = 0;

        // Aciona estimulo.
        in = 4'd1; #10;
        in = 4'd5; #10;
        in = 4'd9; #10;
        in = 4'hF; #10;

        $display("done at %0t", $time);
        $finish;
    end
endmodule

Olhe para a forma - é o template de testbench que você vai usar toda vez:

1. Abre o arquivo de dump VCD ($dumpfile, $dumpvars) - coberto em Dumpfile and VCD.
2. Define valores iniciais e segura reset por alguns ciclos.
3. Aciona estímulo através de uma série de mudanças intercaladas com delays #.
4. $finish para terminar a simulação limpamente.

É isso. Cada teste Verilog que você vai ver, incluindo os exemplos dos fornecedores, segue esse padrão.

Múltiplos blocos initial são paralelos

Vários blocos initial no mesmo module começam todos no tempo 0 simultaneamente. Cada um roda suas próprias declarações em sua própria fatia de tempo:

module parallel_init;
    initial begin
        #5  $display("[A] at time %0t", $time);
        #10 $display("[A] at time %0t", $time);
    end

    initial begin
        $display("[B] at time %0t", $time);   // imprime primeiro
        #2  $display("[B] at time %0t", $time);
        #20 $finish;
    end
endmodule

O simulador inicia ambos os blocos no tempo 0. O primeiro $display do bloco B roda imediatamente. O bloco A espera 5 unidades antes de imprimir. O bloco B imprime de novo no tempo 2. O segundo print do bloco A dispara no tempo 15. O $finish do bloco B mata a simulação no tempo 22.

Dividir setup, geração de clock e estímulo em blocos initial separados é um estilo comum - cada bloco é curto e faz uma coisa.

Inicialização inline em declarações

Uma forma compacta comum: inicializar um reg no momento da declaração. A maioria dos simuladores trata isso como um initial:

reg clk = 0;
reg reset = 1;
reg [7:0] count = 0;

Isso é equivalente a:

reg clk;
reg reset;
reg [7:0] count;

initial begin
    clk = 0;
    reset = 1;
    count = 0;
end

A forma compacta é o que você vai ver em testbenches - coloca o valor inicial logo ao lado da declaração, onde é fácil de escanear.

initial é só de simulação

Ferramentas de síntese ignoram blocos initial. Hardware real não tem um "momento zero" quando código de setup roda - tem power-on, sinais de reset e a configuração que vem desses eventos. Se você precisa que um register comece em um estado conhecido em hardware real, acione-o com um sinal de reset dentro de um always @(posedge clk):

always @(posedge clk) begin
    if (reset) state <= IDLE;
    else       state <= next_state;
end

Esse ramo if (reset) é o equivalente sintetizável de initial state = IDLE. Reset é a resposta para "como inicializo um register em hardware real?"

Algumas flows de FPGA aceitam um initial restrito para valores de reset de register (ferramentas Xilinx, por exemplo), mas isso é uma extensão por fornecedor. Não confie nisso em código portável.

Coisas que você verá dentro de initial

Alguns padrões comuns além do esqueleto padrão de testbench:

Terminação com delay

initial begin
    #1000 $finish;   // rede de seguranca: mata a sim depois de 1000 unidades de tempo
end

Um initial separado cujo único trabalho é colocar um limite superior duro na simulação. Mesmo se seu bloco principal de estímulo travar esperando por um sinal que nunca vem, esse bloco dispara e termina a execução.

Setup de forma de onda

initial begin
    $dumpfile("dump.vcd");
    $dumpvars(0, test);   // dump tudo sob o escopo `test`
end

Essas duas linhas dizem ao simulador para escrever um arquivo VCD com cada sinal no escopo de teste. Sem elas, sem forma de onda.

Imagem de memória inicial

reg [7:0] memory [0:255];

initial begin
    $readmemh("image.hex", memory);
end

$readmemh carrega um arquivo formatado em hex no array. Usado em testbenches de CPU para pré-carregar memória de instruções. Só de simulação.

Erros comuns

Usar initial para lógica sintetizável. Não vai sintetizar. Use sinais de reset no lugar.

Esquecer $finish. Sem ele o simulador roda até algo mais o parar (um limite de tempo padrão, interrupção manual, etc.). Para um teste rápido isso está bom; para um script de regressão, sempre use $finish.

Esquecer #delay entre atribuições de estímulo. Se você escrever a = 0; b = 1; sem delay, ambos acontecem no mesmo tempo de simulação e o DUT pode vê-los simultaneamente em vez de como eventos separados. Insira #1 ou mais longo entre eventos de estímulo distintos.

Tentar conduzir um wire a partir de initial. Mesma regra do always: só reg é um alvo legal.

O que vem a seguir

Você viu os dois sabores de bloco procedural. O próximo doc cobre o tópico mais confuso do Verilog para iniciantes: Blocking vs Non-blocking Assignment. Saber quando usar = e quando usar <= é a diferença entre um flip-flop funcionando e uma bagunça de race conditions.