Asignación continua en Verilog: la sentencia assign

assign describe una verdad permanente

Una declaración wire crea una señal. Un assign describe qué la excita. La relación es continua: lo que sea que esté en el lado derecho, el lado izquierdo es igual a ello, en cada instante de tiempo simulado:

wire y;
assign y = a & b;

Dos cosas implicadas por ese par de líneas:

• y existe como un wire en el circuito.
• y es en todo momento el AND bit a bit de a y b. Cambia cualquier entrada y y la sigue.

No hay reloj ni evento que dispare la actualización. El simulador ve que a o b cambian, marca y como sucio y vuelve a evaluar la expresión. En hardware esto mapea a un par de puertas AND: combinacional, sin estado, instantáneo.

La forma implícita

Puedes combinar la declaración y la asignación en una sola línea:

wire y = a & b;

Eso es lo mismo que las dos líneas de arriba. Útil para wires en línea que a nadie fuera de este ámbito le importan. Muchas guías de estilo prefieren la forma implícita porque pone la declaración justo al lado de la ecuación.

Qué puede excitar assign

El destino de assign debe ser un tipo net - en Verilog clásico, eso es wire (u otro de los primos más raros como tri, wand, wor). No puede ser un reg. Si declaras accidentalmente tu destino como reg:

reg y;
assign y = a & b;   // ERROR: cannot drive reg with assign

El compilador te lo dirá. O cambia el destino a wire, o mueve la lógica a un bloque always @(*) donde reg es el destino legal.

El lado derecho puede ser cualquier cosa que evalúe a un valor: literales, señales, parámetros, expresiones con operadores, llamadas a funciones. Puede mezclar varios anchos de entrada; se aplican las reglas estándar de ensanchamiento.

Cuándo usar assign vs always

Ambos pueden producir lógica combinacional. La elección es mayormente sobre cómo se lee el código:

• assign es mejor cuando la relación es una sola expresión. Sumadores, muxes simples construidos con ?:, máscaras, bits de paridad, cualquier cosa que puedas escribir en una línea.
• always @(*) es mejor cuando necesitas sentencias procedurales. Sentencias case multivía, if/else if anidados, cualquier cosa que se beneficie de regs intermedios con nombre. Cubrimos esto en Always Block.

Aquí está el mismo mux 4 a 1 escrito de las dos formas:

module mux_assign(
    input  wire [1:0]  sel,
    input  wire [3:0]  in0, in1, in2, in3,
    output wire [3:0]  out
);
    // Chain of conditional operators
    assign out = (sel == 2'd0) ? in0
               : (sel == 2'd1) ? in1
               : (sel == 2'd2) ? in2
               : in3;
endmodule

module mux_always(
    input  wire [1:0]  sel,
    input  wire [3:0]  in0, in1, in2, in3,
    output reg  [3:0]  out
);
    always @(*) begin
        case (sel)
            2'd0: out = in0;
            2'd1: out = in1;
            2'd2: out = in2;
            2'd3: out = in3;
            default: out = 4'bx;
        endcase
    end
endmodule

module test;
    reg [1:0] sel;
    wire [3:0] out_a, out_b;
    wire [3:0] in0 = 4'hA, in1 = 4'hB, in2 = 4'hC, in3 = 4'hD;

    mux_assign A(.sel(sel), .in0(in0), .in1(in1), .in2(in2), .in3(in3), .out(out_a));
    mux_always B(.sel(sel), .in0(in0), .in1(in1), .in2(in2), .in3(in3), .out(out_b));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            sel = i[1:0];
            #1 $display("sel=%b out_a=%h out_b=%h", sel, out_a, out_b);
        end
        $finish;
    end
endmodule

Los dos módulos sintetizan a esencialmente el mismo multiplexor. La versión con assign es una línea de código; la versión con always son seis. Para cuatro casos está cerca; para dieciséis casos el bloque case es claramente más fácil de leer.

Patrones comunes

Lógica combinacional plana

assign sum   = a + b;
assign carry = a[7] & b[7];
assign equal = (data == 8'hFF);

Una expresión, un wire. El pan y la mantequilla de assign.

Un mux 2 a 1

assign out = sel ? a : b;

Una única expresión condicional - el sintetizador la convierte en un único mux 2 a 1. La forma más limpia posible de "selecciona entre a y b".

Empaquetar bits

assign status = {error, overflow, ready, busy, 4'b0};

La concatenación en la derecha de un assign es cómo empaquetas flags en un byte de estado. El resultado se calcula y excita continuamente.

Salida tri-state

assign data_pin = output_enable ? data_out : 1'bz;

Cuando output_enable está en alto, excita el pin. Cuando está en bajo, libera a alta impedancia. Este es el patrón canónico en los pines del chip donde varios drivers podrían compartir un wire.

Concurrencia: varios assigns no son secuenciales

Un recordatorio que no dejará de ser relevante: varias sentencias assign en el mismo módulo todas corren en paralelo. No son una secuencia:

assign y = a & b;     // exists at all times
assign z = a | b;     // also exists at all times, independently

El orden en el archivo es irrelevante. Ambas ecuaciones son simultáneamente verdaderas. El sintetizador puede disponer la puerta AND a la izquierda de la OR o a la derecha; no importa, ambas puertas funcionan continuamente.

Si quieres comportamiento que parezca secuencial, estás recurriendo a un bloque always (y probablemente a un reloj). Eso es un capítulo distinto.

Múltiples drivers: el patrón del bus

Un wire puede tener más de un assign que lo apunte, pero casi nunca quieres esto excepto para buses tri-state. Dos drivers peleando por un wire produce comportamiento indefinido:

assign y = a;
assign y = b;   // BAD - two drivers, simulator picks one or x's it out

El patrón legítimo: cada driver libera a z cuando está inactivo, y a lo sumo uno está activo en cualquier momento.

assign bus = device_a_active ? data_from_a : 1'bz;
assign bus = device_b_active ? data_from_b : 1'bz;

Eso funciona porque en cualquier momento dado, a lo sumo uno de los dos ternarios produce un valor distinto de z. El valor real del wire es el del driver que no esté liberando.

En lógica interna - cualquier sitio que no sea un pin de chip o un bus on-chip compartido - un driver por wire. Los bugs de múltiples drivers son desagradables de depurar.

Qué no puede hacer assign

Algunas cosas para las que assign es la herramienta equivocada:

• Almacenamiento. assign describe relaciones combinacionales; no puede introducir un flip-flop. Si necesitas que un valor sea recordado entre ciclos de reloj, eso es un bloque always @(posedge clk).
• Lógica procedural de varios pasos. No puedes escribir if/else o case dentro de un assign. Lo más cercano que consigues es encadenar ?:, que se vuelve feo pasadas tres ramas.
• Excitar registros desde dentro de un bloque procedural. Los destinos reg necesitan asignación procedural, no assign.

Conocer los límites es cómo decides cuándo cambiar a always.

Qué viene a continuación

Ya has visto el lado estructural completo de Verilog: declarar módulos, instanciarlos y cablear lógica combinacional con assign. El siguiente capítulo entra en bloques procedurales - las construcciones initial y always donde el tiempo y la ordenación empiezan a importar.