Non Blocking Assignment

Parte da seção Fundamentos do Journey de Verilog da Coddy. Lição 50 de 90.

Na lição anterior, abordamos a atribuição blocking (=), que é executada passo a passo. Agora abordaremos a atribuição non-blocking (<=), que é executada toda de uma vez, em paralelo.

A atribuição non-blocking usa o operador <=. Ela é chamada de "non-blocking" porque não bloqueia a execução da próxima instrução. Todas as atribuições non-blocking em um bloco são executadas ao mesmo tempo.

Sintaxe:

variable <= expression;

Quando Usar Atribuição Non-Blocking

A atribuição Non-Blocking (<=) é usada para lógica sequencial: circuitos que usam um clock e têm memória. As saídas mudam somente em uma borda de clock (geralmente a borda de subida).

Exemplos de lógica sequencial:

Flip-flops
Registradores
Contadores

Máquinas de estados
Registradores de deslocamento

Exemplo de Verilog:

initial begin
  a <= 5;      // Agendado, mas ainda não executado
  b <= a + 2;  // Agendado, usa o valor ANTIGO de a
  c <= b * 3;  // Agendado, usa o valor ANTIGO de b
end

All as três atribuições acontecem ao mesmo tempo usando os old values. No end da etapa de tempo, all atualizações acontecem juntas.

Não bloqueante em blocos always (lógica sequencial)

Não bloqueante é usado para lógica sequencial: circuitos que usam um clock e têm memória (flip-flops, registradores, contadores).

always @(posedge clk) begin
  q <= d;           // q recebe d na borda do clock
  count <= count + 1; // count incrementa na borda do clock
end

Ambas as atribuições acontecem ao mesmo tempo, usando valores de antes da borda de clock.

Resumo

Regra	Explicação
Use `<=` para lógica sequencial	`always @(posedge clk)`
Use `=` para lógica combinacional	`always @(*)`
Non-blocking é executado em paralelo	All atribuições acontecem de uma só vez
Values são atualizados no end da etapa de tempo	Não imediatamente

Desafio

Conclua a atribuição non-blocking

Add as atribuições non-blocking ausentes para fazer este registrador de deslocamento de 2 bits funcionar.

Como funciona:

A cada edge de clock, q1 gets d
q2 gets o valor old de q1

O que fazer:

Assign d a q1 (non-blocking)
Assign q1 a q2 (non-blocking)

Experimente você mesmo

module shift_register (
  input clk,
  input reset,
  input d,
  output reg q1,
  output reg q2
);
  
  always @(posedge clk or posedge reset) begin
    if (reset) begin
      q1 <= 0;
      q2 <= 0;
    end else begin
      // TODO: Adicionar lógica de deslocamento
      // Passo 1: Atribuir d a q1 (non-blocking)
      // Passo 2: Atribuir q1 a q2 (non-blocking)
    end
  end
endmodule