S10 S10-Material

Diseño de Sistemas
Computacionales para
Aplicación Específica
Sesión 10
Ciclo: Agosto 2021
Logro de la sesión
Al final de la sesión el estudiante estará en capacidad de:
• Comprender el concepto de modularidad y su importancia en el diseño digital.
• Comprender el concepto de instanciación de componentes.
• Distribuir el diseño de un sistema complejo en componentes.
• Emplear el lenguaje VHDL para instanciar componentes con o son parámetros

genéricos.
• Emplear el lenguaje VHDL para instanciar componentes de forma iterativa.
DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

Contenido de la sesión:
• Concepto de modularidad
• Concepto de instanciación
• Diseño modular en VHDL
• Código estructural usando componentes
• Instanciación de componentes que contienen parámetros
• Instanciación iterativa de componentes
• Observaciones adicionales

1.- CONCEPTOS Y DEFINICIONES
1.1.- Modularidad
¿Qué es modularidad?

1.1.- Modularidad
La modularidad puede definirse como el grado en que los componentes de un sistema

pueden ser separados y, después, pueden ser recombinados nuevamente.
Por ejemplo, un programa escrito en lenguaje C es modular cuando se delega las tareas a
diferentes funciones, en lugar de llevar a cabo todo el procesamiento en la función principal. Es
posible mejorar la modularidad del programa, separando las tareas no solamente en
funciones, sino también en archivos, de manera conveniente (cabeceras, librerías, drivers, etc.).
La modularidad brinda diversas ventajas en el diseño de un sistema. Entre ellas destacan.
• Mayor organización y legibilidad en el diseño.

• Permite dividir un sistema grande y complejo en múltiples sub-sistemas (bloques)
relativamente simples.
• Permite re-utilizar bloques que se han diseñado previamente.

1.1.- Modularidad

1.2.- Instanciación
En los lenguajes de programación orientada a objetos, tales como Java o C++, es posible crear elementos
con características específicas. A este conjunto de características particulares se le conoce como CLASE, y
a cada uno de los elementos creados con este grupo de características se le conoce como OBJETO.
Cuando se crea un OBJETO que pertenece a una CLASE específica (es decir, con un conjunto de
características determinadas), se dice que estamos instanciando dicho objeto.
Por un lado, el conjunto de características de un objeto (la CLASE) se construye una sola vez. Por otro lado,
es posible crear o instanciar una infinita cantidad de objetos de una misma clase.
El lenguaje VHDL permite instanciar elementos conocidos como componentes. En este caso particular, en
lugar de “crear una clase”, lo que se hace es construir la implementación del componente una sola vez. Al
igual que con los objetos, los componentes pueden ser instanciados una infinidad de veces.

1.2.- Instanciación
Componente “Homero” Instanciaciones de “Homero”

2.- CÓDIGO ESTRUCTURAL
2.1.- Diseño modular en VHDL
El lenguaje VHDL nos brinda recursos para llevar a cabo diseños complejos mediante el uso
de código organizado en “módulos”.
El objetivo principal del diseño modular es permitir que “bloques” comunes de código puedan ser
re-usados y compartidos.
Usualmente, estos bloques comunes de código son escritos en forma de

componentes (COMPONENTS), funciones (FUNCTIONS), o procedimientos (PROCEDURES),
los cuales pueden ser colocados en un paquete (PACKAGE), el cual es finalmente compilado en
una librería (LIBRARY).

2.2.- Código estructural en VHDL
Teniendo en cuenta los objetivos de nuestro curso, para el estudio del diseño modular,
solamente abordaremos el uso de los bloques conocidos como componentes
(COMPONENTS).
El estilo de código que separa un diseño VHDL en componentes, instancia “copias” de dichos
componentes y los interconecta en un archivo aparte, se conoce como código estructural.
En el lenguaje VHDL, para poder utilizar un componente (COMPONENT),

hace falta llevar a cabo 03 pasos:
1) Implementación del componente (archivo VHD)

2) Declaración del componente
3) Instanciación del componente

2.2.- Código estructural en VHDL
Para ilustrar cada uno de los pasos mencionados anteriormente se empleará un ejemplo
aplicativo simple.
Imagine que se desea diseñar el circuito combinacional que se muestra en la imagen inferior.
En lugar de escribir todo el código VHDL en un solo archivo, organizaremos el circuito en 03
componentes: compuerta NOT, compuerta NAND de 02 entradas y compuerta NAND de 03
entradas.
A continuación se detalla el procedimiento de diseño.

2.3.- Implementación de componentes en VHDL
• El primer paso es escribir el código VHDL de cada uno de los componentes de manera
convencional.
• Para esto se recomienda, primero, escribir el código del componente en un archivo VHD con
el nombre del componente, y asignar un nombre específico a la ENTIDAD y a la
ARQUITECTURA, de modo que no cause conflicto con los archivos VHD que se crearán más
adelante.
• Luego, se debe establecer el archivo creado como entidad TOP, compilar el código y
verificar que el diseño es correcto.
• Se debe repetir el procedimiento con cada uno de los componentes que se va a utilizar.
• A continuación, se muestra el código correspondiente a los archivos de cada uno de los

componentes de nuestro ejemplo.




2.4.- Declaración de componentes en VHDL
Una vez que los componentes han sido implementados, debemos declararlos e instanciarlos
en el archivo VHD donde se desea utilizarlos. Este archivo VHD, considerado el principal, es el
que contiene a la entidad TOP, la cual se llama así por estar en el nivel más alto de la jerarquía.
Imaginemos que, en nuestro ejemplo, el archivo VHD que contiene la entidad TOP se llama
“project.vhd” y es ahí donde deseamos utilizar los componentes. En ese caso, debemos
realizar la declaración y la instancia de los componentes en el archivo “project.vhd”.
Para declarar un componente, la declaración debe realizarse en la sección de declaraciones

dentro del bloque ARCHITECTURE (al igual que las señales). Además, se debe seguir una
sintaxis idéntica a la de un segmento ENTITY:
COMPONENT nombre_componente IS
PORT(
nombre_puerto : modo_señal tipo_señal;
nombre_puerto : modo_señal tipo_señal;
…);
END COMPONENT;

2.5.- Instanciación de componentes en VHDL
Instanciar un componente puede definirse como crear un objeto que tiene todas las
características del componente. De hecho, la instancia de componentes tiene una sintaxis
que nos hace recordar a los lenguajes de programación orientados a objetos (Java, C++).
La sintaxis para la instancia de un componente es la siguiente:
etiqueta: nombre_componente PORT MAP (lista_puertos);
La lista de puertos (lista_puertos) indica la conexión entre los pines del componente y las
entradas, salidas o señales que se encuentran a nivel local (en el archivo VHD donde se
instancia los componentes).
Existen dos maneras de describir la lista de puertos:

• Mapeo posicional (por posición)
• Mapeo nominal (por nombre)
A continuación se explica cada una de estas maneras.

Imaginemos que tenemos el inversor de nuestro ejemplo declarado en la entidad TOP, tal
como se muestra:
COMPONENT inverter IS
PORT (a: IN STD_LOGIC; b: OUT STD_LOGIC);
END COMPONENT;
Si deseamos instanciar el inversor, conectar su entrada “a” a una señal “x”, y conectar su
salida “b” a una señal “y”, podemos hacerlo mediante mapeo posicional, empleando la
siguiente sintaxis:
U1: inverter PORT MAP (x, y);
En el caso del mapeo posicional, los puertos “x” e “y” corresponden a “a” y “b”,
respectivamente. Para utilizar esta forma, debemos respetar el orden de las entradas/salidas
del componente.

Una manera alternativa de describir el mapeo de los puertos es mediante mapeo nominal.
En este caso es necesario utilizar, de manera explícita, los nombres de las entradas y salidas
del componente.
Por ejemplo, para el caso del inversor que mostramos anteriormente:
U1: inverter PORT MAP (a => x, b => y);
El mapeo posicional es más fácil de escribir, pero el mapeo nominal es menos proclive a
error. Además, los puertos de salida pueden dejarse “al aire”, usando la palabra clave OPEN.
U2: mi_circuito PORT MAP (a => x, b => y, w => OPEN, d => z);
En las siguientes páginas se muestra el código en el archivo “project.vhd”, el cual contiene la

entidad TOP del proyecto. En este archivo se deben realizar las declaraciones y las instancias
de los componentes.
De esta manera, hemos completado el diseño de un circuito lógico combinacional, empleando

código estructural.



2.6.- Ejemplo aplicativo
Para reforzar lo aprendido, se resolverá un ejemplo aplicativo que emplea 03 componentes

relativamente simples: un divisor de frecuencia, un circuito anti-rebotes y un contador
ascendente/descendente.
La estructura del sistema se muestra en la imagen inferior. El objetivo de este ejemplo es

distribuir el diseño en 04 archivos VHD: 03 componentes y un archivo principal (el que contiene
la entidad TOP). El código resultante se muestra en las siguientes diapositivas.

--Declaracion de librerias
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;
--Declaracion de la entidad
ENTITY frequency_divider IS
PORT(
clk_in: IN std_logic;
clk_div: OUT std_logic
);
END frequency_divider;
--Definicion de arquitectura
ARCHITECTURE frequency_divider OF frequency_divider IS
SIGNAL count: unsigned(19 downto 0);
BEGIN
--Divisor de frecuencia
PROCESS(clk_in)
BEGIN
if(rising_edge(clk_in)) then
if(count = x"7A11F") then
count <= x"00000";
clk_div <= '1’;
else
count <= count + x"00001";
clk_div <= '0’;
end if;
end if;
END PROCESS;
END frequency_divider;

LIBRARY ieee;
ENTITY debouncer IS
PORT(
clk, sw_in: IN std_logic;
sw_in_clean: OUT std_logic
);
END debouncer;
ARCHITECTURE debouncer OF debouncer IS
SIGNAL a, b, c, d: std_logic;
BEGIN
--Registros en serie
PROCESS(clk)
BEGIN
if(rising_edge(clk)) then
a <= sw_in;
b <= a;
c <= b;
d <= c;
end if;
END PROCESS;
--Compuerta AND
sw_in_clean <= b AND c AND d;
END debouncer;

LIBRARY ieee;
ENTITY up_down_counter IS
PORT(
up_ndown: IN std_logic;
clk: IN std_logic;
q: OUT unsigned(3 downto 0)
);
END up_down_counter;
ARCHITECTURE up_down_counter OF up_down_counter IS
SIGNAL count: unsigned(3 downto 0);
BEGIN
--Contador ascendente/descendente
PROCESS(clk)
BEGIN
if(up_ndown = '1') then
count <= count + "0001";
else
count <= count - "0001";
end if;
end if;
END PROCESS;
--Conexión con la salida

q <= count;

--Declaracion de librerias COMPONENT frequency_divider IS

LIBRARY ieee; PORT(
USE ieee.std_logic_1164.all; clk_in: IN std_logic;
USE ieee.numeric_std.all; clk_div: OUT std_logic
);
END COMPONENT;
ENTITY Circuito_Ejemplo IS COMPONENT debouncer IS
PORT( PORT(
clk, button, dir: IN std_logic; clk, sw_in: IN std_logic;
counter: OUT unsigned(3 downto 0) sw_in_clean: OUT std_logic
); );
END COMPONENT;
END Circuito_Ejemplo;
--Declaración de señales
--Definicion de arquitectura SIGNAL clk_div, button_clean: std_logic;
ARCHITECTURE Circuito_Ejemplo OF Circuito_Ejemplo IS
BEGIN
--Declaración de componentes comp_01: frequency_divider PORT MAP(clk, clk_div);
comp_02: debouncer PORT MAP(clk_div, button, button_clean);
COMPONENT up_down_counter IS comp_03: up_down_counter PORT MAP(dir, button_clean, counter);
PORT(
up_ndown: IN std_logic; END Circuito_Ejemplo;
clk: IN std_logic;
q: OUT unsigned(3 downto 0)
);
END COMPONENT;

3.- USO DE PARÁMETROS CON CÓDIGO ESTRUCTURAL
3.1.- Componentes con parámetros genéricos
Cuando se ha creado un componente que contiene parámetros genéricos, y éste es

instanciado en otro archivo, los parámetros tomarán el valor que se les asignó por defecto.
En ocasiones, se desea instanciar a un componente múltiples veces, pero con diferentes

parámetros de configuración. En este caso debe hacerse una modificación en la sintaxis
utilizada para instanciar al componente:
etiqueta: nombre_componente GENERIC MAP (lista_parametros)

PORT MAP(lista_puertos);
Por ejemplo, si declaramos un componente Bin_To_Gray (conversor de binario a Gray) y

deseamos que tenga 16 bits, entonces debemos instanciarlo como se muestra a continuación:
Bin2Gray: Bin_To_Gray GENERIC_MAP(n => 16) PORT MAP (b => entrada, g => salida);

Como ejemplo aplicativo, vamos a modificar el código del ejemplo anterior. En lugar de emplear
un contador ascendente/descendente de 04 bits, utilizaremos un contador genérico de ‘n’ bits, el
cual deseamos configurar para que tenga una salida de 08 bits.
El diagrama de bloques de este circuito se muestra en la imagen inferior. Para realizar los
cambios, solamente es necesario modificar los archivo VHD correspondientes al contador
ascendente/descendente y a la entidad TOP. Los archivos modificados se muestran en las
siguientes diapositivas.

LIBRARY ieee;
ENTITY up_down_counter IS
GENERIC(n: integer:= 4);
PORT(
clk: IN std_logic;
q: OUT unsigned(n-1 downto 0)
);
ARCHITECTURE up_down_counter OF up_down_counter IS
CONSTANT UNO: unsigned(n-1 downto 0) := (0 => '1', OTHERS => '0');

SIGNAL count: unsigned(n-1 downto 0);
BEGIN
--Contador ascendente/descendente
PROCESS(clk)
BEGIN
if(up_ndown = '1') then
count <= count + UNO;
else
count <= count - UNO;
end if;
end if;
END PROCESS;
--Conexión con la salida

q <= count;

--Declaracion de librerias COMPONENT frequency_divider IS

LIBRARY ieee; PORT(
USE ieee.std_logic_1164.all; clk_in: IN std_logic;
USE ieee.numeric_std.all; clk_div: OUT std_logic
);
END COMPONENT;
ENTITY Circuito_Ejemplo IS COMPONENT debouncer IS
PORT( PORT(
clk, button, dir: IN std_logic; clk, sw_in: IN std_logic;
counter: OUT unsigned(7 downto 0) sw_in_clean: OUT std_logic
); );
END Circuito_Ejemplo; END COMPONENT;
--definicion de arquitectura --Declaración de señales

ARCHITECTURE Circuito_Ejemplo OF Circuito_Ejemplo IS SIGNAL clk_div, button_clean: std_logic;
--Declaración de componentes BEGIN
COMPONENT up_down_counter IS comp_01: frequency_divider PORT MAP(clk, clk_div);

GENERIC(n: integer:= 4); comp_02: debouncer PORT MAP(clk_div, button, button_clean);
PORT( comp_03: up_down_counter GENERIC MAP(8) PORT MAP(dir, button_clean, counter);
clk: IN std_logic; END Circuito_Ejemplo;
q: OUT unsigned(n-1 downto 0)
);
END COMPONENT;

3.2.- Instanciación iterativa de componentes
Algunos circuitos, relativamente complejos, están conformados por una gran cantidad de
componentes de un mismo tipo, los cuales se encuentran interconectados entre sí. Esto es
particularmente cierto para los circuitos que se encargan de realizar operaciones matemáticas a
alta velocidad (e.g. sumadores y multiplicadores paralelos).
Como ejemplo demostrativo, diseñaremos un sumador de 04 bits, el cual está basado en un

componente al que llamaremos full_adder (sumador completo de un bit). La implementación
interna de este componente se muestra en la imagen inferior. El código VHDL correspondiente al
componente full_adder se muestra en la siguiente diapositiva.

LIBRARY ieee;
ENTITY full_adder IS
PORT(
a, b, carry_in: IN std_logic;
sum, carry_out: OUT std_logic
);
END full_adder;
ARCHITECTURE full_adder OF full_adder IS
SIGNAL s1, s2, s3, s4: std_logic;
BEGIN
s1 <= a XOR b;
sum <= s1 XOR carry_in;
s2 <= s1 AND carry_in;

s3 <= a AND b;
carry_out <= s2 OR s3;
END full_adder;

Una vez que el componente full_adder ha sido implementado, el siguiente paso es instanciarlo
04 veces, e interconectar los componentes tal y como se muestra en la imagen inferior.
Debe notarse que, la salida carry_out de un sumador se conecta con la entrada carry_in del
sumador que se encuentra inmediatamente después. El circuito resultante presenta dos
entradas de 04 bits ‘X’ e ‘Y’, una entrada de un bit “C_IN”, una salida de 04 bits ‘S’ y una salida
de un bit “C_OUT”.
Por conveniencia, emplearemos una señal tipo vector para conectar los “carries” del circuito.

--declaracion de librerias
LIBRARY ieee; BEGIN
fa0: full_adder PORT MAP(x(0), y(0), c_in, s(0), carries(0));
fa1: full_adder PORT MAP(x(1), y(1), carries(0), s(1), carries(1));
--declaracion de la entidad fa2: full_adder PORT MAP(x(2), y(2), carries(1), s(2), carries(2));
ENTITY full_adder_04_bits IS fa3: full_adder PORT MAP(x(3), y(3), carries(2), s(3), c_out);
PORT(
x, y: IN std_logic_vector(3 downto 0); END full_adder_04_bits;
c_in: IN std_logic;
s: OUT std_logic_Vector(3 downto 0);
c_out: OUT std_logic
);
END full_adder_04_bits;
--definicion de arquitectura
ARCHITECTURE full_adder_04_bits OF full_adder_04_bits IS
--Declaración de componentes
COMPONENT full_adder IS
PORT(
);
END COMPONENT;
SIGNAL carries: std_logic_vector(2 downto 0);

Del código anterior, se puede notar que existe un patrón de repetición en la instanciación de los
componentes “fa1” y “fa2”. Sin embargo, este patrón no se presenta en la instanciación de “fa0”
y “fa3”.
Para aprovechar el uso de sentencias iterativas se debe tener un patrón de repetición que se
presente en una gran parte del circuito. Por esta razón, agregaremos dos elementos más al
vector “carries” y los conectaremos a los puntos correspondientes a “c_in” y “c_out”.
Con este cambio ya es posible aplicar la sentencia iterativa FOR GENERATE.
En las siguientes diapositivas se muestra los cambios realizados.

LIBRARY ieee; BEGIN
--Declaracion de la entidad fa2: full_adder PORT MAP(x(2), y(2), carries(2), s(2), carries(3));
ENTITY full_adder_04_bits IS fa3: full_adder PORT MAP(x(3), y(3), carries(3), s(3), carries(4));
PORT(
x, y: IN std_logic_vector(3 downto 0); carries(0) <= c_in;
c_in: IN std_logic; c_out <= carries(4);
s: OUT std_logic_Vector(3 downto 0);
c_out: OUT std_logic END full_adder_04_bits;
);
PORT(
);
END COMPONENT;

LIBRARY ieee; BEGIN
g1: for i in 0 to 3 generate
fax: full_adder PORT MAP(x(i), y(i), carries(i), s(i), carries(i + 1));
--declaracion de la entidad end generate;
ENTITY full_adder_04_bits IS
PORT( carries(0) <= c_in;
x, y: IN std_logic_vector(3 downto 0); c_out <= carries(4);
c_in: IN std_logic;
s: OUT std_logic_Vector(3 downto 0); END full_adder_04_bits;
c_out: OUT std_logic
);
PORT(
);
END COMPONENT;

La nueva versión del código presenta la ventaja de ser fácilmente escalable. Es decir, si se
desea extender el diseño para construir un sumador de ‘n’ bits, esto se puede lograr fácilmente.
En la siguiente diapositiva se presenta el código VHDL correspondiente a un sumador genérico

de ‘n’ bits, construido en base al componente full_adder, tal como el que se muestra en la
imagen inferior.

LIBRARY ieee; --Declaración de señales
USE ieee.std_logic_1164.all; SIGNAL carries: std_logic_vector(n downto 0);
--Declaracion de la entidad BEGIN

ENTITY full_adder_n_bits IS
GENERIC(n: integer := 4); g1: for i in 0 to n-1 generate
PORT( fax: full_adder PORT MAP(x(i), y(i), carries(i), s(i), carries(i + 1));
x, y: IN std_logic_vector(n-1 downto 0); end generate;
c_in: IN std_logic;
s: OUT std_logic_Vector(n-1 downto 0);
c_out: OUT std_logic carries(0) <= c_in;
); c_out <= carries(n);
END full_adder_n_bits; END full_adder_n_bits;
ARCHITECTURE full_adder_n_bits OF full_adder_n_bits IS
PORT(
);
END COMPONENT;

4.- OBSERVACIONES ADICIONALES
4.1.- Restricciones en la instanciación de componentes
En las sesiones anteriores de nuestro curso hemos establecido que existen dos tipos de
sentencia: sentencia concurrente (WHEN simple, WHEN con selector, FOR GENERATE, entre
otros.) y sentencia secuencial (IF-ELSE, CASE, FOR LOOP, entre otros).
Por un lado, las sentencias secuenciales únicamente se pueden utilizar dentro de un PROCESS;
por otro lado, las sentencias concurrentes únicamente se pueden utilizar fuera de los PROCESS.
Esto nos hace plantearnos la pregunta ¿A qué tipo de sentencia pertenece la instanciación de un
componente? ¿Concurrente o secuencial?
La instanciación de un componente en VHDL se considera una sentencia concurrente, por lo

cual no puede utilizarse dentro de un PROCESS.
Por esta razón utilizamos la sentencia FOR GENERATE para el diseño del sumador genérico, ya
que no es posible utilizar la sentencia FOR LOOP (una sentencia secuencial).

4.2.- Entidad TOP
El diseño de sistemas digitales mediante el uso de código estructural también se conoce como
diseño jerárquico. Esto se debe a que es común organizar un sistema complejo en bloques, los
cuales se distribuyen en niveles o jerarquías.
Cuando se emplea esta distribución, un bloque que se encuentra en un nivel superior instancia a
uno o más bloques que se encuentra en un nivel inferior de la jerarquía. Para ilustrar mejor esto,
mostraremos la representación en niveles de un par de ejemplos vistos en clase.
Representación jerárquica del ejemplo con contador ascendente/descendente

4.2.- Entidad TOP
Representación jerárquica del ejemplo “contador de bits en alto”.

4.2.- Entidad TOP
En una representación jerárquica, siempre existirá un bloque que se encuentra en la parte más
alta de la jerarquía, el cual inicia la instanciación de los demás bloques. Debido a su ubicación
en la cima de la jerarquía, este bloque también recibe el nombre de bloque TOP o entidad TOP
(“top” en Inglés quiere decir cima o punto más alto).
Asimismo, los bloques que se encuentran en la parte más baja de la jerarquía son comúnmente
llamados bloques BOTTOM (“bottom” en inglés quiere decir fondo o punto más bajo).
Cuando se realiza un diseño en VHDL, es necesario indicar al sintetizador la ubicación de la

entidad TOP, de manera que pueda generar el circuito deseado sin ninguna ambigüedad.

4.3.- Metodologías de diseño
Una vez que se conocen los conceptos de diseño jerárquico, bloque TOP y bloque BOTTOM, ya
se hablar de mtodologías de diseño.
Cuando se organiza un sistema en bloques y jerarquías (niveles), se plantean 02 posibles

metodologías para llevar a cabo el diseño del sistema:
• Metodología Top-Down (de arriba hacia abajo)

• Metodología Bottom-Up (de abajo hacia arriba)
A continuación se presentará una breve descripción de cada una de estas metodologías de

diseño.

En la metodología de diseño Top-Down, se define el bloque del nivel TOP y se identifican los
sub-bloques necesarios para para construir el bloque de nivel TOP. Luego, se subdividen los
sub-bloques, hasta llegar a los sub-bloques BOTTOM, los cuales no pueden ser divididos.
Esta metodología de diseño es la que utilizan por defecto quienes se inician en el diseño digital
con VHDL, ya que, inicialmente, no cuentan con un repertorio de componentes.

En la metodología de diseño Bottom-Up, primero se identifican los sub-bloques BOTTOM que

tenemos a nuestra disposición. Luego, construimos sub-bloques más complejos del diseño,
empleando los sub-bloques BOTTOM.
Esta metodología de diseño es particularmente útil cuando el diseñador cuenta con un repertorio
(o librería) de componentes, los cuales puede aprovechar.

5.- CONCLUSIONES
• La modularidad permite organizar un diseño en bloques reutilizables, lo cual puede ahorrar tiempo
de desarrollo al diseñador, además de hacer el código más ordenado y legible.
• Los bloques reutilizables de hardware, empleados en el código estructural, se conocen como

componentes.
• Para poder utilizar un componente es necesario implementar, declarar e implementar dicho

componente.
• La instanciación de componentes puede emplearse en conjunto con los parámetros genéricos para
obtener diseños más versátiles.
• La metodología principal de diseño jerárquico que se empleará en este curso es la Top-Down.

6.- REFERENCIAS
[1] Stephen Brown & Zvonko Vranesic, Fundamentos de lógica digital con
diseño VHDL, Segunda Edición, McGraw Hill, 2006.
[2] Volnei A. Pedroni, Circuit Design with VHDL, Third Edition, The MIT
Press, 2020.
[3] Frank Vahid, Digital Design with RTL Design, VHDL and Verilog, John
Wiley & Sons, Second Edition, 2011.

7.- PREGUNTAS

S10 S10-Material

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

S10 S10-Material

Cargado por

Copyright:

Formatos disponibles

Diseño de Sistemas

Al final de la sesión el estudiante estará en capacidad de:

• Comprender el concepto de modularidad y su importancia en el diseño digital.

• Comprender el concepto de instanciación de componentes.

• Distribuir el diseño de un sistema complejo en componentes.

• Emplear el lenguaje VHDL para instanciar componentes con o son parámetros

• Emplear el lenguaje VHDL para instanciar componentes de forma iterativa.

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

La modularidad puede definirse como el grado en que los componentes de un sistema

La modularidad brinda diversas ventajas en el diseño de un sistema. Entre ellas destacan.

• Mayor organización y legibilidad en el diseño.

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

Componente “Homero” Instanciaciones de “Homero”

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

Usualmente, estos bloques comunes de código son escritos en forma de

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

En el lenguaje VHDL, para poder utilizar un componente (COMPONENT),

1) Implementación del componente (archivo VHD)

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

A continuación se detalla el procedimiento de diseño.

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

• A continuación, se muestra el código correspondiente a los archivos de cada uno de los

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

Para declarar un componente, la declaración debe realizarse en la sección de declaraciones

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

La sintaxis para la instancia de un componente es la siguiente:

etiqueta: nombre_componente PORT MAP (lista_puertos);

Existen dos maneras de describir la lista de puertos:

A continuación se explica cada una de estas maneras.

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

U1: inverter PORT MAP (x, y);

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

Por ejemplo, para el caso del inversor que mostramos anteriormente:

U1: inverter PORT MAP (a => x, b => y);

En las siguientes páginas se muestra el código en el archivo “project.vhd”, el cual contiene la

De esta manera, hemos completado el diseño de un circuito lógico combinacional, empleando

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

Para reforzar lo aprendido, se resolverá un ejemplo aplicativo que emplea 03 componentes

La estructura del sistema se muestra en la imagen inferior. El objetivo de este ejemplo es

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

--Conexión con la salida

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

--Declaracion de librerias COMPONENT frequency_divider IS

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

Cuando se ha creado un componente que contiene parámetros genéricos, y éste es

En ocasiones, se desea instanciar a un componente múltiples veces, pero con diferentes

etiqueta: nombre_componente GENERIC MAP (lista_parametros)

Por ejemplo, si declaramos un componente Bin_To_Gray (conversor de binario a Gray) y

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

DISEÑO DE SISTEMAS COMPUTACIONALES S10.s10 – Código estructural

CONSTANT UNO: unsigned(n-1 downto 0) := (0 => '1', OTHERS => '0');