Always Block em Verilog: Lógica combinacional e sequencial

O burro de carga do Verilog comportamental

assign descreve lógica combinacional de equação única. Assim que você precisa de if/else, case ou memória, recorre a always. Um bloco always é uma peça de código procedural que re-roda sempre que sinais específicos mudam. Os sinais que disparam a re-execução são a sensitivity list.

Há duas formas de always que você verá com mais frequência:

1. always @(*) - re-roda sempre que qualquer sinal lido no bloco muda. Constrói lógica combinacional.
2. always @(posedge clk) - re-roda só na borda de subida de clk. Constrói lógica sequencial clocked (flip-flops).

Outras formas existem (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)) mas as duas acima representam quase todo bloco sintetizável que você vai escrever.

Combinacional always @(*)

module decoder3(
    input  wire [2:0] sel,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            3'd0: out = 8'b0000_0001;
            3'd1: out = 8'b0000_0010;
            3'd2: out = 8'b0000_0100;
            3'd3: out = 8'b0000_1000;
            3'd4: out = 8'b0001_0000;
            3'd5: out = 8'b0010_0000;
            3'd6: out = 8'b0100_0000;
            3'd7: out = 8'b1000_0000;
            default: out = 8'b0;
        endcase
    end
endmodule

module test;
    reg [2:0] sel;
    wire [7:0] out;
    decoder3 dut(.sel(sel), .out(out));

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            sel = i[2:0];
            #1 $display("sel=%0d out=%b", sel, out);
        end
        $finish;
    end
endmodule

Três coisas para notar:

• out é reg. Qualquer coisa atribuída dentro de always precisa ser reg. A palavra-chave não significa "isso é um flip-flop"; aqui significa apenas "sou escrito a partir de um bloco procedural".
• always @(*). O * diz "acorde sempre que qualquer coisa que eu leio mudar". O simulador automaticamente descobre a sensitivity list. Você pode escrever a lista manualmente - always @(sel) - mas @(*) é mais seguro porque omitir um sinal é uma fonte clássica de bugs.
• Sem clock. Este bloco descreve lógica combinacional. O sintetizador produz uma peça de lógica que calcula out a partir de sel diretamente - sem flip-flops, sem necessidade de pino de clock.

O caso default não é opcional no espírito mesmo sendo opcional na sintaxe. Omita-o e qualquer valor de entrada não especificado deixa out mantendo seu valor anterior - o que sintetiza para um latch não intencional. Sempre inclua o default.

Sequencial always @(posedge clk)

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

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

    counter4 dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t count=%0d", $time, count);
endmodule

As principais diferenças em relação à versão combinacional:

• always @(posedge clk). O bloco re-roda só na borda de subida de clk. Nada acontece entre bordas.
• Non-blocking assignment <=. Dentro de um bloco clocked, este é o operador certo. Ele diz "agende count para assumir seu novo valor no final do time step", que é exatamente como um flip-flop se comporta. O porquê e a alternativa estão em Blocking vs Non-blocking.
• Sem default necessário. O if cobre ambos os ramos (reset e não-reset). Sem risco de latch.

O sintetizador vê essa forma - sensitivity clocked, non-blocking assignment - e produz um register de 4 bits (quatro flip-flops) mais a lógica combinacional que calcula count + 1 e o mux que escolhe entre reset e incremento.

A distinção de síntese

O mesmo fonte de module pode descrever duas peças completamente diferentes de hardware dependendo da forma do bloco always:

Bloco	Hardware
always @(*) y = expr;	Lógica combinacional pura. Sem memória.
always @(posedge clk) y <= expr;	Flip-flop. Captura expr uma vez por ciclo de clock.
always @(*) if (en) y = expr;	Latch - geralmente um bug. O caso "else" mantém o valor antigo.
always @(posedge clk) if (en) y <= expr;	Flip-flop com enable. Captura só quando en é alto.

O terceiro caso é a armadilha do latch. Um latch é uma célula de memória transparente que mantém sua saída quando a entrada não é asserida - útil em designs específicos, quase sempre um bug quando acidental. A maioria das ferramentas de síntese avisa alto quando infere um latch que você não pediu. Trate o aviso como um erro.

Variantes de sensitivity list

Você verá algumas sensitivity lists menos comuns:

• always @(a or b or c) - lista explícita. Verilog-2001 adicionou o separador ,: always @(a, b, c). Qualquer um funciona.
• always @(posedge clk or negedge reset_n) - reset assíncrono. O bloco roda em uma borda de subida de clock ou uma borda de descida de reset. Usado quando reset precisa fazer efeito imediatamente, sem esperar o próximo clock.
• always @(negedge clk) - clocking na borda de descida. Raro; alguns designs o usam para flip-flops "negative-edge-triggered" que capturam na borda de descida em vez da subida.

Para designs novos, prefira always @(*) para combinacional e always @(posedge clk) para sequencial. Recorra a reset assíncrono só quando o design genuinamente precisar.

Dois blocos são duas peças de hardware

Múltiplos blocos always no mesmo module são independentes - cada um se torna sua própria peça de hardware:

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // sequencial
    output reg  [7:0] comb_out    // combinacional
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // inverte bitwise
    end
endmodule

module test;
    reg clk = 0, reset = 1;
    reg [7:0] in;
    wire [7:0] reg_out, comb_out;

    two_blocks dut(.clk(clk), .reset(reset), .in(in),
                   .reg_out(reg_out), .comb_out(comb_out));

    always #5 clk = ~clk;

    initial begin
        in = 8'h00; #12 reset = 0;
        in = 8'hA5; #10;
        in = 8'h3C; #10;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%h reg_out=%h comb_out=%h",
                 $time, in, reg_out, comb_out);
endmodule

O bloco clocked produz um register flip-flop. O bloco combinacional produz uma porta XOR. Vivem lado a lado; nenhum sabe do outro. As duas saídas mudam em cronogramas completamente diferentes.

O que blocos always não podem fazer

Algumas coisas que parecem tentadoras mas não são permitidas:

• Atribuir a um wire: o alvo precisa ser reg. Compilador faz cumprir.
• Atribuir ao mesmo reg a partir de dois blocos always diferentes: produz comportamento indefinido em simulação e não vai sintetizar. Um driver por sinal.
• Ler e escrever o mesmo sinal no mesmo bloco combinacional de uma forma que cria um loop de feedback: always @(*) x = x + 1; é um loop de delay zero que o simulador não consegue resolver.

Os dois primeiros o compilador pega. O terceiro às vezes só aparece em tempo de simulação como um hang.

O que vem a seguir

O próximo doc - Initial Block - cobre o irmão do always: um bloco que roda exatamente uma vez no início da simulação. É o burro de carga dos testbenches. Depois disso, as regras para blocking vs non-blocking assignment que decidem se seu bloco clocked faz o que você quis dizer.