BLOQUE 2 TEMA 3: Verilog

BLOQUE 2
TEMA 3: Verilog
3.1
3.2
3.3
3.4
Introducción
Estructura
Estilos de Descripción
Modelado Estructural
Instanciado de Módulos
Primitivas
Primitivas Definidas por el Usuario
3.5 Tipos de Datos y Operadores
3.6 Modelado de Comportamiento
Asignamientos
Control de Temporización
Control de Flujo de Actividad
Funciones y Tareas
3.7 Máquinas de Estado Finito
Smith “Application-Specific Integrated Circuits”
M- D. Ciletti, “Modeling, Synthesis and Rapid Prototyping with the Verilog HDL”
Verilog
HDSE
INTRODUCCIÖN
P La compañía Gateway Design Automation desarrolló Verilog como un lenguaje de
simulación.
P En 1989 Cadence compró Gateway y en 1990 puso Verilog en dominio público.
P Posteriormente se desarrollo Verilog como un standard del IEEE
P Verilog es un lenguaje tipo C
P Verilog permite describir diseños a distintos niveles de abstracción
q nivel algoritmo (similar a un código C con construcciones if, case y loops)
q nivel transferencia de registros (usa registros conectados por ecuaciones booleanas)
q nivel de puertas (interconexión de puertas)
q nivel de conmutadores (los conmutadores son los transistores MOS que implementan las puertas lógicas)
P Verilog define construcciones para controlar la entrada y la salida de la simulación
P herramientas de síntesis lógica no soportan todas las construcciones de Verilog
Verilog
HDSE
INTRODUCCIÖN
‘timescale 1ns/1ns
/* directiva de compilación (‘), define la unidad de tiempo y la precisión para el
simulador. Un HDL tiene implícita una semántica de tiempos asociada a sus
objetos (señales) porque modela su evolución */
// modela una caja negra que contiene un reloj de 50MHz y cuenta de 0 a 7
// declara tipo de dato reg para el reloj (clock)
// declara tipo de dato entero para el contador
// inicializa, se ejecuta una vez al comienzo
module contador;
reg clock;
integer count;
initial
begin
clock = 0; count = 0; // inicializa señales
#340 $finish;
// finaliza tras 340 unidades de tiempo, Función-tarea del sistema ($)
end
always
// sentencia always para generar el reloj, se ejecuta siempre
#10 clock = ~ clock;
always
// sentencia always para la cuenta, concurrente con la otra sentencia always
begin
@ (negedge clock); // espera hasta que clock pasa de 1 a 0
if (count == 7) count = 0;
else
count = count + 1;
$display(“time = “, $time, “ count = “, count);
end
endmodule
Verilog
HDSE
INTRODUCCIÖN
‘timescale 1ns/1ns
module contador;
reg clock;
integer count;
salida del simulador VERILOG-XL
...........
time =
20 count =
time =
40 count =
...................................
time =
300 count =
time =
320 count =
...........
initial
begin
clock = 0; count = 0;
#340 $finish;
end
always
#10 clcock = ~ clock;
always
begin
@ (negedge clock);
if (count == 7)
count = 0;
else
count = count + 1;
$display(“time = “, $time, “ count = “, count);
end
endmodule
Verilog
1
2
7
0
HDSE
ESTRUCTURA
P el module es la entidad de diseño principal en verilog
P el module representa un bloque hardware: desde puertas simples hasta un sistema completo
P la descripción de cada module puede ser
q comportamiento: usando construcciones de lenguajes de programación: if, asignaciones...
q estructural: interconexión jerárquica de submódulos. En el nivel más bajo de la jerarquía
las componentes deben ser primitivas de verilog o especificarse tipo comportamiento
P un sistema digital puede definirse como un conjunto de modules
P Sintaxis
module nombre_modulo (lista_de_terminales); // especifica nombre y terminales (puertos)
input [msb:lsb] lista_terminales_entrada;
// especifica tipo y número de bits de cada terminal
output [msb:lsb] lista_terminales_salida;
inout [msb:lsb] lista_terminales_bidireccionales;
.......... <module_items> .........
// comportamiento o instanciado de otros modules
endmodule
suma
datoa
8
datob
Verilog
out
8
module suma_resta(suma, datoa, datob, out);
input suma;
//por defecto wire
input [7:0] datoa, datob; wire datoa, datob;
output [7:0] out; reg out;
....................sentencias ...................
endmodule
HDSE
ESTILOS DE DESCRIPCIÓN
Estructural / Comportamiento
/* modelo estructural de una and construida
con dos nands*/
module MIAND(in1, in2, out);
input in1, in2;
output out;
wire w1;
// dos instancias del module nand
NAND NAND1(in1, in2, w1);
NAND NAND2(w1,. w1, out);
endmodule
// modelo comportamiento de una puerta nand
module NAND(in1, in2, out);
input in1, in2;
output out;
// sentencia de asignamiento continuo
assign out = ~(in1 & in2);
endmodule
Verilog
in1
in2
w1
&
&
out
P los terminales (puertos) permiten interconectar modules
P los nombres de los puertos cuando se
conectan pueden ser distintos al nombre de la declaración del module
P asignamiento continúo
asigna un valor a un wire
se ejecutan continuamente
similar a una puerta real conectada al cable
son concurrentes
HDSE
ESTILOS DE DESCRIPCIÓN
Comportamiento: Flujo de datos / Algoritmo
/* modelo comportamiento RTL o flujo de
datos*/
module suma_4_RTL(a, b, c_in, sum, c_out);
input [3:0] a, b;
input
c_in;
output [3:0] sum;
output
c_out;
// asignamiento continuo
assign {c_out, sum} = a + b + c_in;
endmodule
// modelo comportamiento: flujo de datos o RTL
module comp_RTL (menor, mayor, igual, A1, A0,
B1, B0);
input A1, A0, B1, B0;
output menor, mayor, igual;
assign menor = ({A1,A0} < {B1, B0});
assign mayor = ({A1,A0} >{B1, B0});
assign igual = ({A1,A0} == {B1, B0});
endmodule
Verilog
// modelo comportamiento: algoritmos
module comp_algo (menor, mayor, igual, A, B);
input [1:0] A, B;
output menor, mayor, igual;
reg menor, mayor, igual;
always @ (A or B)
begin
menor=0;
mayor = 0;
igual = 0;
if (A==B) igual=1;
else if (A > B) mayor = 1;
else menor = 1;
end
endmodule
P el tipo de dato reg retiene su valor hasta que
se hace otro asignamiento
HDSE
ESTILOS DE DESCRIPCIÓN
Comportamiento: Algoritmo i
// modelo comportamiento: algoritmo
// asigna valores a reg en sentencias procedurales
// el comportamiento implementado puede ser combinacional o secuencial
module comp_algo (menor, mayor, igual, A, B); // describe un comparador de dos bits
input [1:0] A, B;
output menor, mayor, igual;
reg menor, mayor, igual;
always @ (A or B) // procedimiento always su bloque secuencial asociado se ejecuta
// siempre que en A o B ocurra un evento
begin
// comienza el bloque secuencial. La lista de sentencias procedurales
// hasta el end se ejecuta secuencialmente
menor = 0;
mayor = 0;
igual = 0;
if (A == B) igual = 1;
else if (A > B) mayor = 1;
else menor = 1;
end
// termina el bloque secuencial
endmodule
Verilog
HDSE
ESTILOS DE DESCRIPCIÓN
Comportamiento: Algoritmo ii
module and4_algo (x_in, y_out); // puerta and de 4 entradas
input [3:0] x_in;
output
y_out;
reg y_out;
integer k;
always @ (x_in) // procedimiento always. Se ejecuta si cambia una o más entradas
begin: and_loop
//bloque secuencial con etiqueta
y_out = 1;
for (k = 0; k <= 3; k = k + 1)
if(x_in[k] == 0)
begin
y_out = 0;
disable and_loop; // evita analizar las restantes entradas
end
end
endmodule
Verilog
HDSE
MODELADO ESTRUCTURAL
Instanciado de Modules
P las declaraciones de módulos son “plantillas” (“templates”) a partir de los cuales se
crean las instancias
P los módulos se instancian dentro de otros módulos
P la excepción es el módulo del nivel más alto que es su propia instancia
P no se pueden instanciar modules en procedimientos
sintaxis
module_name
instance_name_1 (lista_conexiones_terminales),
instance_name_2 (lista_conexiones_terminales);
wire [3:0] in1, in2;
wire [3:0] o1, o2;
// C1 es una instancia del module and4
// los términales de C1 referenciados por posición
and4 C1(in1, in2, o1);
// C2 es otra instancia del modulo and4
// los terminales de C2 referenciados por nombre
// DEFINICIÖN DEL MÓDULO
module and4(a, b, c);
input [3:0] a, b;
output [3:0] c;
assign c=a&b;
endmodule
and4 C2(.c(o2), .a(in1), .b(in2));
Verilog
HDSE
MODELADO ESTRUCTURAL
Módulos Parametrizables
P los parámetros permiten que una constante se pueda utilizar simbólicamente
P se pueden definir módulos parametrizables y especificar el valor del parámetro para cada
instancia
P sintaxis parámetros
parameter par_1 = valor,
par_2= valor, .......;
parameter [range] par_3=valor;
parameter n=4;
/* registro de cuatro bits cuya longitud
se fija con el parámetro n */
reg [n-1:0] out;
P instanciado módulos parametrizables
module_name #(valores_parámetros)
instance_name_1 (lista_conexiones_terminales);
Verilog
// DEFINICIÓN MODULO
module despl_n(it, ot);
input [7:0] it;
output [7:0] ot;
// el valor por defecto de n es 2
parameter n=2;
// desplaza it a la izquierda n veces
assign ot = (it << n);
endmodule
// INSTANCIADO
wire [7:0] in1, ot1, ot2, ot3;
despl_n
c1(in1, ot1),// n=2
#(3) c2(in1, ot2),// n= 3
#(5) c3(in1, ot3);// n = 5
HDSE
MODELADO ESTRUCTURAL
Primitivas
P
P
puertas lógicas que son parte del lenguaje verilog
se pueden especificar retraso y fuerza lógica
q Puertas básicas: una salida
GATE: and, nand, or, nor, xor, xnor
GATE (fuerza_logica) #(retrasos)
nonbre_instancia_1(out1, in1,....inN);
q Buffers e Inversores
GATE: buf o not
GATE (fuerza_logica) #(retrasos)
nombre_instancia_1(out1, ..., outN, in);
retrasos es:
#(subida, bajada) ó
#subida_y_bajada ó
#(subida_y_bajada)
not #(4) not_1(a, c);
buf c1(o, p, q, r, in);
c2(l, m, in);
and c1(o, a, b, c, d);// cuatro entradas
c2(p, f, g);//dos entradas
or #(4,3) c3(s, a, b);//subida, bajada
xor #(5) c4(m, c, d);
// no es obligatorio usar identificadores
// cuando se instancian primitivas
xor #2.2 (o1, a, b);
q Puertas tri-estado
GATE puede ser bufif1, bufif0, notif1, notif0
// bus = a 5 unidades de tiempo después de que ctrl
//se ponga a 0
bufif0 #(5) c1(bus, a, ctrl);
Verilog
HDSE
MODELADO ESTRUCTURAL
Primitivas Definidas por el Usuario i
P se especifican usando una tabla de verdad.
P el primer puerto debe ser el único puerto de salida.
P No se pueden usar vectores ni puertos bidireccionales
primitive sumador(Sum, a,b);
output Sum; input a, b;
table
//entradas : salida
0 0 : 0 ;//orden entr. = orden termi.
01:1;
10:1;
11:0;
endtable
endprimitive
Verilog
primitive Dlatch(Q, CLK, D);
output Q; reg Q; input CLK, D;
table
//entrada : estado presente : salida (prox. estado)
1 0 : ? : 0 ; // ? Es un 0, 1 o x
1 1 : b : 1 ; // b Es un 0, 1
1 1 : x : 1 ; // x valor lógico desconocido
0 ? : ? : - ; // - La salida no cambia.
/*puede añadirse lo siguiente para reducir pesimismo en simulación */
// x 0 : 0 : -;
// x 1 : 1 : -;
endtable
HDSE
MODELADO ESTRUCTURAL
Primitivas Definidas por el Usuario ii
P Para circuitos que necesiten
ser sensibles a los flancos,
existe una notación especial
que representa cambios. Así por
ejemplo 01 significaría pasar de
0 a 1, esto es un flanco de
subida.
Abreviaturas para transiciones
*
(??)
r
(01)
f
(10)
p
(01), (x1), (0x)
n
(10), (1x), (x0)
Verilog
primitive DFF(Q, CLK,D);
output Q; reg Q; input CLK, D;
initial Q = 0; // se le da un valor inicial
table
//entrada : estado presente : salida (prox. estado)
r
0 : ? : 0 ; //Flanco de subida
r
1 : ? : 1; //Flanco de subida
(0x)
0 : 0 : 0 ; //Flanco de subida
(0x)
1 : 1 : 1; //Flanco de subida
(?0)
? : ? : -; //Flanco de bajada, no hay cambio
?
(??) : ? : -; //No hay flanco, no hay cambio
// la tabla debe ser tan completa como sea posible
endtable
endprimitive
HDSE
EJEMPLO
q
Descripción estrcutural de un sumador de propagación de acarreo de 16 bits con la siguiente
descomposición jerárquica
sumador de propagaión de acarreo de 16 bits
sumador de propagación de acarreo de 4 bits
sumador completo
semisumador
a) sin vectores de instancias
b) con vectores de instancias
Verilog
HDSE
BASES DEL LENGUAJE
P verilog es sensible a minúsculas y mayúsculas. Las palabras claves son minúsculas
P identificadores: pueden utilizar letras (mayúsculas y minúsculas) dígitos (no al principio), _ , $
P las directivas de compilación comienzan por ‘
P las funciones y tasks del sistema comienzan por $
P Valores lógicos
Verilog tiene predefinido un conjunto de 4 valores lógicos: {1, 0, x, z}. Se usa x para valores
desconocidos o no inicializados mientras que z define un estado de alta impedancia
P Números
<size> ’ <base><número>
<size> valor decimal que especifica cuantos bits representan el valor almacenado, opcional
<base> decimal (d o D), hex (h o H), octal (o ó O) y binary( b o B), decimal por defecto
<numero> valor en la base indicada
número
2’b10
3’d5
3’b5
‘ha
Verilog
#bits Base
equivalente dec.
2
binaria 2
3
decimal 5
no valido
hexadecimal
10
almacenado
10
101
depende de la máquina
HDSE
TIPOS DE DATOS
tipos de
datos
nets
( conectividad estructural )
tipo_net [msb:lsb]
[#delay] identificador;
input, output, inout
wire
supply0
supply1
tri
wand
............
análogo a un cable en un circuito
no almacenan un dato,
por defecto escalar, pueden definirse vectores
nets no explícitamente declarados son wire
se les puede asociar un retraso
pueden ser asignados implícitamente por módulos
puede ser asignado en un asignamiento continuo
o un force...release
registros
(almacenamiento)
reg
almacena un valor lógico
reg a:
debe usarse para modelar latches, ffs y memorias reg [7:0] tom;
no siempre se sintetiza un elemento de memoria reg [5:0] a, b;
por defecto escalar, pueden definirse vectores
se asignan en sentencias procedurales, funciones o tasks
reg [31:0] cce [0:1023];
1024 palabras de 32-bit
solo output
conservan su valor hasta integer
la siguiente asignación
Verilog
wire y1, z_5;
wire [7:0] data_bus;
wire A= B + C;
wire #2 y;
variables de proposito general, signed
pueden definirse vectores
real
almacena valores (retrasos) como números reales
time
64 bits unsigned, no soportado en síntesis, tsim
integer a;
integer arr[1:100];
HDSE
OPERADORES
Operador
Descripción
:?
(condicional) Es un operador ternario, una forma especial de <expresion>
||
Operación OR, operando de un bit
&&
Operación AND, operando de un bit
| (~|)
OR (NOR) bit a bit
^ (~^)
&
XOR (XNOR) bit a bit
AND bit a bit
== (Igualdad) != (Desigualdad) === (Igualdad en case) !=== (Desigualdad en case)
< (Menor) <= (Menor o igual) > (Mayor) >= (Mayor o igual)
<< (Desplazar a la izquierda) >> (Desplazar a la derecha)
+ (Suma) - (Resta)
* (multiplicación) / (división) % (módulo)
Operadores unarios: ! ~ & ~& | ~| ^ ~^ + -
Verilog
HDSE
OPERADORES
Operador
Descripción
!
Negación Lógica
!1’b1 es 1‘b0
~
Negación bit a bit
~1’b10xz es 1’b01xx
Reducción AND (NAND)unaría
& 4’b1111 es 1’b1, &2’bx1 es 1’bx
Reducción OR (NOR) unaría
| 4b’0000 es 1’b0
Reducción XOR (NXOR) unaría
^ 2b’10 es 1’b1
& (~&)
| (~|)
^ (~^)
operador
Verilog
Ejemplo
argumento
resultado
aritmético
dos operandos
palabra binaria
bitwise
dos operandos, excepto ~
palabra binaria
Reducción
un operando
bit
Lógico
dos operandos booleanos, excepto !
valor booleano
Relacional
dos operandos
net y reg se interpretan sin signo
valor booleano
desplazamiento
un operando
palabra binaria
Condicional
tres operandos
expresión
HDSE
OPERADORES
Ejemplos
// aritmética complemento a 2
// el patrón de bits almacenado en un registro
// se interpreta como un valor sin signo
module arith1 ();
reg [3:0] A, B;
wire [4:0] sum, dif1, dif2, neg;
assign sum = A + B;
assign dif1 = A -B;
assign dif2 = B - A;
assign neg = -A
initial
begin
#5 A = 5; B = 2; end
endmodule
A
B
sum
dif1 dif2
neg
5
2
7
3
29
27
0101 0010 00111 00011 11101 11011
Verilog
// las operaciones aritméticas sobre objetos de n bits
// se realizan en modulo 2n
module modulo ;
reg [2 : 0] siete ;
initial begin
#1 siete =7 ; $display (“Antes = ”, siete);
#1 siete = siete +1; $display(“despues =”,siete);
........._________________________
Resultado:
antes = 7
despues = 0
// multiplexor usando operadores condicionales anidados
wire [1:0] select;
wire [15:0] d_1, d_2, d_3, d_4;
wire [15:0] bus_a = (select == 2’b00) ? d_1:
(select == 2’b01) ? d_2:
(select == 2’b10) ? d_3:
(select == 2’b11) ? d_4;
HDSE
MODELADO COMPORTAMIENTO
los ejemplos anteriores han introducido tres tipos de comportamientos (behaviours)
no estructurales en verilog:
q asignamientos continuos
lógica combinacional implícita estableciendo asociaciones estáticas entre expresiones y nets
q construcciones (procesos) initial
flujo de actividad que se ejecuta una vez, se activa en tsim = 0
q construcciones (procesos) always
flujo de actividad que se ejecuta cíclicamente, se activa en tsim = 0
proceso
P evolución de los valores de variables tipo registro en un módulo
P puede consistir en una sentencia o en bloque de sentencias (bloque secuencial)
limitado por begin ...end
P Las sentencias dentro de un bloque secuencial que es parte de un procedimiento se
ejecutan secuencialmente, en el orden en que aparecen, pero en la misma unidad
de tiempo de simulación si no se especifica ninguna temporización.
P solo se asigna una variable tipo registro cuando se ejecuta la sentencia de asignamiento en el flujo de actividad del proceso
P un módulo puede contener cualquier número de procesos
P los distintos procesos se ejecutan concurrentemente
Verilog
HDSE
MODELADO COMPORTAMIENTO
module secuencial_1; reg Y, clk;
always
begin: my_block
@(posedge clk) #5 Y=1;
// Espera 5 y Pone a 1 Y con el flanco de subida
@(posedge clk) #5 Y=0;
// Espera 5 y Pone a 0 Y al flanco siguiente
end
always #10 clk = ~clk ;
initial Y = 0;
initial clk = 0;
initial $monitor(“T=%2g”, $time, “ clk = ”, clk, “ Y = “, Y);
initial #70 $finish
endmodule
T=0 clk
T=10 clk
T=15 clk
T=20 clk
T=30 clk
T=35 clk
T=40 clk
T=50 clk
T=55 clk
T=60 clk
Verilog
=0
=1
=1
=0
=1
=1
=0
=1
=1
=0
Y=0
Y=0
Y=1
Y=1
Y=1
Y=0
Y=0
Y=0
Y=1
Y=1
..........
initial
begin
sig_a = 0;
sig_b = 1;
sig_c = 1;
sig_d = 0;
// asignamientos procedurales
// se ejecutan secuencialmente
end
.......
en tsim = 0 se asignan sig_a,
sig_b, sig_c y sig_d.
HDSE
MODELADO COMPORTAMIENTO. TEMPORIZACIÓN
q control de retrasos (#)
#∆t sentencia;
P retrasa la ejecución de la setencia ∆t unidades de tiempo, tambien la sentencia nula. Suspende el flujo de actividad y por lo tanto afecta al tiempo de
ejecución de todas las siguientes
q control por ocurrencia de eventos (@)
P sincroniza la ejecución de una sentencia hasta que ocurra un evento determinado
P evento cambio en el valor de un identificador o una expresión que hacen
referencia a un net o a un register
Pcuando se alcanza @ el flujo de actividad se suspende
@ (expresion_evento) sentencia;
@ identificador_evento sentencia;
@ (expresión_evento1 or expresión_evento2) sentencia;
cualificadores predefinidos
posedge : transiciones 0 -> 1, 0 -> x y x -> 1
negedge: transiciones 1 -> 0, 1 -> x y x -> 0
q sentencia wait
P modela comportamiento sensible a niveles
P suspende el flujo de actividad hasta que una condición es verdadera
wait (expresión) sentencia;
Verilog
HDSE
MODELADO COMPORTAMIENTO. TEMPORIZACIÓN
module delay_controls; reg X, Y, clk, Dummy;
always #1 Dummy = ! Dummy ;
// Reloj Dummy usado para gráficos
//Ejemplos de controles de temporización.
always begin #25 X= 1; #10 X =0; #5 ; end
//Ejemplo de evento
always @(posedge clk) Y = X;
always #10 clk = ! clk ;
//El reloj real está 10 unidades de tiempo bajo
//y diez en alto
initial begin clk = 0;
$display (“T clk x Y”);
$monitor(“%2g”, $time, , ,clk, , , ,X, ,Y);
$dumpvars; #100 finish; end
endmodule
T
0
10
20
25
30
35
40
50
60
65
Verilog
Clk
0
1
0
0
1
1
0
1
0
0
X
x
x
x
1
1
0
0
0
0
1
Y
x
x
x
x
1
1
1
0
0
0
T
70
75
80
90
Clk
1
1
0
1
XY
1 1
0 1
0 1
0 0
// ff D con reset y set asíncronos
// asyndff_1 no es un modelo correcto
module asyndff_1 (d, clk, q, qbar, s, r);
input d, clk, s, r;
output q, qbar; reg q;
assign qbar = ~q;
always @ (s or r or posedge clk)
begin
if ( r == 0) q = 0;
else if(s == 0) q = 1;
else if (clk == 1) q = d;
end // almacena d si s o r se desactivan con clk 1
endmodule
module asyndff_2 (d, clk, q, qbar, s, r);
input d, clk, s, r;
output q, qbar; reg q;
assign qbar = ~q;
always @ (negedge s or negedge r or posedge clk)
begin
if ( r == 0) q = 0;
else if(s == 0) q = 1;
else q = d;
end
endmodule
HDSE
MODELADO COMPORTAMIENTO. ASIGNAMIENTOS
q Asignamiento procedural (=, asigna valor a una variable registro, blocking)
variable = expresión;
// actualiza variable con el valor de expresión
#∆t variable = expresión; // ∆t unidades de tiempo pasan antes de que se ejecute
variable = #∆t (@(evento)) expresión; // la expresión se evalúa inmediatamente,
// la asignación se retrasa ∆t unidades de tiempo (o hasta ocurrencia del evento)
P aparecen en procesos
P variable solo tipo registro
P expresión cualquier expresión usando los operadores de verilog
P se ejecutan secuencialmente en el orden en el que se han escrito
P debe ejecutarse antes de que se puedan ejecutar las que le siguen
initial
begin
sum[7] = b[7] ^ c[7]; // se ejecuta ahora
ziltch = #15 ckz&h;
// ckz&h se evalúa ahora; zlitch cambia
// después de 15 unidades de tiempo
#10 hat = b&c;
// 10 unidades de tiempo despues de que
// ziltch cambia, b&c se evalua y hat cambia
Verilog
initial
begin
a = 1; b = 2; c= 3;
#5 a = b + c;
// espera 5 unidades
// y ejecuta a = b + c = 5
d = a; // d = 5 en tsim = 5
........
HDSE
MODELADO COMPORTAMIENTO. ASIGNAMIENTOS
q Asignamiento (procedural) non-blocking (<=, asigna valor a una variable tipo
registro, RTL)
variable <= expresión;
variable <= #∆t(@(evento)) expresión; // la expresión se evalúa inmediatamente,
// la asignación se retrasa ∆t unidades de tiempo (o hasta ocurrencia del evento)
P aparecen en procesos
P variable solo tipo registro
P expresión cualquier expresión usando los operadores de verilog
P no bloquea la ejecución de las sentencias que le siguen
P utiles en el modelado de transferencias concurrentes en circuitos síncronos (RTL)
P las sentencias en una lista de asignaciones non-blocking se ejecutan “concurrentemente”
initial
begin
// todos los asignamientos se ejecutan en tsim = 0
a = 1; b = 0; // se ejecutan primero porque aparecen primero
// RHS de las siguientes asignaciones se evalúan concurrentemente
a <= b; // usa b=0
b <= a; // usa a = 1
Verilog
HDSE
MODELADO COMPORTAMIENTO. ASIGNAMIENTOS
blocking
non-blocking
initial
begin
a = 1; b = 0;
// importa el orden
a = b; // usa b = 0
b = a; // usa a = 0
initial
begin
a = 1; b = 0;
// no importa el orden
a <= b; // usa b = 0
b <= a; // usa a = 1
always @ (posedge clk)
begin
// registro desplazamiento
Z = Y; Y = X;
y = x ; z = y; // ffs paralelos
initial
begin
a = #10 1;
b = #2 0;
c = #3 1;
end
Verilog
t
0
2
3
10
12
15
a
x
x
x
1
1
1
always @ (posedge clk)
begin
// registros desplazamiento
Z <= Y; Y <= X;
y <= x ; z <= y;
b
x
x
x
x
0
0
c
x
x
x
x
x
1
d
x
x
x
1
1
1
e
x
0
0
0
0
0
f
x
x
1
1
1
1
initial
begin
d <= #10 1;
e <= #2 0;
f <= #3 1;
end
HDSE
MODELADO COMPORTAMIENTO. ASIGNAMIENTOS
q Asignamiento continuo procedural: assign...(deassign)
P aparecen en procesos, asigna variables tipo registro
P asociación dinámica a una variable (puede ser eliminada)
P tiene efecto cuando la sentencia se ejecuta y dura hasta que se hace otro asignamiento al registro o se usa la sentencia deassign sobre ese registro
P permiten modelar el comportamiento sensible a niveles de la lógica combincional, latches y control asíncrono de componentes secuenciales
module mux4_PCA(a, b, c, d, select, y_out);
input a, b, c, d;
input [1:0] select;
output y_out;
reg y_out;
always @ (select)
if (select == 0) assign y_out = a; else
if (select == 1) assign y_out = b; else
if (select == 2) assign y_out = c; else
if (select == 3) assign y_out = d; else
y_out = 1’bx;
endmodule
Verilog
module ff_PCA(pr, cl, q, clk, d);
input pr, cl, clk, d;
output q;
reg q;
always @ (negedge clk)
q = d;
always @ (cl or pr)
begin
if (!cl) assign q = 0; else
if (!pr) assign q = 1; else
deassign q;
end
endmodule
// ff con clear y preset asíncrono
HDSE
MODELADO COMPORTAMIENTO. ASIGNAMIENTOS
q Asignamiento continuo procedural: force...release
P aparecen en procesos, asigna variables tipo registro o nets
P cuando se asigna un net con force tiene prioridad sobre los asignamientos continuos y construcciones estructurales hasta que se ejecuta release
P cuando se asigna un registro con force tiene prioridad sobre los asignamientos
procedurales y construcciones assign...deassign hasta que se ejecuta release
Modos de asignamiento
output
primitive/
module
asignamiento asignamiento
assign...deassign
continuo
procedural
t sim
net
si
si
no
no
si
registro
comb no
seq si
no
si
si
si
Verilog
HDSE
MODELADO COMPORTAMIENTO. OTROS EJEMPLOS
.....
@ (event_A) begin
......
@ (event_B) begin
.....
end
end
si event_A ha ocurrido pero no event_B, el comportamiento se suspende en el segundo control por
ocurrencia de eventos. Si event_A ocurre de nuevo
mientras el proceso está suspendido se ignora.
Mientras está suspendido, otros procesos pueden
ejecutarse
module data_slip () ; reg clk, D, Q1, Q2;
// Circuito secuencial mal hecho
always @(posedge clk) Q1 = D; // Q1 = #1 D;
always @(posedge clk) Q2 = Q1; // Q2 = #1 Q1
//Esto es un data slip (deslizamiento)
initial begin clk = 0; D =1; end always #50 clk = ! clk ;
initial begin
$display (“T clk D Q1 Q2”);
$monitor(“%3g”, $time, , clk, , , ,D, ,Q1, , , ,Q2);
end
initial #400 $finish; //corre por 8 ciclos
initial $dumpvars;
endmodule
T
0
50
100
150
200
250
300
350
Verilog
Clk
0
1
0
1
0
1
0
1
D Q1 Q2
1 x x
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
T
0
50
51
100
150
151
200
250
300
350
Clk
0
1
1
0
1
1
0
1
0
1
D Q1 Q2
1 x x
1 x x
1 1 x
1 1 x
1 1 x
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
HDSE
MODELADO COMPORTAMIENTO. CONTROL
q operador condicional (?...:)
expresion_condicional = expresión ? expresion_verdadera : expresión falsa
P se usa tanto en asignamientos continuos como procedurales
q sentencia condicional (if...else)
if (expresión) sentencia1; else sentencia2;
P selección entre sentencias alternativas en función del valor booleano de una expresión
P sentencia puede ser una sentencia simple, un bloque secuencial o la sentencia nula (;)
P si todas las posibilidades no están especificadas en síntesis infiere un latch
module mux_bev(y_out, clk, r, sel, a, b);
input clk, r, sel;
input [15:0] a, b;
output [15:0] y_out;
reg [15:0] y_out;
always @ (posedge clk or negedge r)
if( r == 0) y_out = 0; else y_out = (sel) ? a + b : a -b;
endmodule
Verilog
.....
if (a == b)
begin
x = 1;
ot = 4’b1111;
end
..........
P se infieren latches para x y
para ot. Mantienen su antiguo
valor si a != b
HDSE
MODELADO COMPORTAMIENTO. CONTROL
q sentencia case (case)
case (expresión) case1: sentencia1;
case2: sentencia2;
.......
default sentenciad;
endcase
module mux4_case(a, b, c, d, select, y_out); // multiplexor de cuatro canales
input a, b, c, d;
input [1:0] select;
output y_out;
reg y_out
always @(a or b or c or d or select) // un evento en los datos o en select hace que
// y_out se compute. Ineficiente para simulación.
begin
case (select) // en simulación se examina expresión en el sistema de cuatro valores lógicos
0: y_out = a;
1: y_out = b;
2: y_out = c;
3: y_out = d;
default y_out = 1’bx;
endcase
endmodule
Verilog
HDSE
MODELADO COMPORTAMIENTO. CONTROL
q loops
q construcción repeat
P ejecuta una sentencia o un bloque de sentencias un número determinado de veces
repeat (expresión) sentencia;
q construcción for
P ejecuta una sentencia o un bloque de sentencias repetidamente, bajo la condición de que
una expresión sea verdadera
q construcción while
P ejecuta una sentencia o un bloque de sentencias repetidamente mientras una expresión
sea verdadera
q construcción forever
P ejecuta una sentancia repetidamente y de forma incondicional sujeto a disable
// inicializa un array de memoria
word_address = 0;
repeat (memory_size)
begin
memory[word_adress] = 0;
word_address = word_address + 1;
end
.......
Verilog
.........
for (K = 4; K ; K = K -1;)
begin
demo_register [K + 10] = 0;
demo_register [[K + 2] = 1;
end
// posiciones asignadas: 14, 13,
// 12, 11, 6, 5, 4, 3
begin: count_1
reg [7:0] temp_reg;
count = 0;
temp_reg = reg_a;
while (temp_reg)
begin
count= count + temp_reg[0];
temp_reg = temp_reg >> 1;
end
end
.....
HDSE
MODELADO COMPORTAMIENTO. CONTROL
q sentencia disable
termina prematuramente un bloque secuencial etiquetado, sentencia procedural o task;
q flujo de actividad paralelo (fork...join)
fork
sentencia1;
sentencia2;
....
join
// implementa tiempo absoluto en un generador de señal
......
.....
parameter half_cycle = 50;
fork // tsim = 0
initial
#50 sig_wave = ´b1;
#100 sig_wave = ’b0;
begin: clock_loop
#150 sig_wave = ‘b1;
clock = 0;
#300 sig_wave = ‘b0; // se ejecuta en tsim= 300
forever
join
begin
...... // mismo resultado si se cambia orden
#half_cycle clock = 1;
.....
#half_cycle clock = 0;
begin // bloque secuencial
end
#50 sig_wave = ‘b1;
end
#100 sig_wave = ’b0;
initial
#150 sig_wave = ‘b1;
#350 disable clock_loop;
#300 sig_wave = ‘b0; // se ejecuta en tsim= 600
....
end
...... // resultado distinto si se cambia el orden
Verilog
HDSE
MODELADO COMPORTAMIENTO. FUNCIONES y TAREAS
P Una tarea es un tipo de procedimiento, que es llamado en una sentencia procedural. Las
tareas tienen entradas y salidas pero no devuelven ningún valor. Una tarea puede llamar a
otra tarea o a una función.
P Una función es un procedimiento que es usado en lugar de una expresión. Tiene al menos
una entrada, ninguna salida, y devuelve un único valor.
P Las tareas pueden incluir controles temporales, no así las funciones.
Ilustramos las diferencias entre una tarea y una función:
LLama_a_una_tarea_y_espera (Input1,Input2,Output);
Resultado_inmediato=Llama_a_una_función(All_Inputs);
module bit_counter(data_w, bit_count);
input [7:0] data_w ;
output [3:0] bit_count;
reg [3:0] bit_count;
always @ (data_w)
count_ones(data_w, bit_count);
task count_ones;
input [7:0] reg_a;
output [3:0] count;
reg [3:0] count;
reg [7:0] temp_reg;
Verilog
begin
count = 0;
temp_reg = reg_a;
while (temp_reg)
begin
count= count + temp_reg[0];
temp_reg = temp_reg >> 1;
end
end
endtask
endmodule
module Func_compara;
reg [2:0] A, B,C, D, E, F;
initial begin A=1; B=0; D=2; E=3;
C=compara(A,B);
F=compara(D, E);
$display(“A B C D E F”);
$display(A, ,B, ,C, ,D, ,E, ,F );
end
function [2:0] compara;
input [2:0] a, b;
begin if (a<=b) compara=a;
else compara=b; end
endfunction
ABCDEF
1 00 232
HDSE
CONTENIDOS MODULE
q module el_diseño
q Declaraciones de puertos
q Declaración de parámetros
q Declaración de tipos
q Asignamientos continuos
q Instanciado de primitivas
q Instanciado de módulos
q Declaración de tareas
q Declaración de funciones
q Comportamientos
initial
always
Asignamientos procedurales
Asignamientos non-blocking
Asignamientos procedurales continuos
Bucles (for, repeat, while, forever)
Control de flujo (if, condicional, case, wait, disable)
Funciones y tareas del sistema
Llamadas funciones y tareas
q endmodule
Verilog
HDSE
DESCRIPCIÓN FSMs
module FSM_estilo1(....);
input ...;
output ....;
parameter size = ...;
reg [size-1:0] state, next_state;
assign the_outputs = ...
// una funcion de las entradas y el estado
assign next_state = ...
// una funcion de las entradas y el estado
always @(negedge reset or posedge clk)
if (reset == 1’b0) state <= start_state;
else state <= next_state;
endmodule
P se trata de descripciones explícitas
P otros estilos intermedios son posibles
P tambien es posible una descripción más
abstracta sin declaración explícita de
registros de estado (descripción implícita)
Verilog
module FSM_estilo2(....);
input ...;
output ....;
parameter size = ...;
reg [size-1:0] state, next_state;
always @ (state or entradas)
begin
// decodifica next_state con case o if
end
always @(negedge reset or posedge clk)
if (reset == 1’b0) state <= start_state;
else begin
state <= next_state;
the_outputs <= algún_valor(entradas,
next_state)
// asignamiento síncrono de las salidas
endmodule
HDSE
DESCRIPCIÓN FSMs
// explícita
module speed_machine (clock, acelarador, freno, velocidad, dyn_ind)
input clock, acelerador, freno;
output [1:0] velocidad, dyn_ind;
reg [1:0] state, next_state;
parameter parado = 2’b00;
parameter V_baja = 2’b01, desacelarando = 0;
parameter V_media = 2’b10, velocidad_constante = 1;
parameter V_alta = 2’b11, acelerando = 2;
assign velocidad = state;
assign dyn_ind = freno ? (state == parado) ? velocidad_constante : desacelerando:
acelerador ? (state == V_alta) ? velocidad_constante : acelerando: velocidad_constante;
always @(posedge clock) // síncrono gobierna las transiciones de estado
state <= next_state;
always @ (state or acelerador or freno) // asíncrono combinacional
if (freno == 1’b1) case (state)
parado: next_state <= parado;
V_baja: next_state <= parado;
V_media: next_state <= V_baja;
V_alta: next_state <= V_media;
default: parado;
endcase
freno/
else if (acelerador == 1’b1) case (state)
100
acelerador
parado: next_state <= V_baja;
V_baja: next_state <= V_media;
parado
parado, 1
parado, 1
V_media: next_state <= V_alta;
V_alta: next_state <= V_alta;
V_baja
parado, 0
V_baja, 1
default: parado;
V_media
V_baja, 0
V_media, 1
endcase
else next_state <= state;
V_alta
V_media, 0
V_alta, 1
endmodule
Verilog
01
V_low, 2
V_media, 2
V_alta, 2
V_alta, 1
HDSE
DESCRIPCIÓN FSMs
// descripción implícita
module contador_1 (clock, up_down, reset, count)
input clock, reset;
input [1:0] up_down;
output [2:0] count;
reg [2:0] count;
always @(negedge clock or negedge reset)
if (reset == 0) count = 3’b0; else
if (up_down == 2’b00 || up_down == 2’b11)
count = count;
else if (up_down == 2’b01) count = count + 1;
else if (up_down == 2’b10) count = count - 1;
endmodule
// descripción implícita
module contador_2 (clock, up_down, reset, count)
input clock, reset;
input [1:0] up_down;
output [2:0] count;
reg [2:0] count, next_count;
always @(negedge clock or negedge reset)
if (reset == 0) count = 3’b0; else count = next_count;
always @ (count or up_down) begin
if (up_down == 2’b00 || up_down == 2’b11)
next_count = count;
else if (up_down == 2’b01) next_count = count + 1;
else if (up_down == 2’b10) next_count = count - 1;
else next_count = count;
end
endmodule
Verilog
HDSE
MODELADO DE RETRASOS
Retrasos asociados a nudos y puertas:
Ya vimos como el símbolo # nos permitía retrasar
asignamientos, en realidad, con este símbolo podemos definir retrasos típicos, máximos y mínimos.
Para asignamientos
#(1.1 : 1.3 : 1.7 ) assign delay_a = a; // mín, típ, máx
Para wires
wire #(1.1 : 1.3 : 1.7 ) delay_a ; // mín, típ, máx
Para puertas podemos definir retrasos típicos, máximos y mínimos así como retrasos asociados a las
transiciones de subida y bajada por separado.
nand #3.0 nd01(c,a,b);
nand #(2.6 : 3.0 : 3.4) nd02 (c,b,a);
nand #(2.8 : 3.0 : 3.3 , 2.6 : 2.9: 3.1) nd03 (c,b,a);
//(La sintáxis es (
Verilog
min
tip
max
min
tip
max
t sub :tsub :tsub , t baj : tb a j:t baj
)
HDSE
VERILOG Y LA SÍNTESIS LÓGICA
P las herramientas de síntesis lógica no soportan todas las construcciones de Verilog
P las construcciones soportadas dependen de cada herramienta
construcciones que suelen estar soportadas en síntesis
declaración de módulos (module)
puertos: input, output, inout
asociación de puertos por nombre
asociación de puertos por posición
declaración de parámetros
nets: wire, tri, wand, wor, supply0, supply1
registros: reg, integer
instanciado de módulos
instanciado de primitivas
asignamientos continúos
operadores desplazamiento, condicional, concatenación, aritmético, bitwise, redución, lógico
y relacional
assign...deassign
begin...end
case
if, if...else,
disable
bucle for
tasks (no se permite control de temporizaciones)
funciones
Verilog
HDSE
VERILOG Y LA SÍNTESIS LÓGICA
construcciones generalmente no soportadas en síntesis
construcciones para descripción a nivel de conmutador
fork...join
forever
while
wait
initial
force...release
repeat
primitive...endprimitive
table...endtable
especificaciones de retraso
$time
Verilog
HDSE