Palabras clave: control de retardo, disparo por eventos, disparo por flanco, disparo por nivel

Verilog proporciona 2 grandes tipos de métodos de control de temporización: control de retardo y control de eventos. El control de eventos se divide principalmente en control de eventos por disparo de flanco y control de eventos sensible al nivel.

Control de retardo

El control de temporización basado en retardo aparece en las expresiones; especifica el intervalo de tiempo entre el inicio y la finalización de la ejecución de una sentencia.

El retardo puede ser un número, un identificador o una expresión.

Según la posición en la expresión, el control de retardo se puede dividir en retardo normal y retardo integrado.

Retardo normal

Cuando se encuentra un retardo normal, la sentencia debe esperar un cierto tiempo y luego asigna el resultado del cálculo a la señal de destino.

El formato es: #delay procedural_statement, por ejemplo:

reg  value_test ;
reg  value_general ;
#10  value_general    = value_test ;

Otra forma de escribir este tipo de retardo es usar directamente el signo de número (almohadilla)#como una sentencia de ejecución de retardo independiente, por ejemplo:

#10 ;
value_ single         = value_test ;

Retardo integrado

Cuando se encuentra un retardo integrado, la sentencia primero guarda el resultado del cálculo, luego espera un cierto tiempo y lo asigna a la señal de destino.

El control de retardo integrado se coloca después del signo de asignación. Por ejemplo:

reg  value_test ;
reg  value_embed ;
value_embed        = #10 value_test ;

Cabe señalar que los efectos de estos 2 métodos de control de retardo son diferentes.

Cuando el lado derecho del signo de asignación de la sentencia de retardo es una constante, ambos métodos de control de retardo pueden lograr el mismo efecto de asignación con retardo.

Cuando el lado derecho del signo de asignación de la sentencia de retardo es una variable, los dos métodos de control de retardo pueden producir efectos de asignación con retardo diferentes.

Por ejemplo, el siguiente código de simulación:

Ejemplo

`timescale 1ns/1ns
 
module test ;
    reg  value_test ;
    reg  value_general, value_embed, value_single ;
 
    //signal source
    initial begin
        value_test        = 0 ;
        #25 ;      value_test        = 1 ;
        #35 ;      value_test        = 0 ;        //absolute 60ns
        #40 ;      value_test        = 1 ;        //absolute 100ns
        #10 ;      value_test        = 0 ;        //absolute 110ns
    end
 
    //(1)general delay control
    initial begin
        value_general     = 1;
        #10 value_general  = value_test ; //10ns, value_test=0
        #45 value_general  = value_test ; //55ns, value_test=1
        #30 value_general  = value_test ; //85ns, value_test=0
        #20 value_general  = value_test ; //105ns, value_test=1
    end
 
    //(2)embedded delay control
    initial begin
        value_embed       = 1;
        value_embed  = #10 value_test ; //0ns, value_test=0
        value_embed  = #45 value_test ; //10ns, value_test=0
        value_embed  = #30 value_test ; //55ns, value_test=1
        value_embed  = #20 value_test ; //85ns, value_test=0
    end
 
    //(3)single delay control
    initial begin
        value_single      = 1;
        #10 ;
        value_single = value_test ; //10ns, value_test=0
        #45 ;
        value_single = value_test ; //55ns, value_test=1
        #30 ;
        value_single = value_test ; //85ns, value_test=0
        #20 ;
        value_single = value_test ; //105ns, value_test=1
    end
 
    always begin
        #10;
        if ($time >= 150) begin
            $finish ;
        end
    end
 
endmodule

Los resultados de la simulación son los siguientes; se puede observar en la figura:

  • (1) Los resultados de la ejecución de las dos formas de expresión del retardo normal son consistentes.
  • (2) Método de asignación con retardo normal: tras encontrar la sentencia de retardo, primero se retrasa un cierto tiempo y luego se asigna el operando actual a la señal de destino; no tiene la característica de 'retardo inercial' y no omitirá pulsos relativamente estrechos.
  • (3) Método de asignación con retardo integrado: tras encontrar la sentencia de retardo, primero se calcula el resultado del lado derecho de la expresión, luego se retrasa un cierto tiempo y se asigna a la señal de destino.

A continuación se analiza el proceso de asignación con retardo integrado:

value_embed  = #10 value_test ; //0ns, value_test=0

En el tiempo 0ns, se ejecuta esta sentencia de retardo.

Primero se asigna 0 a la señal value_embed; tras un retardo de 10ns, la salida es 0;

value_embed  = #45 value_test ; //10ns, value_test=0

En el tiempo 10ns, se ejecuta esta sentencia de retardo.

Dado que en este momento value_test sigue siendo 0, el valor de value_embed no cambia.

Es decir, hasta el tiempo 55ns, el valor de value_embed permanece en 0.

value_embed  = #30 value_test ; //55ns, value_test=1

De manera similar, en el tiempo 55ns, el valor de value_test es 1, se asigna a value_embed y se retrasa 30ns para la salida.

Por lo tanto, en el tiempo 85ns, value_embed emite 1.

value_embed  = #20 value_test ; //85ns, value_test=0

De manera similar, en el tiempo 105ns, value_embed emite 0.

Control de eventos por disparo de flanco

En Verilog, un evento se refiere al cambio de valor de una variable de tipo reg o wire.

El control de temporización basado en disparo por eventos se divide principalmente en los siguientes tipos.

Control de eventos general

El control de eventos utiliza el símbolo@para representarlo.

La condición para que se ejecute la sentencia es que el valor de la señal experimente un cambio específico.

La palabra clave posedge indica que la señal experimenta una transición de flanco positivo; negedge indica que la señal experimenta una transición de flanco negativo. Cuando no se especifica la dirección de la transición, ambos tipos de cambios de flanco disparan el evento correspondiente. Por ejemplo:

Ejemplo

// Si la señal clk cambia en cualquier flanco, se ejecuta q<=d; modelo de flip-flop D de doble flanco
always @(clk) q <= d ;                
// En el flanco de subida de la señal clk, se ejecuta q<=d; modelo de flip-flop D de flanco positivo
always @(posedge clk) q <= d ;  
// En el flanco de bajada de la señal clk, se ejecuta q<=d; modelo de flip-flop D de flanco negativo
always @(negedge clk) q <= d ;
// Se calcula el valor de d inmediatamente y se asigna a q en el flanco de subida de clk; no se recomienda esta forma
q = @(posedge clk) d ;      

Control de eventos nombrados

El usuario puede declarar una variable de tipo event (evento) y dispararla para detectar si el evento ocurre. Los eventos nombrados se declaran con la palabra clave event; la señal de disparo se representa con->se representa. Por ejemplo:

Ejemplo

event     start_receiving ;
always @( posedge clk_samp) begin
        -> start_receiving ;       // El flanco de subida del reloj de muestreo como momento de disparo
end
 
always @(start_receiving) begin
    data_buf = {data_if[0], data_if[1]} ; // En el momento de disparo, se integran los datos multidimensionales
end

Lista de sensibilidad

Cuando el cambio de cualquiera de varias señales o eventos puede disparar la ejecución de una sentencia, Verilog utiliza la expresión 'or' para describir esta situación, con la palabra claveorpara conectar múltiples eventos o señales. La lista formada por estos eventos o señales se llama 'lista de sensibilidad'. Por supuesto, or también puede reemplazarse por una coma,en su lugar. Por ejemplo:

Ejemplo

// Modelo de flip-flop D con reset activo en bajo
always @(posedge clk or negedge rstn)    begin      
//always @(posedge clk , negedge rstn)    begin      
// También se pueden listar múltiples eventos de disparo usando comas
    if(! rstn)begin
        q <= 1'b ;      
    end
    else begin
        q <= d ;
    end
end

Cuando hay muchas variables de entrada en lógica combinacional, escribir la lista de sensibilidad resulta tedioso. En este caso, una forma más concisa es@*o@(*), lo que indica que es sensible a los cambios de todas las variables de entrada en el bloque de sentencias. Por ejemplo:

Ejemplo

always @(*) begin
//always @(a, b, c, d, e, f, g, h, i, j, k, l, m) begin
// Las dos formas son equivalentes
    assign s = a? b+c : d ? e+f : g ? h+i : j ? k+l : m ;
end

Control de eventos sensible al nivel

El control de eventos discutido anteriormente requiere esperar un cambio en el valor de la señal o el disparo de un evento, y se representa utilizando@+lista de sensibilidadde la manera indicada.

Verilog también admite el uso de nivel como señal sensible para controlar la temporización, es decir, la ejecución de las sentencias posteriores debe esperar a que una condición sea verdadera. Verilog utiliza la palabra clave wait para representar esta situación sensible al nivel. Por ejemplo:

Ejemplo

initial begin
    wait (start_enable) ;      // Esperar la señal start
    forever begin
        // Después de que la señal start se active, en el flanco de subida de clk_samp, se integran los datos
        @(posedge clk_samp)  ;
        data_buf = {data_if[0], data_if[1]} ;      
    end
end

Descarga del código fuente

Download