4 .

1 BLOQUES ARITMÉTICOS
Elena Valderrama
Universidad Autónoma de Barcelona
 4 .1
Los bloques aritméticos constituyen una parte importante en caso cualquier circuito
digital.

Estudiaremos circuitos capaces de implementar las 4 operaciones básicas:

1. SUMA
2. RESTA
3. MULTIPLICACIÓN
4. DIVISIÓN

2
 4 .1
1. Suma binaria
Sumador paralelo: Ver lecciones 2.2 y 2.3 de la semana 2.
xi yi

𝑋 n
Sumador n+1
𝑍
𝑌 n
acarreoOUT
Sumador
acarreoIN
acarreo0
1 n bits 1 bit

Full_Adder (FA)
zi

xn-1 yn-1 xn-2 yn-2 x1 y1 x0 y0

acarreoOUT
Sumador
1 bit
Sumador
1 bit
… Sumador
1 bit
Sumador
1 bit acarreoIN

zn-1 zn-2 z1 z0
3
 4 .1
2. Resta binaria
Un restador binario realiza el cálculo:
𝐷 = 𝑋 − 𝑌 − 𝑎𝑐𝑎𝑟𝑟𝑒𝑜0 𝑋 n
Restador n+1
𝐷
𝑌 n

donde: acarreo0
1 n bits

𝑋 = 𝑥𝑛−1 𝑥𝑛−2…𝑥1 𝑥0
𝑌 = 𝑦𝑛−1 𝑦𝑛−2 …𝑦1 𝑦0
¿Cómo representamos un número negativo?
acarreo0: 1 bit
(habitualmente igual a 0) Si D<0, D se representa por un número de n+1
bits llamado el “complemento a 2” de D:
−2𝑛  𝐷 2𝑛 − 1 𝐷 = −𝑑𝑛 .2𝑛 +𝑑𝑛−1 .2𝑛−1 +𝑑𝑛−2 .2𝑛−2 + ⋯ + 𝑑1 . 2 + 𝑑0

4
 4 .1
2. Resta binaria
Algoritmo “manual”:
1 1 0 0 1 0 0 1
1 0 0 1 1 1 0 0
n pasos, en cada paso calculamos:
 El bit “resta”:
𝑑𝑖 = (𝑥𝑖 -𝑦𝑖 -𝑎𝑐𝑎𝑟𝑟𝑒𝑜𝑖 ) 𝑚𝑜𝑑2

 El acarreo hacia la etapa

siguiente:
𝑎𝑐𝑎𝑟𝑟𝑒𝑜𝑖+1 = 1 ⟺
(𝑥𝑖 -𝑦𝑖 -𝑎𝑐𝑎𝑟𝑟𝑒𝑜𝑖 ) < 0

5
 4 .1
2. Resta binaria
Algoritmo-1 de la resta
acarreo(0) <= acarreo_inicial; -- (habitualmente 0)
for i in 0 to n-1 loop
d(i) <= (x(i) + y(i) + acarreo(i)) mod 2;
Algoritmo-2 de la resta
acarreo(i+1) <= sign(x(i) - y(i) - acarreo(i));
acarreo(0) <= acarreo_inical; ; -- (habitualmente 0)
end loop;
for i in 0 to n-1 loop
s(n) <= acarreo(n);
d(i) <= x(i) xor y(i) xor acarreo(i);
acarreo(i+1) <=
𝑎 − 𝑏 − 𝑐 𝑚𝑜𝑑2 = 𝑎 + 𝑏 + 𝑐 𝑚𝑜𝑑2 (not(x(i)) and y(i)) or (not(x(i)) and acarreo(i))
or (y(i) and acarreo(i));
end loop;
s(n) <= acarreo(n);

6
 4 .1
2. Resta binaria 𝑋 n
Restador n+1
𝑌 n 𝑍
xi yi acarreo0
1 n bits

Restador  d(i) <= x(i) xor y(i) xor acarreo(i);

acarreoOUT acarreoIN
1 bit  acarreo(i+1) <=
Full_Substractor (not(x(i)) and y(i)) or (not(x(i)) and acarreo(i))
(FS) or (y(i) and acarreo(i))
di

xn-1 yn-1 xn-2 yn-2 x1 y1 x0 y0

dn=acarreoOUT FS FS … FS FS acarreoIN

dn-1 dn-2 d1 d0

7
 4 .1
(Ejercicio)
Construir un circuito que calcule D = x - y (x, y de n bits) y devuelva el valor de D en la
representación clásica de “signo y magnitud”, es decir, como D = (-1)sign·|D|

Sugerencia: Calcula en paralelo x – y and y– x y selecciona el |D| dependiendo del signo de x – y.

8
 4 .1
(Solución del ejercicio)
Construir un circuito que calcule D = x - y (x, y de n bits) y devuelva el valor de D en la
representación clásica de “signo y magnitud”, es decir, como D = (-1)sign·|D|

Sugerencia: Calcula en paralelo X – Y and Y – X y selecciona el |D| dependiendo del signo de X – Y.

x y y x

subtract.
Restador 0 subtract.
Restador 0
d’ d’’

0 1

sign d
9
 4 .1
3. Multiplicador binario
Un multiplicador realiza el cálculo:
𝑌 = 𝑦𝑚−1 . 2𝑚−1 +𝑦𝑚−2 . 2𝑚−2+…+𝑦1 . 2+𝑦0
𝑃 = 𝑋. 𝑌
𝑃 = 𝑋. 𝑦𝑚−1 . 2𝑚−1 +𝑋. 𝑦𝑚−2 . 2𝑚−1+…+𝑋. 𝑦1 . 2+𝑋. 𝑦0
donde:
Algoritmo1:
𝑋 = 𝑥𝑛−1 𝑥𝑛−2…𝑥1 𝑥0
p0 = X·y0;
𝑌 = 𝑦𝑚−1 𝑦𝑚−2 …𝑦1 𝑦0 p1 = X·y1·2;
p2 = X·y2·22;
Mayor valor de P: ···
2𝑛 − 1 . 2𝑚 − 1 = 2𝑛+𝑚 − 2𝑛 − pm-1 = X·ym-1·2m-1;
− 2𝑚 + 1 < 2𝑛+𝑚
P = p0 + p1 + p2 + ··· + pm-1 .
 P es un número de n+m bits

10
 4 .1
3. Multiplicador binario

Algoritmo1:
p0 = X·y0;
p1 = X·y1·2; Ejemplo:
p2 = X·y2·22;
101101
···
x 1011
pm-1 = X·ym-1·2m-1; ---------
P = p0 + p1 + p2 + ··· + pm-1 . 101101  p0
101101  p1
000000  p2
101101  p3
------------------
111101111  P

11
 4 .1
3. Multiplicador binario 0 X
acc_in X
p0 = X·y0; acc_in X
y
y y(0)
p1 = X·y1·2; acc_out

p2 = X·y2·22; X·2

··· adder
acc_in X
pm-1 = X·ym-1·2m-1; y y(1)
acc_out acc_out
P = p0 + p1 + p2 + ··· + pm-1 . X·22

Algoritmo2: “Right-to left algorithm” acc_in X

y y(2)
acc <= 0; acc_out

for i in 0 to m-1 loop ····

acc <= acc + X*(2**i)*y(i); X·2m-1

end loop;
acc_in X
P <= acc; y y(m-1)
acc_out

P 12
 4 .1
4. Divisor binario
Dados dos números X e Y naturales (X < Y),
dividir X entre Y (X/Y ) consiste en calcular
dos números Q y R tales que:

𝑋 = 𝑄. 𝑌 + 𝑅 Definición equivalente:
Calcular Q,R tal que X/Y = Q +R/Y,
𝑋 = 𝑥𝑛−1 …𝑥0 𝑌 = 𝑦𝑛−1…𝑦0
donde Q es un múltiplo de 2−𝑝 ,
Precisión de Q : 2−𝑝 (Q tendrá p bits, todos fraccionarios) sabiendo que el error cometido es de
X/Y - Q = R/Y < 2−𝑝 .
R < Y.2−𝑝

Para calcular X/Y cuando X  Y será necesario

alinear previa y convenientemente los operandos.

13
 4 .1
4. Divisor binario
Algoritmo de división binaria Ejemplo: X = 21, Y = 35, p = 6

r(0) <= x; iteración r q d comentarios

for i in 1 to p loop 0 21 - - -
d <= 2*r(i-1) - y; 1 7 1 7 D = 42-35 = 7
if d < 0 then q(i) <= 0; r(i) <= 2*r(i-1); 2 14 0 -21 D = 14-35 = -21
else q(i) <= 1; r(i) <= d; 3 28 0 -7 D = 28-35 = -7
end if; 4 21 1 21 D = 56-35 = 21
5 7 1 7 D = 42-35 = 7
end loop;
6 14 0 <0 D = 28-35 < 0

Resultado: Q = [100110]2 . 2-p = 38/64 = [0,100110]2,

Q = (q1 q2 ··· qp-1 qp)·2-p, R = 14/64 = [0,001110]2
R = rp·2-p.

14
 Y
4 .1
4. Divisor binario X

r Y
0
Algoritmo de división binaria r Y
q1 q sign
r+ q subtractor
r(0) <= x; 2·r
for i in 1 to p loop
d <= 2*r(i-1) - y; r Y 1 0
q2 q
if d < 0 then q(i) <= 0; r(i) <= 2*r(i-1); r+
else q(i) <= 1; r(i) <= d; r+

end if;
r Y
end loop; q3 q
r+

····

r Y
qp q
r+

rp 15
 4 .1
RESUMEN
 Hemos visto un conjunto de circuitos capaces de ejecutar las operaciones aritméticas
básicas de suma, resta, multiplicación y división.
 Hemos introducido, aunque muy brevemente, la representación de números negativos
mediante el complemento a 2.

16
4.2 Introducción al VHDL: Léxico, sintaxis
y estructura
Lluís Terés
Instituto de Microelectrónica de Barcelona, IMB-CNM (CSIC)
Universitat Autònoma de Barcelona (UAB)
PREVIO: Lenguajes de descripción de hardware (HDL), ¿que 4 .2
son y para que se utilizan?
¿Que son?
• Lenguajes de alto nivel de abstracción orientados a describir/modelar hardware
• Permiten escribir modelos formales y no ambiguos en lugar de utilizar lenguajes naturales
• Lenguajes comprensibles para personas y máquinas
• Similares a los lenguajes de programación pero para modelar Hw en lugar de desarrollar Sw
¿Para que se utilizan?
• Modelado: desarrollar modelos Hw que sean independientes de su implementación tecnológica
• Simulación: los modelos HDL se pueden simular para validar las especificaciones a cumplir
• Síntesis: materializar los modelos HDL a nivel físico contra distintas tecnologías
¿Cuales son los principales HDLs?
• VHDL: VHSIC Hardware Description Language (Std. IEEE 1076 desde 1987)
• Verilog: lenguaje de simulación de Cadence (1985)HDL público (Std. IEEE 1364 desde 1995)
• C/C++/SystemC/SystemVerilog: lenguajes de mayor nivel de abstracción para especificar
18
sistemas Hw/Sw a nivel funcional
PREVIO: HDLs, ¿que son y para que se utilizan? 4 .2
Nivel de Lenguajes de desarrollo Lenguajes de descripción
abstracción de Software de Hardware
compilación + simulación
void Error(int Codigo) { if (reset = ‘1’) then
Programas/Modelos switch (Codigo) { q <= ‘0’;
case 1: printf(“ ….. elsif (clk’event and clk=‘1’) then
independientes de ... q <= d; Resultados de
Procesador/Tecnología } programa en end if; Modelo Hw en
} lenguaje de alto nivel
Simulación
lenguaje de alto nivel Pre-síntesis
compilación

síntesis

compilación síntesis validación

str r1, 1Ah d q

lea dx, cadena Resultados de
Programas/Modelos mov ah, 0ah clk Simulación
dependientes de int 21h reset Descripción Post-síntesis
… Programa en implementación
Procesador/Tecnología
... código máquina física
jmp end (P específico) (tecnología específica) compilación + simulación
19
CONTENIDO 4 .2
1. VHDL: léxico y sintaxis básicas
2. VHDL: unidades de diseño
3. VHDL: sentencias secuenciales (selección)
4. VHDL: sentencias concurrentes (selección)
5. Flujo de diseño en VHDL: modelado - simulación - síntesis
6. Resumen

20
1. Léxico y sintaxis básicos 4 .2
Palabras Reservadas, Identificadores, Símbolos y Literales
Palabras reservadas del lenguaje
abs access after alias all and architecture
array assert attribute begin block body buffer
bus case component else elsif end entity
exit file for function generate generic guarded
if in inout is label library nand
new next nor not null of on
open or others out process procedure ...
Identificadores para dar nombres específicos a elementos/objetos VHDL
- Basados en el conjunto de caracteres {„a‟…‟z‟, ‟A‟…‟Z‟, ‟0‟…‟9‟, ‟_‟}
- Primer carácter es alfabético. „_‟ al final o dos „__‟ consecutivos prohibido
- Mayúscula/minúsculas indiferentes. Palabras reservadas prohibidas
Ejemplos: COUNT, aBc, X, f123, VHDL, VH_DL, ABC, q1, Q0

Símbolos Literales
- 1 o 2 caracteres Base Carácter Físicos
- operadores, puntuación, comentarios, parte de 2#110_1010# „a‟ „A‟ „@‟ 10 ns
sent.: + - * / ( ) . , : & „ < 16#CA# Cadenas caract. 2.2 V
> = | # ; -- => ** := /= >= 16#f.ff#e+2 “Tiempo” 50 pF
Decimal “110101” Cadena bits
<= <> “
12 0 1E6 Bits:„0‟,„1‟ X”F0f” B”111_100”
1.1. Objetos en VHDL 4 .2
• Un objeto VHDL es cualquier elemento del lenguaje capaz de contener valores
• Tipos de objetos VHDL:
 Constant
 Variable Declaración de objeto:
<Object type> <identifier> : <data type> [:= Initial value];
 Signal
 File

constant PI : real := 3.1415927; variable Counter : integer :=0; Declaración

constant WordBits : natural := 8; variable Increment : integer;
constant NumWords : natural := 1024; de variables
constant TotBits : natural := WordBits * NumWords; Increment := 2; Asignación
Counter := Counter + Increment;
a variables
signal Clk : bit := „1‟;
Declaración e
... inicialización de señal
Clk <= „1‟; Asignación a señal
file Estimuli : FileTypeName1 open read_mode is “data.in”;
file Dataout : FileTypeName2 open write_mode is “data.out”;
 1.2. Tipos de datos 4 .2
• VHDL es un lenguaje fuertemente tipado
• Un tipo de datos define un conjunto de valores fijos y
estáticos
• Todo objeto del lenguaje pertenece a un tipo de
Package standard is
datos específico
type boolean is (false, true);
STANDARD package: Tipos de datos
predefinidos del VHDL
• type
Losbit
valores de los„1‟);
is („0‟, objetos deben pertenecer al tipo
type character is (NUL, SOH, STX,…, „ „, „!‟, „”‟, „#‟, „$‟,… „0‟, „1‟, „2‟, „3‟, „4‟, „5‟,
de datos del objeto
„6‟, „7‟, „8‟, „9‟,…,„A‟, „B‟, „C‟, „D‟, „E‟, „F‟ ,…, „a‟, „b‟, „c‟, „d‟, …);
• type
El usuario/diseñador
severity_level ispuede definir
(note, nuevos
warning, tipos de
error, failure);
type integer is range -2.147.483.647 to 2.147.483.647; -- implementation dependent
datos
type real is range -1.0e38 to 1.0e38 ; -- implementation dependent
…/…
function NOW return TIME;
subtype natural is integer range 0 to integer'high;
subtype positive is integer range 1 to integer'high;
type string is array (positive range <>) of character;
type bit_vector is array (natural range <>) of bit
…/…
End standard;
 1.2. Tipos de datos
• VHDL es un lenguaje fuertemente tipado
• Un tipo de datos define un conjunto de valores fijos y
estáticos
• Todo objeto del lenguaje pertenece a un tipo de
datos específico
• Los valores de los objetos deben pertenecer al tipo
También en STANDARD package…
de datos del objeto
-- implementation dependent
• type
El usuario/diseñador
time is range 0 to puede
1e20definir nuevos tipos de
units
datos
fs;
ps = 1000 fs;
ns = 1000 ps;
us = 1000 ns;
ms = 1000 us;
sec = 1000 ms;
min = 60 sec;
hr = 60 min;
end units time; 24
1.3. Operadores y expresiones 4 .2
• Los operadores son símbolos que identifican operaciones específicas
• Tipos: relacional , lógico, aritmético y concatenación
• Operadores:
• Expresiones:
Relational Logic Arithmetic Arithmetic
(-b + sqrt(b**2 - 4.0*a*c))/(2.0*a)
= and +
/= or - Relational Logic
< nand * delay >= 20 ns (a xor b) and not c;
name < “Smith”
<= nor /
> xor **
Concatenation
>= not mod BitSign & VectorValue
rem
Concatenation abs • Expresiones usadas como condiciones o asignadas a:
 Constantes (const := expresión;)
&  Variables (var := expresión;) 25
 Señales (sig <= expresión;)
2. Unidades de diseño 4 .2
El VHDL se organiza en diferentes “Unidades de Diseño” :
• Entity • Entidad
• Architecture • Arquitectura
• Package (declaration & body) • Paquete (declaración & cuerpo)
• Configuration • Configuración

Primarias
Entity Configuration Package
Declaration Declaration Declaration

Architecture 1 Package

Secundarias
Body
Architecture 2

Architecture n
26
2.1. ENTITY (entidad) 4 .2
• Es una “caja negra” con nombre que solo describe la interface externa de un
módulo Hw sin mostrar su implementación o funcionamiento
• Sintaxis:
Nombre o identificador de la entidad
entity <id> is Parámetros genéricos
[<generics>];
[<ports>]; Puertos de entrada/salida (interface electrónica)
[<declarations>];
[begin <sentences>];
Declaraciones globales (comunes a todas la arquitecturas de esta ent.)
end [entity] [<id>];
Sentencias pasivas (comunes a todas la arquitecturas de esta entidad)

entity MUX21 is
port( A : in bit; A
B : in bit;
Ctrl : in bit; B MUX21 Z
Z : out bit);
end MUX21;
Ctrl
27
2.1. ENTITY (entidad) 4 .2
• Es una “caja negra” con nombre que solo describe la interface externa de un
módulo Hw sin mostrar su implementación o funcionamiento
• Sintaxis:
Nombre o identificador de la entidad
entity <id> is Parámetros genéricos
[<generics>];
[<ports>]; Puertos de entrada/salida (interface electrónica)
[<declarations>];
[begin <sentences>];
end [entity] [<id>];

entity MUX21n is Tamaño del bus como parámetro genérico

generic( n : integer := 8);
n
port( A : in bit_vector(n-1 downto 0);
B : in bit_vector(n-1 downto 0);
A
n n
Ctrl : in bit; B MUX21 Z
Z : out bit_vector(n-1 downto 0));
end MUX21; Ctrl 28
2.2. ARCHITECTURE (arquitectura) 4 .2
• Detalla lo que hay detrás de un “entidad” describiendo su comportamiento ya sea
nivel funcional, flujo de datos, estructural o una mezcla de estos
• Pueden haber varias arquitecturas para una misma entidad
• Sintaxis:
Nombre de la arquitectura
Nombre de la entidad
architecture <id> of <id_entity> is
[<declarations>]; Declaraciones (tipos-datos, constantes, variables,
begin señales o componentes) propias de esta
<concurrent sentences>; arquitectura
end [architecture] [<id>];
Sentencias concurrentes:
• Asignaciones concurrentes
• Instancias a componentes
• Procesos (process)
• Bloques (blocks)

29
2.2.1 Entities & Architectures 4 .2
entity MUX21 is entity MUX21n is
port( A, B, Ctrl : in bit; generic ( n: natural);
Z : out bit); port( A : in bit_vector(n-1 downto 0);
end MUX21; B : in bit_vector(n-1 downto 0);
Ctrl : in bit;
Z : out bit_vector(n-1 downto 0));
architecture Functional of MUX21 is
end MUX21;
begin
process(A, B, Ctrl)
begin architecture Functional of MUX21n is
if Ctrl = „0‟ then begin
Z <= A; process(A, B, Ctrl)
else begin
Z <= B; if Ctrl = „0‟ then
end if; Z <= A;
end process; else
Z <= B;
end Functional; n
end if;
end process; A
A end Functional; B
n
MUX21n
n
Z
B MUX21
Z Ctrl
Ctrl
2.2.1 Entities & Architectures 4 .2
entity MUX21 is
port( A : in bit;
B : in bit;
architecture structural of MUX21 is Ctrl : in bit;
signal Ctrl_n, As, Bs : bit; Z : out bit;
component INV end MUX21;
port( Y : in bit;
Z : out bit);
end component;
component AND2
port( X, Y : in bit;
Z : out bit);
end component;
component OR2
port( X, Y : in bit;
Z : out bit); architecture DataFlow of MUX21 is
As Bs
end component; signal Ctrl_n, N1, N2 : bit;
begin begin
U0: INV port map (Ctrl, Ctrl_n); Ctrl_n <= Ctrl_n
N1 not Ctrl;
and a;
U1: AND2 port map (Ctrl_n, A, As); N1
Z <= (N1
Ctrl_n
or N2);
and a;
U2: AND2 port map (Ctrl, B, Bs); N2 <= Ctrl and b;
U3: OR2 port map (As, Bs, Z); Z
Ctrl_n <= (N1
not Ctrl;
or N2);
end structural; end DataFlow;
Sentencias Concurrentes
2.3. PACKAGE (paquete) 4 .2
• Contiene distintas definiciones de tipos-datos, funciones u objetos (constantes, variables,
señales, ficheros) para facilitar su reutilización en distintos códigos-modelos VHDL
• Dos unidades: Nombre del paquete
 “declaración paquete” package <identifier> Declaraciones:
[<declarations>];
“Package declaration” end [package] [<identifier>] • Tipos de datos
• Objetos VHDL
• Funciones & procedimientos
 “Cuerpo paquete”
Nombre del paquete
“Package body” package body <identifier> Asignaciones y definiciones de:
[<Assignments and • Constantes
Detailed definitions>];
• Funciones & procedimientos
end [package body] [<identifier>]
• Otras informaciones a ocultar
Paquetes más habituales:
• Uso del paquete: - STANDARD & TEXTIO
use <library>.<package name>.[<identifier> | all];
- Std_logic_1164
- Std_logic_arith
- Definidos x usuario/diseñador
2.3. PACKAGE (paquete) 4 .2
Ejemplo de paquete definido por el usuario/diseñador
library IEEE; Comentario
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
package main_parameters is
constant m: natural := 8; -- m-bit processor
-- Value „0‟ in m-bits
constant zero: std_logic_vector(m-1 downto 0):= conv_std_logic_vector(0, m);
-- Value „1‟ in m-bits
constant one: std_logic_vector(m-1 downto 0) := conv_std_logic_vector(1, m);
-- Instruction codes for our simple processor instruction set
constant ASSIGN_VALUE: std_logic_vector(3 downto 0) := "0000";
constant DATA_INPUT: std_logic_vector(3 downto 0) := "0010";
constant DATA_OUTPUT: std_logic_vector(3 downto 0) := "1010";
constant OUTPUT_VALUE: std_logic_vector(3 downto 0) := "1000";
constant OPERATION_ADD: std_logic_vector(3 downto 0) := "0100";
constant OPERATION_SUB: std_logic_vector(3 downto 0) := "0101";
constant JUMP: std_logic_vector(3 downto 0) := "1110";
constant JUMP_POS: std_logic_vector(3 downto 0) := "1100";
constant JUMP_NEG: std_logic_vector(3 downto 0) := "1101";
end main_parameters;
Tipo-datos de la Valor de la
Indicador objeto: Id. Constante 33
Constante Constante
constante
2.3. PACKAGE (paquete) 4 .2
Paquetes estándar del IEEE
• Paquete IEEE standard 1164 (std_logic_1164) Caracter Valor
 Lógica Multivaluada (std_logic): (‘U’, ’X’, ‘0’, ’1’, ’Z’, ’W’, ’L’, ’H’, ’-’);
'U' No-inicializado
 Subtipos: (‘X’, ’0’, ’1’), (‘X’, ’0’, ’1’, ’Z’), ... 'X' Valor lógico “desconocido fuerte”
 Operaciones aritmético-lógicas básicas con estos tipos de datos '0' Valor lógico “cero fuerte”
'1' Valor lógico “uno fuerte”
 Funciones de conversión de tipos de datos
'Z' Alta impedancia (desconectado)
• Paquete aritmético (std_logic_arith) 'W' Valor lógico “desconocido débil”
 Operaciones y funciones más complejas con tipos de datos 'L' Valor lógico “cero débil”
“std_logic” 'H' Valor lógico “uno débil”

 Funciones de conversión de tipos de datos (i.e integer <=> std_logic) '-' Termino redundante/indistinto

• Otros: std_logic_unsigned, std_logic_signed, …

• Las herramientas de modelado, simulación y síntesis reconocen y optimizan su funcionamiento
para estos paquetes  Son pues de uso recomendado. 35
RESUMEN 4 .2
• Concepto y objetivos generales de los HDLs: “modelado – simulación – síntesis de Hw”
• Léxico y sintaxis básica del VHDL
 Elementos léxicos del lenguaje
 Objetos (constante, variable, señal y [ficheros])
 Tipos de datos, operadores y expresiones

• Unidades de diseño del VHDL

 Entidad y Arquitectura
 [Configuración]
 Paquete (declaración & cuerpo)

• Hemos visto algunos ejemplos de distintas unidades de diseño simples

36
4.3 Introducción al VHDL: Sentencias
secuenciales del lenguaje
Lluís Terés
Instituto de Microelectrónica de Barcelona, IMB-CNM (CSIC)
Universitat Autònoma de Barcelona (UAB)
37
Previo: mundo secuencial vs. concurrente 4 .3
Sentencias Secuenciales vs. Concurrentes
• Secuenciales
 Sentencias algoritmicas similares a los lenguajes software (if, case, loop, exit, return, …)
 Se interpretan secuencialmente  el orden de ejecución es importante para los resultados
 Solo se usan en functions, procedures and Processes
• Concurrentes
 Orientadas a describir hardware donde componentes, bloques y procesos trabajan
simultáneamente a lo largo del tiempo
 Algunas sentencias secuenciales tiene sus equivalentes concurrentes
 Sentencias seleccionadas: Procesos, Asignaciones a señal, Instanciación de componentes
 Solo se utilizan en las Arquitecturas
• Mapeando de “Concurrente” a “Secuencial” para simulación
 Cada sentencia concurrente se convierte a su proceso equivalente basado en sentencias
secuenciales
 Para simular todas las sentencias concurrentes se convierten a sus procesos equivalentes
 La simulación dirigida por eventos del VHDL solo gestiona un conjunto de procesos concurrentes
38
Previo: mundo secuencial vs. concurrente 4 .3
Estructura general de un modelo en VHDL

entity X is
-- Generics decl.
-- Ports decl.
…
end X; …
S <= A when Sel=„0‟ else B;
Clock <= not clock after 20 ns;
architecture Y of X is …
…
begin P1: process (clock, S);
… begin
…
Solo sentencias concurrentes Solo sentencias secuenciales
…
end Y;
end process;
P2: process …

39
1. Sentencias secuenciales (selección) 4 .3
• ¿Donde pueden utilizarse?

process procedure P() is function F() return

begin begin begin
-- sentencias -- sentencias -- sentencias
-- secuenciales -- secuenciales -- secuenciales
end process; end P; end F;

• Sentencias seleccionadas
• Asignaciones a Variable y Señal
• Wait
• If … then … else … endif
• Case
• Loop, [Exit - Next]
• Functions & Procedures
• Assert…report…severity
40
1.1. Asignación a variable 4 .3
• Reemplazo inmediato del valor de la variable
• Sintaxis:
[label:] <variable name> := <expression>;

• Ejemplos:
Var := „0‟;
Vector := “00011100”;
string := “Message is: ”;
A := B + C;
B := my_function(3,databus)
C := my_function(4,adrbus) + A;

41
1.2. Asignación a señal 4 .3
• Proyecta un nuevo evento (tiempo, valor) en el “driver” de la señal.
“Evento”: pareja tiempo-valor - La señal toma el valor vi en el tiempo ti. t t0 t1 … ti
“Driver de una señal”: secuencia de eventos ordenados por tiempo.
v v0 v1 … vi
• Sintaxis:
[label:] <signal_name> <= [delay_type] <expression> {after <delay>};

• Modelos de retardos: “inertial” o “ transport”

• Ejemplos: driver t 0 10 15 20 28 40 50

A <= „0‟, „1‟ after 10 ns, „0‟ after 15 ns, „1‟ after 20 ns,
A v 0 1 0 1 0 1 0
„0‟ after 28 ns, „1‟ after 40 ns, „0‟ after 50 ns;

B1 <= transport A after 10 ns; B1

B2 <= A after 10 ns;
B2
B3 <= reject 5 ns A after 10 ns;
B3
A
(ns)
0 10 20 30 40 50 60 70
1.3. Wait 4 .3
• Indica el punto donde debe suspenderse un proceso, así como las condiciones para su
posterior reactivación. Mas de una sentencia “wait” por proceso es posible.
• Sintaxis:
[label:] wait [on <signal> {, ...}]
[until <boolean_expresion>]
[for <time_expresion>]; process
begin
Clock <= not Clock;
• Ejemplos básicos: wait for 10 ns;
end process;

process process
begin begin
Suspende y fija un tiempo
<sequential sentences> c <= a and b; de reactivación: 10ns
wait; wait on a, b;
end process; end process; process
begin clk
Suspende sin condición Sensible a eventos en las q <= d;
de reactivación señales “a” “b” wait until Clock = „1‟;
end process;
Sensible a evento en señal y condición=True
INCISO sobre la simulación VHDL 4 .3
Ciclo de simulación dirigida por eventos del VHDL
Actualizar Señales
& Tiempo Ejecución
Que procesos hay
que reactivar? de procesos

?
s/n s/n
s/n s/n Inicializa
DT Inicialización
drivers
de señales
señales

Process-2

Process-n
Process-1

Actualizar drivers ...

de señales

d delay
STOP
Esperar a que todos los procesos
activos se hayan detenido (wait)
0 1 3 4 5 Tiempo
1.4. If … then … else … endif; 4 .3
• Selecciona el grupo de sentencias a ejecutar según se cumpla o no una condición
• Sintaxis:
[label:] if <condicion> then
FlipFlop: process
<sentencias secuenciales>
begin clk
{elsif <condicion> then
if rst = „1‟ then
<sentencias secuenciales}
Q <= „0‟;
[else
elsif (clk‟event and clk=„1‟) then
<sentencias secuenciales>]
Q <= D;
end if [label];
end if; end if;
wait on rst, clk;
• Ejemplos: end process; Flip-flop
process
Process (A, B, Ctrl) begin
Begin if Enable =„1‟ then
if Ctrl = „0‟ then Salida <= Entrada; Latch: process begin
Q <= A; else if load =„1‟ then
else Salida <= „Z‟; Q <= D;
Q <= B; end if; end if;
end if; wait on Enable, Entrada; wait on load, D;
end process; end process; end process;
Mux Buffer Triestate Latch
1.5. Case 4 .3
• Selecciona el grupo de sentencias a ejecutar en función
[label:] case <expresion> is
del valor de una determinada expresión u objeto. {when <value> =>
• Sintaxis: <sequential sentences>;}
[when others =>
 Valores alternativos (|): when “00” | “01” => ... <sequential sentences>;]
 Rango de valores: when 5 to 12 => ... end case [label];
 Resto de valores como última opción: when others => ...
• Ejemplos: type weekdays : (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);
type typeofday : (Workingday, Holiday);
Signal Day : Weekdays; process
ValEnt: señal de tipo entero
process Signal Daytype : typeofday; Res: variable de tipo entero
begin begin
case Day is case ValEnt is
when Monday to Friday => when 0 => Res := 5;
Daytype <= Workingday; when 1 | 2 | 8 => Res := ValEnt;
when Saturday | Saunday => when 3 to 7 => Res := ValEnt + 5;
Daytype <= Holiday; when others => Res := 0;
end case; end case;
wait on Day; wait on ValEnt;
end process; end process;
1.6. If & Case entity LatMux is
port(
4 .3
Load : in bit;
• Ejemplo: módulo “LatMux” según la función A, B, C, D : in bit;
Ctrl : in bit_vector(0 to 1);
indicada por el esquema siguiente: Y : out bit);
 Mux4-1 end LatMux;

 Latch architecture TwoProc of LatMux is

Signal X : bit;
LatMux begin
Concurrent Statements
Mux: process (Ctrl, A, B, C, D);
A begin
case Ctrl is
X when “00” => X <= A;
B when “01” => X <= B;
Y
when “10” => X <= C;
C when “11” => X <= D;
end case;
D end process;
Sequential Statements
Ctrl Latch: process (Load, X);
begin
if Load=„0‟ then
Load Y <= X;
end if;
end process;
47
end TwoProc;
Ejercicio 4 .3
• ¿Podríais describir una nueva arquitectura del
entity LatMux is
mismo módulo pero con un único “Process”? port(
Load : in bit;
A, B, C, D : in bit;
Ctrl : in bit_vector(0 to 1);
Y : out bit);
LatMux end LatMux;

A architecture OneProc of LatMux is

Begin
B
C
? Y UnicP: process (Load, Ctrl, A, B, C, D);
begin
if Load=„0‟ then
case Ctrl is
D when “00” => Y <= A;

Ctrl ?
when “01” => Y <= B;
when “10” => Y <= C;
when “11” => Y <= D;
Load end case;
end if;
end process UnicP;

end OneProc; 48
Ejercicio (solución) 4 .3
• ¿Podríais describir una nueva arquitectura del
entity LatMux is
mismo módulo pero con un único “Process”? port(
Load : in bit;
A, B, C, D : in bit;
Ctrl : in bit_vector(0 to 1);
Y : out bit);
LatMux end LatMux;

A architecture OneProc of LatMux is

Begin
B UnicP: process (Load, Ctrl, A, B, C, D);
Y
begin
C if Load=„0‟ then
case Ctrl is
D when “00” => Y <= A;
when “01” => Y <= B;
Ctrl when “10” => Y <= C;
when “11” => Y <= D;
Load end case;
end if;
end process UnicP;

end OneProc; 49
 1.7. Loop 4 .3
• Las sentencias secuenciales del bucle se repiten según el tipo y condiciones del mismo.
• Tipos de bucles: “while”, “for” o “sin control de iteraciones (bucle infinito)”.
• Sintaxis: [label:] [while <boolean_condition> | for <repetition_control>]
loop
<sequential sentences>}
end loop [label];
achitecture Functional of ParallelAdder is
begin
• Ejemplo: “Full-adder” process (X, Y, Cin);
variable C : std_logic_vector(n downto 0);
entity ParallelAdder is
variable tmp : std_logic;
generic (n : natural :=4 );
variable I : integer;
port ( X, Y : in
begin
std_logic_vector(n-1 downto 0);
C(0) := Cin;
Cin : in std_logic;
for I in 0 to n-1 loop
Z : out
tmp := X(I) xor Y(I);
std_logic_vector(n-1 downto 0);
Z(I) <= tmp xor C(I);
Cout : out std_logic);
C(I+1) := (tmp and C(I)) or (X(I) and Y(I));
End ParallelAdder ;
end loop;
Cout <= C(n);
• Sentencias Exit y Next: roturas condicionales end process;
end Functional;
de bucle
1.8. Function 4 .3
• Trozo de código que realiza un cálculo específico en función de unos parámetros de
entrada y retorna un valor.
• Sintaxis para su declaración: function <name> [(<parameters list>)] return <data_type>;

• Sintaxis para su definición: function <name> [(<parameters list>)] return <data_type> is

{<declarative part>}
begin
{<sequential sentences>} [label:] return [expresion];
end [function] [<name>];

• Ejemplo: function bv2int (bs: bit_vector(7 downto 0)) return integer; Declaración de función

Var := base + bv2int(adrBus(15 downto 8));

Uso de la función
Sig <= base + bv2int(adrBus(7 downto 0));
51
1.9. Procedure 4 .3
• Trozo de código que realiza un cálculo específico en función de unos parámetros de
entrada y retorna valores en sus parámetros de salida.
• Sintaxis para su declaración: procedure <name> [(<parameters list>)];

• Sintaxis para su definición: procedure <name> [(<parameters list>)] is

{<declarative part>}
begin
{<sequential sentences>}
end [function] [<name>];

• Ejemplo: procedure bv2int (bs: in bit_vector(7 downto 0); x: out integer ); Declaración

bv2int(adrBus(15 downto 8); Var);

Var := base + Var;
Uso de la función
52
1.10. Assert 4 .3
• Sentencia de comprobación: cuando <boolean expression> es FALSE entonces se imprime el
<string of characters> y se realizan las acciones previstas según el nivel de “severity” indicado.
• Sintaxis:
[label:] assert <boolean expression>
[report <string of characters>]
[severity (note | warning | error |failure);

• Ejemplos:
assert not(addr < X"00001000" or addr > X"0000FFFF“)
report “Address in range" severity note;

assert (J /= C) report "J = C" severity note;

Sentencias Secuenciales: Report – Reporta un mensaje y activa un nivel de “severity” (problema)

• Sintaxis: [label:] [report < string of characters >]
[severity (note | warning | error |failure);

• Ejemplo:
report “Check point 13”;
= assert FALSE “Check point 13” severity note;
RESUMEN 4 .3
• Los mundos secuencial y concurrente en VHDL
• Sentencias secuenciales en VHDL (dentro de process, function o procedure)
 Sentencias seleccionadas:
• Asignaciones a Variable & Señal • If … then … else … endif • Loop, Exit y Next
• Wait • Case • Functions, Procedures y Assert

 Gestión del tiempo y simulación dirigida por eventos de procesos concurrentes

 Aprendizaje basado en ejemplos sencillos

54
4.4 Introducción al VHDL: Sentencias
concurrentes del lenguaje
Lluís Terés
Instituto de Microelectrónica de Barcelona, IMB-CNM (CSIC)
Universitat Autònoma de Barcelona (UAB) 55
Comentario previo 4 .4
Estructura general de un modelo en VHDL

entity X is
-- Generics decl.
-- Ports decl.
…
end X; …
S <= A when Sel=„0‟ else B;
Clock <= not clock after 20 ns;
architecture Y of X is …
…
begin P1: process (clock, S);
… begin
…
Solo sentencias concurrentes Solo sentencias secuenciales
…
end Y;
end process;
P2: process …

56
1. Sentencias concurrentes (selección) 4 .4
• Todas las sentencias concurrentes se evalúan simultáneamente

• ¿Donde pueden utilizarse?

• Entity (sentencias pasivas) entity X is Concurrent sentences
begin
• Block (agrupa sentencias concurrentes)
• Architecture (todas las sentencias entre
begin y end son concurrentes) end X;

• ¿Que sentecnias vamos a analizar?

• Process B : block
architecture Y of X is begin
• Asignaciones a señal begin
• Asignación directa
• Asignación condicional end block;
• Asignación por selección end Y;

• Componentes
• Generate
• Cada sentencia concurrente se convertirá a su proceso secuencial equivalente antes de ser simulada.
57
Luego se simula un mar de procesos concurrentes entre si.
1.1. Process 4 .4
• Contienen sentencias secuenciales que definen su función.
• Se comunican con los otros procesos y sentencias concurrentes mediante señales.
• Cada proceso es sensible a eventos, señales o condiciones específicas para reactivarlo.
• La lista de sensibilidad del principio de un proceso indica las señales a las que este es sensible.
• Un proceso es un bucle infinito que debe contener al menos una condición de paro/espera (wait).
• Los procesos pueden tener declaraciones locales que solo son visibles dentro del mismo proceso.
• Sintaxis: [<label>:] process [(<signal> ,{<signal>, ...})] [is]
<local declarations>
begin Señales cuyos
<sequential sentences> sensitivity signals list cambios activan la
end process [<label>]; ejecución del proceso

process
process (<sensitivity signals list>) begin
begin <sequential sentences>
<sequential sentences> = wait on <sensitivity signals list>;
end process; end process;
1.2. Asignación a señal 4 .4
• Sintaxis:

[label:] <signal> <= [delay_type] <expresion | waveform> {after <delay_time>};

• Ejemplos: A B
Tmp <= A xor B after 10 ns;
Z <= Tmp xor Cin after 10 ns; Cout Full Cin
Cout <= (A and B) or (Tmp and Cin) after 15 ns; Adder

W <= „0‟, „1‟ after 10 ns, „0‟ after 15 ns, „1‟ after 20 ns, Z
„0‟ after 28 ns, „1‟ after 40 ns, „0‟ after 50 ns;
Waveform

W t 0 10 15 20 28 40 50
driver v 0 1 0 1 0 1 0
W
(ns)
59
0 10 20 30 40 50 60 70
1.3. Asignación condicional a señal 4 .4
• Sintaxis:
[<label>:] <signal> <= [delay_type]
{<expression|waveform> when <boolean expression> else}
< expression|waveform> [when <boolean expression>];

• Ejemplos:
process (Sel, A, B)
begin
if Sel = „0‟ then
S <= A;
S <= A when Sel = „0‟ else B;
= else
process (Sel2, E1, E2)
begin
S <= B;
if Sel2 = “00” then
Equivalent end if;
S <= E1;
Process end process;
elsif Sel2 = “11” then
S <= E2;
else
null;
S <= E1 when Sel2 = “00” else
E2 when Sel2 = “11” else
unnafected when others;
= end if;
end process;
Equivalent
Process
 1.4. Asignación selectiva a señal 4 .4
• Sintaxis:
[<label>] with <expression> select
<signal> <= [delay_type]
{<expression|waveform> when <value>,}
<expression|waveform> when <value>;

• Ejemplos:

process (Op1, Op2, Operation)

with Operation select begin
Result <= Op1 + Op2 when add, case Operation is
Op1 - Op2 when subs, when add => Result <= Op1 + Op2;
Op1 and Op2 when andL, = when subs => Result <= Op1 - Op2;
Op1 or Or2 when orL; when andL => Result <= Op1 and Op2;
when orL => Result <= Op1 or Op2;
end case;
Equivalent end process;
Process
Type opcode is (add, subs, andL, orL);
Signal operation : opcode; 61
1.5. Componentes 4 .4
• Descripciones estructurales y jerárquicas utilizando componentes definidos en otras partes.
• Sintaxis de declaración de componente:
component <idname> [is]
[generic (<generic parameters list>);]
[port (<ports list>);]
end [component] [<idname>];

• Sintaxis para instanciación o referencia a componente:

<label>: <idname>
[generic map (<parameters association list>);]
[port map (<ports association list>);]

• Ejemplos:
Listas de asociación por:
• position
component example is U2 : example port map (X, Y, W, Z)
• name
port(a, b, c : in bit;
d : out bit); U2 : example port map
end component example; (d=>Z, a=>X, b=>Y, c=>W);
1.5. Componentes 4 .4
entity FullAdder is
begin
port(X, Y, CIn : in bit; U1 U3
Cout, Sum : out bit); A
end FullAdder;
X Half OrG COut
Y Adder B C
architecture structural of FullAdder is Half
component HalfAdder Adder
port(I1, I2 : in std_logic; CIn Sum
COut, Sum : out std_logic); U2
end component;
component OrG
port(I1, I2 : in std_logic; I1 I2 Sum Cout
O : out std_logic); 0 0 0 0
end component; 0 1 1 0
Listas de asociación
signal A, B, C : std_logic; 1 0 1 0
begin posicional
1 1 0 1
U1: HalfAdder port map (X, Y, A, B);
U2: HalfAdder port map (B, CIn, C, Sum); Sum <= I1 xor I2; Cout <= I1 and I2;
U3: OrG port map (O => COut, I1 => A, I2 => C);
end structural;
Lista de asociación nominal 63
1.6. Generate 4 .4
• Se usa para crear multiples repeticiones de instancias de componentes o de cualquier otra
sentencia concurrente.
<label>: {[for <range specification> | if <condition> ]}
• Sintaxis: generate
{<concurrent sentences>}
end generate; entity Register is Parallel in/out
generic (N: positive);
N-bits Register
port( Clk : in std_logic;
E : in std_logic_vector(N-1 downto 0);
• Ejemplo: S out std_logic_vector(N-1 downto 0));
end Register;
architecture structural of Register is
component DFF
E(N-1) E(N-2) E(0)
port (Clk : in std_logic;
E : in std_logic;
S : out std_logic);
DFF DFF DFF end component;
variable I : integer;
begin
GenReg: for I in N-1 downto 0 generate
Clk S(N-1) S(N-2) S(0) Reg: DFF port map(Clk, E(I), S(I));
end generate;
end structural;
1.7. Assert, Procedure call y Function call 4 .4
• El mismo uso y funcionamiento que su secuenciales equivalentes, pero en el contexto
concurrente. [label:] assert <boolean expression>
[report <string of characters>]
[severity (note | warning | error |failure);

• La “llamada a función” puede incluirse en cualquier expresión dentro de una sentencia

concurrente. function Check_Timing(min_time, max_time, clk, sig_to_test) returns boolean;

assert Check_Timing(min_time, max_time, clk, sig_to_test)

report “Timing error”
severity (warning);

• La llamada a un procedimiento en concurrente es como un proceso con los parámetros del

procedimiento en la lista de sensibilidad. [label:] <Procedure name> [(<parameters>)];
Check_Timing(min_time, max_time, clk, sig_to_test, testOK);
66
1.8. Procedure vs. Process en concurrente 4 .4
• Un proceso se puede modelar mediante su procedimiento equivalente
o Las señales de la lista de sensibilidad del proceso se convierten en parámetros del procedimiento
o Los parámetros del procedimiento serán todas las señales de E/S del bloque.

Signal rst, ck, d, q: std_logic; procedure FFD (signal rst, clk, d: in std_logic;
…/… signal q: out std_logic);
FFD: process (rst, clk); begin
begin if rst = „1‟ then
if rst = „1‟ then Q <= „0‟;
Parámetros formales
Q <= „0‟; elsif (clk‟event and clk=„1‟) then
elsif (clk‟event and clk=„1‟) then Q <= D;
Q <= D; end if; end if;
end if; end if; end procedure; D Flip-flop
end process; D Flip-flop
o Se declara en un package y se accede vía sentencia “Use”
o Definición y uso simultaneo o Uso por instanciación con parámetros actuales  Fácil reúso
o Usos repetidos  Cortar y pegar proceso o Para simular también se convierten a su procesos
 equivalentes 67
Componente y referencias
2 Modelado, simulación y síntesis 4 .4
package my_package is
type operation is (add, sub);
end my_package;
use work.my_package.all;
entity AddSub is
Port (signal a, b: in std_logic_vector(3 downto 0);
signal opcode : in operation;
signal sign : out std_logic;
signal z : out std_logic_vector(4 downto 0));
End entity AddSub;

Architecture Functional of AddSub is

Begin
Operate: process (a, b, opcode);
variable x, y : std_logic_vector(3 downto 0);
variable s : std_logic;
begin
if a >= b then x := a; y := b; s := „0‟;
else x := b; y := a; s := „1‟;
case opcode is
when add then z <= „0‟&x + „0‟&y; sign <=
„0‟;
when sub then z <= „0‟&x – „0‟&y; sign <= s;
end case
end process Operate;
2 Modelado, simulación y síntesis 4 .4
Sistema “test_bench” completo
Generación
Estímulos
Estímulos Módulo
Banco
a verificar
de pruebas
(Module under Test)
(Test Bench)
-MuT-

VHDL

VHDL
Analisis Respuestas
Resultados

Sistema “test_bench” completo

Generación
Estímulos
Estímulos Módulo
Banco
a verificar
de pruebas
(Module under Test)
(Test Bench)
-MuT-
Respuestas
VHDL VHDL

69
 2 Modelado, simulación y síntesis 4 .4
Modulo a verificar (MuT) Banco de pruebas
Module under Test (Test_Bench)
use work.my_package.all;
entity AddSub is
Port (signal a, b: in std_logic_vector(3 downto 0);
signal opcode : in operation;
signal sign : out std_logic;
signal z : out std_logic_vector(4 downto 0));
End entity AddSub;

Architecture Functional of AddSub is

Begin
Operate: process (a, b, opcode);
variable x, y : std_logic_vector(3 downto 0);
variable s : std_logic;
begin
if a >= b then x := a; y := b; s := „0‟;
else x := b; y := a; s := „1‟;
case opcode is
when add then z <= „0‟&x + „0‟&y; sign <=
„0‟;
when sub then z <= „0‟&x – „0‟&y; sign <= s;
end case
end process Operate; 70
End Architecture Functional;
 2 Modelado, simulación y síntesis 4 .4
Modulo a verificar (MuT) Banco de pruebas
Module under Test (Test_Bench)
use work.my_package.all;
entity AddSub is use work.my_package.all;
Port (signal a, b: in std_logic_vector(3 downto entity 0);TB_AddSub is end;
signal opcode : in operation;
signal sign : out std_logic; architecture Test_Bench of TB_AddSub is
signal z : out std_logic_vector(4 downto signal0));c, d : std_logic_vector(3 downto 0);
End entity AddSub; signal oper : operation; signal signo : std_logic;
signal res : std_logic_vector(4 downto 0);
Architecture Functional of AddSub is Begin
Module under Test
Begin MuT: entity work.AddSub(Functional)
Sistema “TB_AddSub”
Operate: process (a, b, opcode);completo port map (c, d, oper, signo, res);
variable x, y : std_logic_vector(3 downto 0);
Generación c,d Estímulos a,b
variable s : oper
std_logic; opcode Stimuli: process; Test vectors wavefroms
Estímulos
begin begin
if a >= b then x := a; y := b; s := „0‟; c <= “0110”; d <= “0011”; oper <= add;
Test Bench: MuT:
else x := b; y := a; s AddSub
:= „1‟; wait for 100 ns;
Stimuli: Process
case opcode is oper <= sub; wait for 100 ns;
VHDL

when add
Analisis signo Respuestas
then z <= „0‟&x
sign + „0‟&y; sign <= d <= “1001”; wait for 100 ns;
Result. res
„0‟; z VHDL oper <= add; wait;
when sub then z <= „0‟&x – „0‟&y; signend <= process
s; Stimuli;
end case
end process Operate; end Test_Bench;
End Architecture Functional;
2 Modelado, simulación y síntesis 4 .4
Banco de pruebas
(Test_Bench)
use work.my_package.all;
entity TB_AddSub is end;
architecture Test_Bench of TB_AddSub is
signal c, d : std_logic_vector(3 downto 0);
signal oper : operation; signal signo : std_logic;
signal res : std_logic_vector(4 downto 0);
Begin
Module under Test
MuT: entity work.AddSub(Functional)
port map (c, d, oper, signo, res);

Stimuli: process; Test vectors wavefroms

begin
c <= “0110”; d <= “0011”; oper <= add;
wait for 100 ns;
oper <= sub; wait for 100 ns;
d <= “1001”; wait for 100 ns;
oper <= add; wait;
end process Stimuli;
end Test_Bench;
2 Modelado, simulación y síntesis 4 .4
Ejercicio
¿Se podrían considerar equivalentes estos dos procesos de generación de estímulos para el
ejemplo que hemos visto?
Stimuli: process; Test vectors wavefroms
begin
c <= “0110”; d <= “0011”; oper <= add;
wait for 100 ns;
oper <= sub; wait for 100 ns;
d <= “1001”; wait for 100 ns;
oper <= add; wait;
end process Stimuli;

Stimuli: process; Test vectors wavefroms

begin
c <= “0110” after 0ns;
d <= “0011” after 0ns, “1001” after 200ns;
oper <= add after 0ns, sub after 100ns, add after 300ns;
wait for 100 ns;
wait for 100 ns;
wait for 100 ns;
wait;
end process Stimuli; 73
2 Modelado, simulación y síntesis 4 .4
Ejercicio (solución)
¿Se podrían considerar equivalentes estos dos procesos de generación de estímulos para el
ejemplo que hemos visto?
Respuesta: SI Stimuli: process; Test vectors wavefroms
begin
En el primer caso vamos definiendo los valores de c <= “0110”; d <= “0011”; oper <= add;
las entradas del módulo AddSub a medida que wait for 100 ns;
oper <= sub; wait for 100 ns;
avanza el tiempo de simulación. d <= “1001”; wait for 100 ns;
oper <= add; wait;
En el segundo proceso:
end process Stimuli;
- Definimos los valores de las entradas
Stimuli: process; Test vectors wavefroms
al principio y los cargamos en los begin
“drivers” de las distintas señales c <= “0110” after 0ns;
d <= “0011” after 0ns, “1001” after 200ns;
- Luego utilizamos sentencias “wait” oper <= add after 0ns, sub after 100ns, add after 300ns;
a fin de ir avanzando en periodos de wait for 100 ns;
wait for 100 ns;
100 ns para que los distintos valores wait for 100 ns;
se evalúen en AddSub cuando corres- wait;
ponda y produzcan resultados. end process Stimuli;
2 Modelado, simulación y síntesis 4 .4
entity ParallelAdder is
generic (n : natural := 4);
port ( X, Y : in std_logic_vector(n-1 downto 0);
Cin : in std_logic;
Z : out std_logic_vector(n-1 downto 0);
Cout : out std_logic);
End ParallelAdder ;

achitecture Functional of ParallelAdder is

Begin
process (X, Y, Cin);
variable C : std_logic_vector(n downto 0);
variable tmp : std_logic;
variable I : integer;
begin
C(0) := Cin;
for I in 0 to n-1 loop
tmp := X(I) xor Y(I);
Z(I) <= tmp xor C(I);
C(I+1) := (tmp and C(I)) or (X(I) and Y(I));
end loop;
Cout <= C(n);
end process;
end Functional;
2 Modelado, simulación y síntesis 4 .4
entity ParallelAdder is
generic (n : natural := 4);
port ( X, Y : in std_logic_vector(n-1 downto 0);
Cin : in std_logic;
Z : out std_logic_vector(n-1 downto 0);
Cout : out std_logic);
End ParallelAdder ;
Logic Simulation
achitecture Functional of ParallelAdder is
Begin
process (X,X Y, Cin);
Y
variable Cin
C : std_logic_vector(n downto 0);
Z
variable tmp : std_logic;
variable I : integer;
begin
C(0) :=
CoutCin;
for I in 0 to n-1 loop
tmp := X(I) xor Y(I);
Z(I) <= tmp xor C(I);
C(I+1) := (tmp and C(I)) or (X(I) and Y(I));
end loop;
Cout <= C(n);
end process;
end Functional;
2 Modelado, simulación y síntesis 4 .4
entity ParallelAdder is
generic (n : natural := 4);
port ( X, Y : in std_logic_vector(n-1 downto 0);
Cin : in std_logic;
Z : out std_logic_vector(n-1 downto 0);
Cout : out std_logic);
End ParallelAdder ;
Logic Simulation
achitecture Functional of ParallelAdder is
Begin
process (X,X Y, Cin);
Y
variable Cin
C : std_logic_vector(n downto 0);
Z
variable tmp : std_logic;
variable I : integer;
begin
C(0) :=
CoutCin; Cout
for I in 0 to n-1 loop
tmp := X(I) xor Y(I);
X Z(I) <= tmp xor C(I);
C(I+1) := (tmp and C(I)) or (X(I) and Y(I));
end loop;
Z
Y Cout <= C(n);
end process;
end
Cin Functional; Logic Synthesis
RESUMEN 4 .4
• Sentencias concurrentes en VHDL (dentro de architectures, blocks or entities)
 Sentencias seleccionadas:
• Process • Components • Assert
• signal assignments (uncond & cond.) • Generate • Functions & Procedures

• Modelado, simulación y síntesis en VHDL: conceptos y flujos básicos

• Algunos ejemplos sencillos en VHDL

Con esta sesión cerramos esta corta introducción al lenguaje VHDL para facilitar su
uso dentro del…

“Curso de Sistemas Digitales”

78