Paso 15: VM 3.3: Cómo crear una instancia de un módulo
En el módulo anterior mencioné las similitudes entre instancias de módulos en Verilog y llamar a funciones en C y C++.Vamos a ver cómo se crean instancias de un módulo en Verilog.
Aquí es el módulo que vamos a trabajar con:
' calendario 1ns / 1ps
(módulo) srlatch
entrada S,
entrada R,
salida Q
);
alambre Q_int, Qn_int;
asignar Q_int = ~ (S & Qn_int);
asignar Qn_int = ~ (R & Q_int);
asignar Q = Q_int;
endmodule
Por ahora no debe ser cualquier Verilog en este módulo usted no podía explicar.
Así que vamos a decir que queríamos hacer un circuito con dos pestillos de SR (sin importar lo absurdo este circuito es en realidad), cada uno con un interruptor para su funcionamiento de "set" y un botón compartido. La salida de cada seguro será un LED.
Con estas especificaciones en mente, vamos a hacer la definición del módulo superior. Recuerde que las declaraciones de módulo superior contendrá sólo las entradas y salidas que van y vienen del mundo real.
' calendario 1ns / 1ps
Reto: Volver a escribir esta declaración de módulo utilizando autobuses
(superior) módulo
entrada switch0,
entrada switch1,
entrada btn0,
salida led0,
LED de salida 1
);
endmodule
¡ Excelente! Ahora tenemos que añadir dos SR-pestillos a nuestro circuito. ¿Cómo se hace?
No decir "duro código del comportamiento de dos SR-pestillos y asignar sus entradas y salidas respectivamente. Se crean instancias de dos instancias de un Latch SR. Aquí es cómo se verá nuestro módulo superior después de la creación de instancias:
' calendario 1ns / 1ps
(superior) módulo
entrada switch0,
entrada switch1,
entrada btn0,
salida led0,
LED de salida 1
);
(sr0) srlatch
. S(switch0),
. R(btn0),
. Q(led0)
);
(sr1) srlatch
. S(switch1),
. R(btn0),
. Q(LED1)
);
endmodule
¿Así que lo que queda hacer? Nada; absolutamente nada (suponiendo que ya tienes un archivo UCF listo). ¿Por qué?
La razón radica en la creación de instancias de módulo. Echemos un vistazo a uno.
(sr0) srlatch
. S(switch0),
. R(btn0),
. Q(led0)
);
Primera línea: srlatch sr0 (
Esta es una línea muy importante cuya forma necesita comprometerse a la memoria. Primero viene srlatch. Este es el nombre del base módulo que estamos creando una instancia. sr0 es el nombre de instancia. El paréntesis abre a la creación de instancias. Cada creación de instancias se iniciará. "< módulo a ser instanciada >< nombre de instancia >(".
Hay algunos casos menos comunes donde instanciación se diferencia ligeramente, pero aún así este formulario todavía estará presente.
Las siguientes tres líneas:
. S(switch0),
. R(btn0),
. Q(led0)
Echa un vistazo a lo srlatch nombres de puerto de módulo y luego mirar hacia atrás en estas tres líneas. Esto es, de una manera indirecta, similar a cómo se llame a una función en C y C++; Esto es donde pasan los parámetros.
La diferencia es que en Verilog estamos pasando ambas entradas al módulo de salidas y al módulo. Es decir, le estamos diciendo a esa instancia específica del módulo de donde provienen las entradas y donde queremos las salidas para ir.
Otra manera de mirar esto es que estamos pasando el módulo de un conjunto de entradas y salidas, cada uno cuyo valor es continuamente actualizado ya sea desde dentro del módulo (salidas) o fuera del módulo (entradas).
Desglosemos la instrucción: . S(switch0)
La creación de instancias de cada módulo tendrá una serie de declaraciones similares a esta declaración, uno por entrada/salida. El ". S"se refiere a la entrada de S en el módulo de srlatch, y el (switch0) se refiere a entrada switch0 situado en el módulo superior. ¿Ver un patrón?
. < nombre del puerto en módulo de instancia > (< nombre del puerto en el módulo actual >)
Este concepto también es similar a llamar a funciones en otros lenguajes de programación como C y C++; en la llamada de función pasamos valores (que conocemos por el nombre de la variable) en la función. Llamamos a este algo de valor, por ejemplo, principal, pero en la función se llama algo diferente. En este ejemplo de Verilog, tenemos una entrada en el módulo superior llamado "swtich0", y queremos que el valor de "S" de "sr0" igual a cualquier "switch0" es.
Como he mencionado antes, usted necesita una declaración de la inicialización del puerto por puerto en el módulo son instancias, pero si son instancias de un módulo que tiene, digamos, un autobús [7:0] llamado "T" de entrada, no necesitas hacer 8 declaraciones como ". T[0](Input[0]) ". Puede pasar todos buses haciendo referencia a los nombres solamente, por lo que podría pasar "Entrada" a "T"declarando". T(INPUT) ". Tenga en cuenta sin embargo que deben coincidir con dimensiones de autobús para arriba (es decir, no se puede pasar un bus de 5 puerto en un módulo que tiene un bus de 3 Puerto).
Además, tipos de puertos deben coincidir. Sólo puede pasar una entrada a una entrada y una salida (o un alambre; más sobre esto más adelante) a una salida.
Declaraciones de inicialización puerto separado con una sola coma. Buen estilo de codificación exige que cada línea contiene sólo una creación de instancias. De esto debe ser capaz de comprender esas tres líneas de código.
Cerca de la creación de instancias con un correspondiente paréntesis y un punto y coma.
Después de la creación de instancias con éxito, las salidas del módulo de instancia, en esencia, será accesibles dentro del módulo actual. Luego puede dirigir estas salidas a puertos de nivel superior o incluso las entradas de otros módulos de instanciadas.
Antes de finalizar esta discusión, vamos a resumir cómo iniciar un módulo (recordar que "módulo actual" se refiere al módulo que está haciendo la creación de instancias):
< nombre del módulo >< (nombre de instancia >
. < nombre del puerto en el módulo a ser instanciada > (< nombre del puerto/alambre módulo actual >),
... < repetición arriba tantas veces como sea necesario >...
. < nombre del puerto en el módulo a ser instanciada > (< nombre del puerto/alambre módulo actual >)
);
