Palabras clave: módulo, puerto, puerto bidireccional, PAD

Hay 3 tipos de declaraciones descriptivas en el modelado estructural: declaraciones de instanciación Gate (a nivel de compuerta), declaraciones de instanciación UDP (primitivas definidas por el usuario) y declaraciones de instanciación module (módulo). Esta sección se centra principalmente en las declaraciones de instanciación a nivel de módulo, que son las más utilizadas.

Módulo

Un módulo es la forma de definición de unidades básicas en Verilog y es la interfaz para interactuar con el exterior.

El formato de definición del módulo es el siguiente:

module module_name 
#(parameter_list)
(port_list) ;
              Declarations_and_Statements ;
endmodule

La definición de un módulo debe comenzar con la palabra clave `module` y terminar con la palabra clave `endmodule`.

El nombre del módulo, las señales de puerto, las declaraciones de puerto y las declaraciones de parámetros opcionales, entre otros, aparecen antes de las declaraciones Verilog utilizadas en el diseño (`Declarations_and_Statements` en la figura).

El interior de un módulo tiene 5 partes opcionales: declaraciones de variables, sentencias de flujo de datos, sentencias de nivel de comportamiento, instanciación de módulos de nivel inferior, y tareas y funciones, como se muestra en la figura siguiente. El orden y la posición de estas 5 partes son arbitrarios. Sin embargo, todas las variables deben declararse antes de su uso. No se exige una posición específica para la declaración de variables, pero se debe garantizar que estén antes de su uso.

La mayoría de los códigos de simulación anteriores utilizan declaraciones `module`. Pueden consultarlos por su cuenta; aquí no se darán ejemplos específicos. Cuando se presenten los puertos a continuación, se realizarán simulaciones detalladas.

Puerto

El puerto es la interfaz entre el módulo y el mundo exterior. Para el entorno externo, el interior del módulo es invisible, y la invocación del módulo solo puede realizarse mediante conexiones a través de los puertos.

Lista de puertos

La definición de un módulo incluye una lista de puertos opcional. Generalmente, las variables de señal sin tipo y sin ancho de bit se enumeran en la declaración del módulo. A continuación se muestra una lista de puertos de un modelo PAD:

module pad(
    DIN, OEN, PULL,
    DOUT, PAD);

Si un módulo no interactúa con el entorno externo, no es necesario declarar una lista de puertos. Por ejemplo, en las simulaciones anteriores, el módulo `test` en el archivo `test.sv` no declaraba puertos específicos.

module test ;  //直接分号结束
    ......     //数据流或行为级描述
endmodule

Declaración de puertos

(1) Una vez que las señales de puerto se enumeran en la lista de puertos, pueden declararse en el cuerpo del módulo.

Según la dirección del puerto, hay 3 tipos de puertos: entrada (`input`), salida (`output`) y puerto bidireccional (`inout`).

Los tipos `input` e `inout` no pueden declararse como tipo de datos `reg`, porque el tipo `reg` se utiliza para almacenar valores, mientras que los puertos de entrada solo reflejan los cambios de las señales externas conectadas a ellos y no pueden almacenar los valores de dichas señales.

`output` puede declararse como tipo de datos `wire` o `reg`.

En el ejemplo anterior, la declaración de puertos del módulo `pad` puede expresarse en el cuerpo del `module` de la siguiente manera:

Ejemplo

// Declaración del tipo de puerto
input        DIN, OEN ;
input [1:0]  PULL ;  //(00,01-dispull, 11-pullup, 10-pulldown)
inout        PAD ;   //pad value
output       DOUT ;  //pad load when pad configured as input

// Declaración del tipo de datos del puerto
wire         DIN, OEN ;
wire  [1:0]  PULL ;
wire         PAD ;
reg          DOUT ;

(2) En Verilog, los puertos se declaran implícitamente como variables de tipo `wire`. Es decir, cuando un puerto tiene atributo `wire`, no es necesario declarar nuevamente el tipo de puerto como `wire`. Sin embargo, cuando el puerto tiene atributo `reg`, la declaración `reg` no puede omitirse.

La declaración de puertos del ejemplo anterior puede simplificarse como:

Ejemplo

// Declaración del tipo de puerto
input        DIN, OEN ;
input [1:0]  PULL ;    
inout        PAD ;    
output       DOUT ;    
reg          DOUT ;

(3) Por supuesto, la declaración de la señal `DOUT` puede combinarse completamente en una sola línea:

output reg      DOUT ;

(4) Hay otro método más conciso y común para declarar puertos, que consiste en enumerar los puertos y sus tipos en la declaración del `module`. Los puertos de tipo `reg` deben declararse ya sea en la declaración del `module` o en el cuerpo del `module`; por ejemplo, las siguientes 2 formas son equivalentes.

Ejemplo

module pad(
    input        DIN, OEN ,
    input [1:0]  PULL ,
    inout        PAD ,
    output reg   DOUT
    );
 
module pad(
    input        DIN, OEN ,
    input [1:0]  PULL ,
    inout        PAD ,
    output       DOUT
    );
 
    reg        DOUT ;

Simulación de puerto inout

Simule el modelo `pad` que contiene un puerto de tipo `inout`. El código completo del modelo `pad` es el siguiente:

Ejemplo

module pad(
    //DIN, pad driver when pad configured as output
    //OEN, pad direction(1-input, o-output)
    input        DIN, OEN ,
    //pull function (00,01-dispull, 10-pullup, 11-pulldown)
    input [1:0]  PULL ,
    inout        PAD ,
    //pad load when pad configured as input
    output reg   DOUT
    );
 
    //input:(not effect pad external input logic), output: DIN->PAD
    assign       PAD = OEN? 'bz : DIN ;
 
    //input:(PAD->DOUT)
    always @(*) begin
        if (OEN == 1) begin //input
            DOUT   = PAD ;
        end
        else begin
            DOUT   = 'bz ;
        end
    end
 
    //use tristate gate in Verilog to realize pull up/down function
    bufif1  puller(PAD, PULL[0], PULL[1]);
 
endmodule

El código del testbench es el siguiente:

Ejemplo

`timescale 1ns/1ns
 
module test ;
    reg          DIN, OEN ;
    reg [1:0]    PULL ;
    wire         PAD ;
    wire         DOUT ;
 
    reg          PAD_REG ;
    assign       PAD = OEN ? PAD_REG : 1'bz ; //
 
    initial begin
        PAD_REG   = 1'bz ;        //pad with no dirve at first
        OEN       = 1'b1 ;        //input simulation
        #0 ;      PULL      = 2'b10 ;   //pull down
        #20 ;     PULL      = 2'b11 ;   //pull up
        #20 ;     PULL      = 2'b00 ;   //dispull
        #20 ;     PAD_REG   = 1'b0 ;
        #20 ;     PAD_REG   = 1'b1 ;
 
        #30 ;     OEN       = 1'b0 ;    //output simulation
                  DIN       = 1'bz ;
        #15 ;     DIN       = 1'b0 ;
        #15 ;     DIN       = 1'b1 ;
    end
 
    pad     u_pad(
        .DIN     (DIN) ,
        .OEN     (OEN) ,
        .PULL    (PULL) ,
        .PAD     (PAD) ,
        .DOUT    (DOUT)
    );
 
    initial begin
        forever begin
            #100;
            if ($time >= 1000)  $finish ;
        end
    end
 
endmodule // test

Los resultados de la simulación son los siguientes:

El análisis de los resultados de la simulación es el siguiente:

Cuando la dirección de PAD es `input` y no hay controlador, la función `pull` se refleja a través del valor de PAD.

Dentro de los primeros 60ns, el extremo de controlador PAD_REG de PAD es `z`, por lo que se puede considerar que no hay controlador. Así, al inicio `PULL=2`, pull-down, el valor de PAD es 0; en 20ns, `PULL=3`, pull-up, el valor de PAD es 1;

En 40ns, `PULL=0`, no hay función `pull`, y el valor de entrada de PAD es `z`.

Después de 60ns~100ns, el extremo de controlador PAD_REG de PAD comienza a conducir normalmente. En este momento, equivale a que PAD esté directamente conectado a PAD_REG, por lo que el valor de PAD se mantiene consistente con su valor de controlador.

En el análisis anterior, la dirección de PAD es siempre `input`, y todas las salidas `DOUT` se mantienen consistentes con el valor de PAD.

Cuando la dirección de PAD es `output`, es decir, en 120ns `OEN=0`, el valor de PAD se mantiene consistente con el valor de entrada `DIN`.

Descarga del código fuente

Download