Ingeniería Electrónica

4to. ciclo Circuitos Digitales

Guía de Laboratorio 1
Compuertas lógicas en VHDL

Jefe de prácticas: Adrián Hinostroza

Coordinador del curso: Luz Adanaqué Infante

Integrantes
● Clever Antony Maylle Ambrocio
● Germán Alejandro Rosales Quino

2023-2

1
 Compuertas lógicas en VHDL
1. Introducción
Este laboratorio es una introducción a las compuertas lógicas las cuales son la base de
los circuitos digitales. Durante el desarrollo del laboratorio se utilizarán el software Vivado y
el lenguaje VHDL. Previo a la realización del laboratorio se deberá de realizar lo siguiente:

▪ Leer los capítulos del libro ”Fundamentos de sistemas digitales”, Floyd, 11va edición.

▪ 3.4 La compuerta NAND

▪ 5.3 La propiedad universal de las compuertas NAND y NOR

▪ Ver los siguientes videos tutoriales:

▪ VHDL Señales.

▪ VHDL Arquitectura flujo de datos.

▪ Vivado Tutorial Múltiples diseños

2. Indicaciones
▪ Las indicaciones del laboratorio son las siguientes:

▪ Test de entrada en la plataforma virtual CANVAS, 15 minutos de duración.

▪ Leer y entender claramente el enunciado de cada experimento.

▪ Realizar los experimentos. Escribir un breve comentario en cada código e imagen dada como

respuesta.

▪ Acudir al Jefe de prácticas en caso de dudas o consultas.

▪ El informe debe de contener el nombre de los integrantes del grupo, las res- puestas a las

preguntas planteadas, las evidencias solicitadas, observaciones, conclusiones y

referencias.

2
 ▪ Las respuestas deben ser debidamente justificadas, no deben de basarse en suposiciones ni

opiniones.

▪ Los diagramas esquemáticos presentados deberán ser elaborados utilizando software (Por

ejemplo VISIO, Multisim, Aplicaciones web, etc), no se aceptarán fotografías de

dibujos realizados a mano.

▪ Las fotografías deberían ser debidamente editadas para una correcta presentación.

▪ La entrega del informe es por medio de la plataforma virtual (CANVAS). NO SE ACEP-

TARÁ INFORMES ENVIADOS POR CORREO.

▪ CUALQUIER PLAGIO SERÁ REPORTADO Y SE ABRIRÁ UN PROCESO DISCIPLINARIO.

3. Orientaciones de seguridad
Leer el documento Uso del laboratorio.pdf en donde se detalla las responsabilidades del
instructor y de los alumnos durante el desarrollo de un laboratorio.

4. Experiencias
Experimento 1: Compuertas lógicas en VHDL
Instrucciones:

1. Realizar el diseñó y simulación de las compuertas lógicas AND, OR y NOT usando VHDL (Las
compuertas deben de estar en archivos .VHD independientes).

2. Usando Vivado generar los diagramas esquemáticos de las tres compuertas.

3. Realizar el diseño y simulación de los circuitos equivalentes (usando solo NANDs) de

las compuertas lógicas básicas AND, OR y NOT (Los tres circuitos deben de estar en
archivos .VHD independientes).

4. Usando Vivado generar los diagramas esquemáticos de los circuitos equivalentes.

Evidencias:

• Códigos VHDL. Copiar y pegar el código en esta guía.

3
El diseño de los circuitos de cada una de las compuertas lógicas es simple y sencillo. En la
arquitectura solo necesitamos usar el término de la compuerta en uso (and, or, not). En las
tablas 1, 2 y 3 se encuentra el código respectivo para cada una de las compuertas.

Tabla 1: Códigos VHDL para la compuerta AND

Compuerta AND

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity AND1 is entity tb_AND1 is

Port (A, B: in std_logic; -- Port ( );
C: out std_logic); end tb_AND1;
end AND1;
architecture Behavioral of tb_AND1 is
architecture Behavioral of AND1 is
component AND1
begin Port (A, B: in std_logic;
C: out std_logic);
C <= A and B; end component;

end Behavioral; signal A_s, B_s, C_s: std_logic;

begin

uut: AND1 port map(

A => A_s,
B => B_s,
C => C_s
);

process
begin

A_s <= '0';

B_s <= '0';
wait for 10ns;

A_s <= '0';

B_s <= '1';
wait for 10ns;

A_s <= '1';

4
 B_s <= '0';
wait for 10ns;

A_s <= '1';

B_s <= '1';
wait;

end process;

end Behavioral;

Tabla 2: Códigos VHDL para la compuerta OR

Compuerta OR

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity OR1 is entity tb_OR1 is

Port (A, B: in std_logic; -- Port ( );
C: out std_logic); end tb_OR1;
end OR1;
architecture Behavioral of tb_OR1 is
architecture Behavioral of OR1 is
component OR1
begin Port (A, B: in std_logic;
C: out std_logic);
C <= A or B; end component;

end Behavioral; signal A_s, B_s, C_s: std_logic;

begin

uut: OR1 port map(

A => A_s,
B => B_s,
C => C_s
);

5
 process
begin

A_s <= '0';

B_s <= '0';
wait for 10ns;

A_s <= '0';

B_s <= '1';
wait for 10ns;

A_s <= '1';

B_s <= '0';
wait for 10ns;

A_s <= '1';

B_s <= '1';
wait;

end process;

end Behavioral;

Tabla 3: Códigos VHDL para la compuerta NOT

Compuerta NOT

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity NOT1 is entity tb_NOT1 is

Port (A: in std_logic; -- Port ( );
C: out std_logic); end tb_NOT1;
end NOT1;
architecture Behavioral of tb_NOT1 is
architecture Behavioral of NOT1 is
component NOT1
begin Port (A: in std_logic;
C: out std_logic);
C <= not A; end component;

end Behavioral; signal A_s, C_s: std_logic;

6
 begin

uut: NOT1 port map(

A => A_s,
C => C_s
);

process
begin

A_s <= '0';

wait for 10ns;

A_s <= '1';

wait;

end process;

end Behavioral;

Para los circuitos equivalentes de dichas compuertas, utilizamos la equivalencia en NANDs

conocida de cada una, como se ve en la figura 1. Con ello, desarrollamos las tablas 4, 5 y 6
con los códigos.

Figura 1: Aplicación universal de las compuertas NAND (Floyd, 2006, p.284)

7
 Tabla 4: Códigos VHDL para el circuito equivalente de AND

Compuerta AND (usando NANDs)

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity NANDS_AND is entity tb_NANDS_AND is

Port (A, B: in std_logic; -- Port ( );
C: out std_logic); end tb_NANDS_AND;
end NANDS_AND;
architecture Behavioral of tb_NANDS_AND
architecture Behavioral of NANDS_AND is is

signal x: std_logic; component NANDS_AND

begin Port (A, B: in std_logic;
C: out std_logic);
x <= A nand B; end component;
C <= x nand x;
signal A_s, B_s, C_s: std_logic;
end Behavioral;
begin

uut: NANDS_AND port map(

A => A_s,
B => B_s,
C => C_s
);

process
begin

A_s <= '0';

B_s <= '0';
wait for 10ns;

A_s <= '0';

B_s <= '1';
wait for 10ns;

A_s <= '1';

B_s <= '0';
wait for 10ns;

8
 A_s <= '1';
B_s <= '1';
wait;

end process;

end Behavioral;

Tabla 5: Códigos VHDL para el circuito equivalente de OR

Compuerta OR (Usando NANDs)

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity NANDS_OR is entity tb_NANDS_OR is

Port (A, B: in std_logic; -- Port ( );
C: out std_logic); end tb_NANDS_OR;
end NANDS_OR;
architecture Behavioral of tb_NANDS_OR is
architecture Behavioral of NANDS_OR is
component NANDS_OR
signal x, y: std_logic; Port (A, B: in std_logic;
begin C: out std_logic);
end component;
x <= A nand A;
y <= B nand B; signal A_s, B_s, C_s: std_logic;

C <= x nand y; begin

end Behavioral; uut: NANDS_OR port map(

A => A_s,
B => B_s,
C => C_s
);

process
begin

A_s <= '0';

9
 B_s <= '0';
wait for 10ns;

A_s <= '0';

B_s <= '1';
wait for 10ns;

A_s <= '1';

B_s <= '0';
wait for 10ns;

A_s <= '1';

B_s <= '1';
wait;

end process;

end Behavioral;

Tabla 6: Códigos VHDL para el circuito equivalente de NOT

Compuerta NOT (usando NANDs)

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity NANDS_NOT is entity tb_NANDS_NOT is

Port (A: in std_logic; -- Port ( );
C: out std_logic); end tb_NANDS_NOT;
end NANDS_NOT;
architecture Behavioral of tb_NANDS_NOT
architecture Behavioral of NANDS_NOT is is

begin component NANDS_NOT

Port (A: in std_logic;
C <= A nand A; C: out std_logic);
end component;
end Behavioral;
signal A_s, C_s: std_logic;

begin

10
 uut: NANDS_NOT port map(
A => A_s,
C => C_s
);

process
begin

A_s <= '0';

wait for 10ns;

A_s <= '1';

wait;

end process;

end Behavioral;

• Diagramas esquemáticos RTL generados por Vivado.

En la tabla 7 podemos observar dichos diagramas. Notamos que los circuitos equivalentes
utilizan un número igual o mayor de compuertas. Con el NOT, su equivalente utiliza
igualmente una sola compuerta NAND, mientras que para el OR se usan tres nands.

Tabla 7: Diagramas esquemáticos RTL del experimento 1

Compuerta AND

11
 Compuerta OR

Compuerta NOT

Compuerta AND
(usando NANDs)

Compuerta OR
(usando NANDs)

Compuerta NOT
(usando NANDs)

• Ondas de simulación.

Como podemos observar en la tabla 8, se comprueba la equivalencia de los circuitos creados

con NANDs y las compuertas lógicas. Observamos pues que las señales de salida son
equivalentes.

Tabla 8: Ondas de simulación del experimento 1

12
Compuerta AND

Compuerta OR

Compuerta NOT

Compuerta AND
(usando NANDs)

Compuerta OR
(usando NANDs)

Compuerta NOT
(usando NANDs)

13
Experimento 2: Circuito combinatorio en VHDL

Figura 1: Diagrama esquemático de un circuito digital.

Instrucciones:

1. Diseñar y simular circuito mostrado en al Figura 1 en VHDL usando arquitectura de flujo de

datos y señales internas.

2. Usando Vivado generar el diagrama esquemático de la Síntesis.

3. Realizar el circuito equivalente utilizando compuertas NANDs y simplificar las inversiones en

cascada.
4. Diseñar y simular el circuito simplificado en VHDL.

5. Usando Vivado generar el diagrama esquemático del circuito simplificado.

Evidencias:

▪ Diagrama esquemático del circuito simplificado usando NANDs (El realizado previo a la
codificación en VHDL).

Para realizar el circuito equivalente con NANDs volvemos a utilizar las equivalencias de cada
compuerta que conocemos (Figura 1). Al final simplificamos dos inversiones de NANDs y
obtenemos el circuito de la figura 2.

Figura 2: Circuito simplificado con NANDs

▪ Códigos VHDL.

14
Haciendo uso de ambos diagramas, creamos los códigos VHDL mostrados en las tablas 9 y
10.

Tabla 9: Códigos VHDL para el circuito combinatorio

Circuito Combinatorio

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity exp2_a is entity tb_exp2_a is

Port (A, B, C: in std_logic; -- Port ( );
D: out std_logic); end tb_exp2_a;
end exp2_a;
architecture Behavioral of tb_exp2_a is
architecture Behavioral of exp2_a is -- declarar el componente a simular
component exp2_a
signal x, y, z: std_logic; Port (
begin A : in std_logic;
B,C : in std_logic;
x <= not(A); D : out std_logic
y <= B and x; );
z <= C and A; end component;
D <= y or z;
-- declarar señales de i/o
signal A_s, B_s, C_s, D_s: std_logic;
end Behavioral;
begin

-- instanciar el componente
uut: exp2_a port map(
-- i/o => señales
A => A_s,
B => B_s,
C => C_s,
D => D_s
);

-- estimulos

process
begin

15
 A_s <= '0';
B_s <= '0';
C_s <= '0';
wait for 5ns;

A_s <= '0';

B_s <= '0';
C_s <= '1';
wait for 5ns;

A_s <= '0';

B_s <= '1';
C_s <= '0';
wait for 5ns;

A_s <= '0';

B_s <= '1';
C_s <= '1';
wait for 5ns;

A_s <= '1';

B_s <= '0';
C_s <= '0';
wait for 5ns;

A_s <= '1';

B_s <= '0';
C_s <= '1';
wait for 5ns;

A_s <= '1';

B_s <= '1';
C_s <= '0';
wait for 5ns;

A_s <= '1';

B_s <= '1';
C_s <= '1';
wait;

end process;

end Behavioral;

Tabla 10: Códigos VHDL para el circuito combinatorio equivalente

16
 Circuito Combinatorio (usando NANDs)

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity exp2_b is entity tb_exp2_b is

Port (A, B, C: in std_logic; -- Port ( );
D: out std_logic); end tb_exp2_b;
end exp2_b;
architecture Behavioral of tb_exp2_b is
architecture Behavioral of exp2_b is -- declarar el componente a simular
component exp2_b
signal x, y, z: std_logic; Port (
begin A : in std_logic;
B,C : in std_logic;
x <= A nand A; D : out std_logic
y <= B nand x; );
z <= A nand C; end component;
D <= y nand z;
-- declarar señales de i/o
end Behavioral; signal A_s, B_s, C_s, D_s: std_logic;

begin

-- instanciar el componente
uut: exp2_b port map(
-- i/o => señales
A => A_s,
B => B_s,
C => C_s,
D => D_s
);

-- estimulos

process
begin

A_s <= '0';

B_s <= '0';

17
 C_s <= '0';
wait for 5ns;

A_s <= '0';

B_s <= '0';
C_s <= '1';
wait for 5ns;

A_s <= '0';

B_s <= '1';
C_s <= '0';
wait for 5ns;

A_s <= '0';

B_s <= '1';
C_s <= '1';
wait for 5ns;

A_s <= '1';

B_s <= '0';
C_s <= '0';
wait for 5ns;

A_s <= '1';

B_s <= '0';
C_s <= '1';
wait for 5ns;

A_s <= '1';

B_s <= '1';
C_s <= '0';
wait for 5ns;

A_s <= '1';

B_s <= '1';
C_s <= '1';
wait;

end process;

end Behavioral;

▪ Ondas de simulación.
Como se aprecia en la tabla 11, ambos circuitos nos proporcionan el mismo resultado,
validando entonces el circuito equivalente.

18
 Tabla 11: Ondas de simulación experimento 2.

Circuito Combinatorio

Circuito Combinatorio
(usando NANDs)

▪ Usando Vivado generar el diagrama esquemático de la Síntesis.

Podemos observar en la tabla 12 que el diagrama de síntesis para ambos circuitos es el

mismo.

Tabla 12: Diagrama esquemático de la síntesis del experimento 2

Circuito Combinatorio

Circuito Combinatorio
(usando NANDs)

▪ Usando Vivado generar el diagrama esquemático de la Implementación.

19
 En la tabla 13 se observa que no solo ambos circuitos cuentan con el mismo diagrama, sino
que se mantiene el generado en la síntesis.

Tabla 13: Diagrama esquemático de la implementación del experimento 2

Circuito Combinatorio

Circuito Combinatorio
(usando NANDs)

▪ Generar el reporte de utilización de recursos de la Implementación.

En la tabla 14 encontramos el reporte de utilización de recursos para ambos circuitos.

Destaca que ambos utilizan un solo LUT, y además ambos circuitos emplean la misma
cantidad de bonded IOB, cuatro.

Tabla 14: Reporte de utilización de recursos del experimento 2

Circuito Combinatorio Copyright 1986-2022 Xilinx, Inc. All Rights Reserved. Copyright
2022-2023 Advanced Micro Devices, Inc. All Rights Reserved.
-------------------------------------------------------------------------------------
--------------------------------------------------------
| Tool Version : Vivado v.2023.1 (win64) Build 3865809 Sun May
7 15:05:29 MDT 2023
| Date : Fri Sep 8 13:17:33 2023
| Host : LAPTOP-K66K892V running 64-bit major release
(build 9200)
| Command : report_utilization -file
C:/Users/germa/OneDrive/UTEC/digitales/lab1/utilization2_rep
ort.txt -name utilization_2
| Design : exp2_a

20
| Device : xc7a35tcpg236-1
| Speed File : -1
| Design State : Routed
-------------------------------------------------------------------------------------
--------------------------------------------------------

Utilization Design Information

Table of Contents
-----------------
1. Slice Logic
1.1 Summary of Registers by Type
2. Slice Logic Distribution
3. Memory
4. DSP
5. IO and GT Specific
6. Clocking
7. Specific Feature
8. Primitives
9. Black Boxes
10. Instantiated Netlists

1. Slice Logic
--------------

+-------------------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available |
Util% |
+-------------------------+------+-------+------------+-----------+-------+
| Slice LUTs | 1| 0| 0 | 20800 | <0.01 |
| LUT as Logic | 1| 0| 0 | 20800 | <0.01 |
| LUT as Memory | 0| 0| 0 | 9600 | 0.00 |
| Slice Registers | 0| 0| 0 | 41600 | 0.00 |
| Register as Flip Flop | 0 | 0 | 0 | 41600 | 0.00 |
| Register as Latch | 0 | 0 | 0 | 41600 | 0.00 |
| F7 Muxes | 0| 0| 0 | 16300 | 0.00 |
| F8 Muxes | 0| 0| 0 | 8150 | 0.00 |
+-------------------------+------+-------+------------+-----------+-------+
* Warning! LUT value is adjusted to account for LUT combining.

1.1 Summary of Registers by Type

--------------------------------

21
+-------+--------------+-------------+--------------+
| Total | Clock Enable | Synchronous | Asynchronous |
+-------+--------------+-------------+--------------+
|0 | _| -| -|
|0 | _| -| Set |
|0 | _| -| Reset |
|0 | _| Set | -|
|0 | _| Reset | -|
|0 | Yes | -| -|
|0 | Yes | -| Set |
|0 | Yes | -| Reset |
|0 | Yes | Set | -|
|0 | Yes | Reset | -|
+-------+--------------+-------------+--------------+

2. Slice Logic Distribution

---------------------------

+------------------------------------------+------+-------+------------+----------
-+-------+
| Site Type | Used | Fixed | Prohibited |
Available | Util% |
+------------------------------------------+------+-------+------------+----------
-+-------+
| Slice | 1| 0| 0 | 8150 | 0.01 |
| SLICEL | 1| 0| | | |
| SLICEM | 0| 0| | | |
| LUT as Logic | 1| 0| 0 | 20800 |
<0.01 |
| using O5 output only | 0| | | |
|
| using O6 output only | 1| | | |
|
| using O5 and O6 | 0| | | | |
| LUT as Memory | 0| 0| 0 | 9600 |
0.00 |
| LUT as Distributed RAM | 0| 0| | |
|
| LUT as Shift Register | 0| 0| | |
|
| Slice Registers | 0| 0| 0 | 41600 |
0.00 |
| Register driven from within the Slice | 0 | | |
| |
| Register driven from outside the Slice | 0 | | |
| |

22
| Unique Control Sets | 0| | 0 | 8150 |
0.00 |
+------------------------------------------+------+-------+------------+----------
-+-------+
* * Note: Available Control Sets calculated as Slice * 1, Review
the Control Sets Report for more information regarding control
sets.

3. Memory
---------

+----------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available | Util% |
+----------------+------+-------+------------+-----------+-------+
| Block RAM Tile | 0 | 0 | 0| 50 | 0.00 |
| RAMB36/FIFO* | 0 | 0 | 0| 50 | 0.00 |
| RAMB18 | 0| 0| 0| 100 | 0.00 |
+----------------+------+-------+------------+-----------+-------+
* Note: Each Block RAM Tile only has one FIFO logic available
and therefore can accommodate only one FIFO36E1 or one
FIFO18E1. However, if a FIFO18E1 occupies a Block RAM Tile,
that tile can still accommodate a RAMB18E1

4. DSP
------

+-----------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available | Util% |
+-----------+------+-------+------------+-----------+-------+
| DSPs | 0 | 0 | 0| 90 | 0.00 |
+-----------+------+-------+------------+-----------+-------+

5. IO and GT Specific
---------------------

+-----------------------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available |
Util% |
+-----------------------------+------+-------+------------+-----------+-------+
| Bonded IOB | 4| 0| 0| 106 | 3.77 |
| IOB Master Pads | 1| | | | |

23
| IOB Slave Pads | 2| | | | |
| Bonded IPADs | 0| 0| 0| 10 | 0.00 |
| Bonded OPADs | 0| 0| 0| 4 | 0.00 |
| PHY_CONTROL | 0| 0| 0| 5 | 0.00 |
| PHASER_REF | 0| 0| 0| 5 | 0.00 |
| OUT_FIFO | 0| 0| 0| 20 | 0.00 |
| IN_FIFO | 0| 0| 0| 20 | 0.00 |
| IDELAYCTRL | 0| 0| 0| 5 | 0.00 |
| IBUFDS | 0| 0| 0| 104 | 0.00 |
| GTPE2_CHANNEL | 0| 0| 0| 2 | 0.00 |
| PHASER_OUT/PHASER_OUT_PHY | 0 | 0 | 0| 20
| 0.00 |
| PHASER_IN/PHASER_IN_PHY | 0 | 0 | 0| 20 |
0.00 |
| IDELAYE2/IDELAYE2_FINEDELAY | 0 | 0 | 0| 250 |
0.00 |
| IBUFDS_GTE2 | 0| 0| 0| 2 | 0.00 |
| ILOGIC | 0| 0| 0| 106 | 0.00 |
| OLOGIC | 0| 0| 0| 106 | 0.00 |
+-----------------------------+------+-------+------------+-----------+-------+

6. Clocking
-----------

+------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available | Util% |
+------------+------+-------+------------+-----------+-------+
| BUFGCTRL | 0 | 0 | 0| 32 | 0.00 |
| BUFIO | 0 | 0 | 0| 20 | 0.00 |
| MMCME2_ADV | 0 | 0 | 0| 5 | 0.00 |
| PLLE2_ADV | 0 | 0 | 0| 5 | 0.00 |
| BUFMRCE | 0 | 0 | 0| 10 | 0.00 |
| BUFHCE | 0 | 0 | 0| 72 | 0.00 |
| BUFR | 0| 0| 0| 20 | 0.00 |
+------------+------+-------+------------+-----------+-------+

7. Specific Feature
-------------------

+-------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available | Util% |
+-------------+------+-------+------------+-----------+-------+
| BSCANE2 | 0 | 0 | 0| 4 | 0.00 |
| CAPTUREE2 | 0 | 0 | 0| 1 | 0.00 |
| DNA_PORT | 0 | 0 | 0| 1 | 0.00 |

24
 | EFUSE_USR | 0 | 0 | 0| 1 | 0.00 |
| FRAME_ECCE2 | 0 | 0 | 0| 1 | 0.00 |
| ICAPE2 | 0 | 0 | 0| 2 | 0.00 |
| PCIE_2_1 | 0 | 0 | 0| 1 | 0.00 |
| STARTUPE2 | 0 | 0 | 0| 1 | 0.00 |
| XADC | 0| 0| 0| 1 | 0.00 |
+-------------+------+-------+------------+-----------+-------+

8. Primitives
-------------

+----------+------+---------------------+
| Ref Name | Used | Functional Category |
+----------+------+---------------------+
| IBUF | 3 | IO |
| OBUF | 1 | IO |
| LUT3 | 1 | LUT |
+----------+------+---------------------+

9. Black Boxes
--------------

+----------+------+
| Ref Name | Used |
+----------+------+

10. Instantiated Netlists

-------------------------

+----------+------+
| Ref Name | Used |
+----------+------+

Circuito Combinatorio Copyright 1986-2022 Xilinx, Inc. All Rights Reserved. Copyright
(usando NANDs) 2022-2023 Advanced Micro Devices, Inc. All Rights Reserved.
-------------------------------------------------------------------------------------
--------------------------------------------------------
| Tool Version : Vivado v.2023.1 (win64) Build 3865809 Sun May
7 15:05:29 MDT 2023
| Date : Fri Sep 8 13:06:09 2023

25
| Host : LAPTOP-K66K892V running 64-bit major release
(build 9200)
| Command : report_utilization -file
C:/Users/germa/OneDrive/UTEC/digitales/lab1/utilization_repor
t.txt -name utilization_1
| Design : exp2_b
| Device : xc7a35tcpg236-1
| Speed File : -1
| Design State : Routed
-------------------------------------------------------------------------------------
--------------------------------------------------------

Utilization Design Information

Table of Contents
-----------------
1. Slice Logic
1.1 Summary of Registers by Type
2. Slice Logic Distribution
3. Memory
4. DSP
5. IO and GT Specific
6. Clocking
7. Specific Feature
8. Primitives
9. Black Boxes
10. Instantiated Netlists

1. Slice Logic
--------------

+-------------------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available |
Util% |
+-------------------------+------+-------+------------+-----------+-------+
| Slice LUTs | 1| 0| 0 | 20800 | <0.01 |
| LUT as Logic | 1| 0| 0 | 20800 | <0.01 |
| LUT as Memory | 0| 0| 0 | 9600 | 0.00 |
| Slice Registers | 0| 0| 0 | 41600 | 0.00 |
| Register as Flip Flop | 0 | 0 | 0 | 41600 | 0.00 |
| Register as Latch | 0 | 0 | 0 | 41600 | 0.00 |
| F7 Muxes | 0| 0| 0 | 16300 | 0.00 |
| F8 Muxes | 0| 0| 0 | 8150 | 0.00 |
+-------------------------+------+-------+------------+-----------+-------+
* Warning! LUT value is adjusted to account for LUT combining.

26
1.1 Summary of Registers by Type
--------------------------------

+-------+--------------+-------------+--------------+
| Total | Clock Enable | Synchronous | Asynchronous |
+-------+--------------+-------------+--------------+
|0 | _| -| -|
|0 | _| -| Set |
|0 | _| -| Reset |
|0 | _| Set | -|
|0 | _| Reset | -|
|0 | Yes | -| -|
|0 | Yes | -| Set |
|0 | Yes | -| Reset |
|0 | Yes | Set | -|
|0 | Yes | Reset | -|
+-------+--------------+-------------+--------------+

2. Slice Logic Distribution

---------------------------

+------------------------------------------+------+-------+------------+----------
-+-------+
| Site Type | Used | Fixed | Prohibited |
Available | Util% |
+------------------------------------------+------+-------+------------+----------
-+-------+
| Slice | 1| 0| 0 | 8150 | 0.01 |
| SLICEL | 1| 0| | | |
| SLICEM | 0| 0| | | |
| LUT as Logic | 1| 0| 0 | 20800 |
<0.01 |
| using O5 output only | 0| | | |
|
| using O6 output only | 1| | | |
|
| using O5 and O6 | 0| | | | |
| LUT as Memory | 0| 0| 0 | 9600 |
0.00 |
| LUT as Distributed RAM | 0| 0| | |
|
| LUT as Shift Register | 0| 0| | |
|

27
| Slice Registers | 0| 0| 0 | 41600 |
0.00 |
| Register driven from within the Slice | 0 | | |
| |
| Register driven from outside the Slice | 0 | | |
| |
| Unique Control Sets | 0| | 0 | 8150 |
0.00 |
+------------------------------------------+------+-------+------------+----------
-+-------+
* * Note: Available Control Sets calculated as Slice * 1, Review
the Control Sets Report for more information regarding control
sets.

3. Memory
---------

+----------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available | Util% |
+----------------+------+-------+------------+-----------+-------+
| Block RAM Tile | 0 | 0 | 0| 50 | 0.00 |
| RAMB36/FIFO* | 0 | 0 | 0| 50 | 0.00 |
| RAMB18 | 0| 0| 0| 100 | 0.00 |
+----------------+------+-------+------------+-----------+-------+
* Note: Each Block RAM Tile only has one FIFO logic available
and therefore can accommodate only one FIFO36E1 or one
FIFO18E1. However, if a FIFO18E1 occupies a Block RAM Tile,
that tile can still accommodate a RAMB18E1

4. DSP
------

+-----------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available | Util% |
+-----------+------+-------+------------+-----------+-------+
| DSPs | 0 | 0 | 0| 90 | 0.00 |
+-----------+------+-------+------------+-----------+-------+

5. IO and GT Specific
---------------------

+-----------------------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available |
Util% |

28
+-----------------------------+------+-------+------------+-----------+-------+
| Bonded IOB | 4| 0| 0| 106 | 3.77 |
| IOB Master Pads | 1| | | | |
| IOB Slave Pads | 2| | | | |
| Bonded IPADs | 0| 0| 0| 10 | 0.00 |
| Bonded OPADs | 0| 0| 0| 4 | 0.00 |
| PHY_CONTROL | 0| 0| 0| 5 | 0.00 |
| PHASER_REF | 0| 0| 0| 5 | 0.00 |
| OUT_FIFO | 0| 0| 0| 20 | 0.00 |
| IN_FIFO | 0| 0| 0| 20 | 0.00 |
| IDELAYCTRL | 0| 0| 0| 5 | 0.00 |
| IBUFDS | 0| 0| 0| 104 | 0.00 |
| GTPE2_CHANNEL | 0| 0| 0| 2 | 0.00 |
| PHASER_OUT/PHASER_OUT_PHY | 0 | 0 | 0| 20
| 0.00 |
| PHASER_IN/PHASER_IN_PHY | 0 | 0 | 0| 20 |
0.00 |
| IDELAYE2/IDELAYE2_FINEDELAY | 0 | 0 | 0| 250 |
0.00 |
| IBUFDS_GTE2 | 0| 0| 0| 2 | 0.00 |
| ILOGIC | 0| 0| 0| 106 | 0.00 |
| OLOGIC | 0| 0| 0| 106 | 0.00 |
+-----------------------------+------+-------+------------+-----------+-------+

6. Clocking
-----------

+------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available | Util% |
+------------+------+-------+------------+-----------+-------+
| BUFGCTRL | 0 | 0 | 0| 32 | 0.00 |
| BUFIO | 0 | 0 | 0| 20 | 0.00 |
| MMCME2_ADV | 0 | 0 | 0| 5 | 0.00 |
| PLLE2_ADV | 0 | 0 | 0| 5 | 0.00 |
| BUFMRCE | 0 | 0 | 0| 10 | 0.00 |
| BUFHCE | 0 | 0 | 0| 72 | 0.00 |
| BUFR | 0| 0| 0| 20 | 0.00 |
+------------+------+-------+------------+-----------+-------+

7. Specific Feature
-------------------

29
 +-------------+------+-------+------------+-----------+-------+
| Site Type | Used | Fixed | Prohibited | Available | Util% |
+-------------+------+-------+------------+-----------+-------+
| BSCANE2 | 0 | 0 | 0| 4 | 0.00 |
| CAPTUREE2 | 0 | 0 | 0| 1 | 0.00 |
| DNA_PORT | 0 | 0 | 0| 1 | 0.00 |
| EFUSE_USR | 0 | 0 | 0| 1 | 0.00 |
| FRAME_ECCE2 | 0 | 0 | 0| 1 | 0.00 |
| ICAPE2 | 0 | 0 | 0| 2 | 0.00 |
| PCIE_2_1 | 0 | 0 | 0| 1 | 0.00 |
| STARTUPE2 | 0 | 0 | 0| 1 | 0.00 |
| XADC | 0| 0| 0| 1 | 0.00 |
+-------------+------+-------+------------+-----------+-------+

8. Primitives
-------------

+----------+------+---------------------+
| Ref Name | Used | Functional Category |
+----------+------+---------------------+
| IBUF | 3 | IO |
| OBUF | 1 | IO |
| LUT3 | 1 | LUT |
+----------+------+---------------------+

9. Black Boxes
--------------

+----------+------+
| Ref Name | Used |
+----------+------+

10. Instantiated Netlists

-------------------------

+----------+------+
| Ref Name | Used |
+----------+------+

Experimento 3: Comparador de 1 bit

30
 x y eq
0 0 1
0 1 0
1 0 0
1 1 1

Cuadro 1: Tabla de verdad de comparación de 1 bit

Instrucciones:

1. Diseñar y simular la función de comparación de 1 bit usando arquitectura de flujo de

datos y señales internas.

2. Usando Vivado generar el diagrama esquemático de la Síntesis.

Evidencias:

• Códigos VHDL.

La tabla de verdad presentada nos muestra una compuerta XNOR. En este caso, conociendo
su expresión lógica (figura 3), podemos generar los códigos VHDL de la tabla 15.

Figura 3: Expresión lógica de la compuerta XNOR

Tabla 15: Códigos VHDL para el comparador de 1 bit

Comparador de 1 bit

Diseño Simulación

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity exp3 is entity tb_exp3 is

Port (x, y: in std_logic; -- Port ( );
eq: out std_logic); end tb_exp3;
end exp3;
architecture Behavioral of tb_exp3 is
architecture Behavioral of exp3 is

31
 component exp3
signal A, B: std_logic; Port (x, y: in std_logic;
begin eq: out std_logic);
end component;
A <= x and y;
B <= not x and not y; signal x_s, y_s, eq_s: std_logic;
eq <= A or B;
begin
end Behavioral;
uut: exp3 port map(
x => x_s,
y => y_s,
eq => eq_s
);

process
begin

x_s <= '0';

y_s <= '0';
wait for 10ns;

x_s <= '0';

y_s <= '1';
wait for 10ns;

x_s <= '1';

y_s <= '0';
wait for 10ns;

x_s <= '1';

y_s <= '1';
wait;

end process;

end Behavioral;

• Ondas de simulación.

La salida mostrada en la figura 4 es la misma que la de la tabla de verdad, corroborando

así nuestro circuito.

32
 Figura 4: Ondas de simulación comparador de 1 bit

• Generar el esquemático RTL

La figura 5 muestra la expresión lógica detallada previamente armada en un circuito.

Figura 5: Esquemático RTL comparador de 1 bit

• Usando Vivado generar el diagrama esquemático de la Síntesis.

Figura 6: Esquemático de la síntesis comparador de 1 bit

a[1]a[0] b[1]b[0] eq
00 00 1
01 01 1

33
 10 10 1
11 11 1
xx xx 0

Cuadro 2: Tabla de verdad de comparación de 2 bits

Experimento 4: Comparador de 2 bits

Instrucciones:

1. Diseñar y simular la función de comparación de 2 bits usando arquitectura de flujo

de datos y señales internas.

2. Usando Vivado generar el diagrama esquemático de la Síntesis.

Evidencias:
▪ Códigos VHDL.

El comparado de 2 bits no es nada más que dos comparadores de 1 bit unidos. Se compara
pues el primer bit de A con el primer bit de B, luego el segundo bit de A con el segundo bit
de B. La salida no es nada más que un AND de ambas lógicas. Usando lo desarrollado en el
experimento 3 generamos los códigos vistos en la tabla 16.

Tabla 16: Códigos VHDL para el comparador de 2 bits

Comparador de 1 bit

Diseño Simulación

library IEEE;
use IEEE.STD_LOGIC_1164.ALL; library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity exp4 is
Port (x,y:in std_logic_vector(1 downto entity tb_exp4 is
0); -- Port ( );
eq:out std_logic); end tb_exp4;
end exp4;
architecture Behavioral of tb_exp4 is
architecture Behavioral of exp4 is -- declarar el componente a simular
component exp4
signal A, B, C, D, E, F: std_logic; Port (
begin x,y : in std_logic_vector(1 downto 0);
eq : out std_logic

34
A <= not x(0) and not y(0); );
B <= x(0) and y(0); end component;
C <= A or B;
-- declarar señales de i/o
D <= not x(1) and not y(1); signal x_s, y_s: std_logic_vector(1 downto
E <= x(1) and y(1); 0);
F <= D or E; signal eq_s: std_logic;

eq <= C and F; begin

end Behavioral; -- instanciar el componente

uut: exp4 port map(
-- i/o => señales
x => x_s,
y => y_s,
eq => eq_s
);

-- estimulos

process
begin

x_s <= "00";

y_s <= "00";
wait for 5ns;

x_s <= "01";

y_s <= "01";
wait for 5ns;

x_s <= "10";

y_s <= "10";
wait for 5ns;

x_s <= "11";

y_s <= "11";
wait for 5ns;

x_s <= "11";

y_s <= "00";
wait for 5ns;

x_s <= "00";

35
 y_s <= "01";
wait for 5ns;

x_s <= "11";

y_s <= "10";
wait for 5ns;

x_s <= "01";

y_s <= "10";
wait;

end process;

end Behavioral;

▪ Ondas de simulación

La salida mostrada en la figura 7 es la misma que la de la tabla de verdad, corroborando así

nuestro circuito.
Figura 7: Ondas de simulación comparador de 2 bits

▪ Usando Vivado generar el diagrama esquemático de la Síntesis.

Figura 8: Esquemático de la síntesis comparador de 2 bits

36
▪ Diagrama esquemático RTL.

En la figura 9 se aprecia que el comparador de 2 bits está formado por dos comparadores de

1 bit unidos con un AND. Ello es lo que describimos desde un principio.

Figura 9: Esquemático RTL comparador de 2 bits

Preguntas:
▪ ¿Cuál es la diferencia entre el número de compuertas utilizadas en los experimentos
3 y 4?

En los experimentos 3 y 4 encontramos tres y siete compuertas respectivamente, lo cual,

nos indica que la diferencia es de 4 compuertas entre ambos. El comparador de 2 bits
utiliza dos comparadores de 1 bit y un AND, razón por la que tiene siete compuertas.

▪ ¿Cuál es la diferencia entre el número de LUTs utilizados en los experimentos 3 y 4?

En los experimentos 3 y 4 encontramos que ambos utilizan un solo LUT (figuras 10 y 11).
Por lo tanto, la diferencia de LUTs entre ambos experimentos es 0.

37
 Figura 10: Resumen del reporte de utilización de recursos del experimento 3

Figura 11: Resumen del reporte de utilización de recursos del experimento 4

Experimento 5: Función lógica final

Instrucciones:

1. Realizar el experimento 3 y 4 utilizando las compuertas NANDs.

Evidencias:

▪ Código VHDL.
Para obtener los circuitos equivalentes de ambos experimentos, volvemos a hacer uso
de las equivalencias en NAND de las compuertas lógicas descritas en la figura 1.

RETO1 RETO2

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity nands_comparador is entity reto2 is

Port ( x,y:in std_logic; Port (x,y:in std_logic_vector(1 downto
eq:out std_logic); 0);
end nands_comparador; eq:out std_logic);

38
 end reto2;
architecture Behavioral of
nands_comparador is architecture Behavioral of reto2 is

signal A,B,C,D: std_logic; signal A, B, C, D, E, F,G,H: std_logic;

begin
begin
A<= x(0) nand C;
A<= x nand C; B<= y(0) nand C;
B<= y nand C; C<= x(0) nand y(0);
C<= x nand y; D<= A nand B;
D<= A nand B;
eq<= D nand D; E<= x(1) nand G;
F<= y(1) nand G;
G<= x(1) nand y(1);
H<= E nand F;
end Behavioral;
eq <= D nand H;

end Behavioral;

▪ Test Bench.

RETO 1 RETO 2

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;

entity tb_comparador_nands is entity tb_reto2 is

-- Port ( ); -- Port ( );
end tb_comparador_nands; end tb_reto2;

architecture Behavioral of architecture Behavioral of tb_reto2 is

tb_comparador_nands is -- declarar el componente a simular
component reto2
component nands_comparador is Port (
Port (x,y:in std_logic; x,y : in std_logic_vector(1 downto 0);
eq:out std_logic); eq : out std_logic
end component; );
end component;
signal x_s: std_logic;

39
signal y_s: std_logic; -- declarar señales de i/o
signal eq_s:std_logic; signal x_s, y_s: std_logic_vector(1
downto 0);
begin signal eq_s: std_logic;

DUT: nands_comparador port map( begin

x => x_s,
y => y_s, -- instanciar el componente
eq => eq_s uut: reto2 port map(
); -- i/o => señales
x => x_s,
process y => y_s,
begin eq => eq_s
);
x_s <= '0';
y_s <= '0'; -- estimulos
wait for 10ns;
process
begin
x_s <= '0';
y_s <= '1'; x_s <= "00";
wait for 10ns; y_s <= "00";
wait for 5ns;
x_s <= '1';
y_s <= '0'; x_s <= "01";
wait for 10ns; y_s <= "01";
wait for 5ns;
x_s <= '1';
y_s <= '1'; x_s <= "10";
wait; y_s <= "10";
wait for 5ns;
end process;
x_s <= "11";
end Behavioral; y_s <= "11";
wait for 5ns;

x_s <= "11";

y_s <= "00";
wait for 5ns;

x_s <= "00";

y_s <= "01";
wait for 5ns;

x_s <= "11";

y_s <= "10";
wait for 5ns;

40
 x_s <= "01";
y_s <= "10";
wait;

end process;

end Behavioral;

▪ Diagrama esquemático generado por Vivado.

Reto 1

Reto 2

▪ Ondas de simulación

Obtenemos los mismos resultados que en los experimentos 3 y 4, comprobando ambos

circuitos.

RETO 1

41
 RETO 2

➔ Proceso de la síntesis e implementación

● Esquemático de la síntesis.

Reto 1

Reto 2

● Device y Package

Reto 1 Reto 2

42
 Device Device

Package Package

● Constrains

Reto 1 Reto 2

43
 set_property PACKAGE_PIN U16 [get_ports set_property PACKAGE_PIN U16 [get_ports
eq] eq]
set_property PACKAGE_PIN V17 [get_ports set_property PACKAGE_PIN V17 [get_ports
x] x0]
set_property PACKAGE_PIN V16 [get_ports set_property PACKAGE_PIN V16 [get_ports
y] x1]
set_property IOSTANDARD LVCMOS33 set_property PACKAGE_PIN w17 [get_ports
[get_ports eq] y0]
set_property IOSTANDARD LVCMOS33 set_property PACKAGE_PIN w16 [get_ports
[get_ports x] y1]
set_property IOSTANDARD LVCMOS33 set_property IOSTANDARD LVCMOS33
[get_ports y] [get_ports eq]
set_property IOSTANDARD LVCMOS33
[get_ports x0]
set_property IOSTANDARD LVCMOS33
[get_ports x1]
set_property IOSTANDARD LVCMOS33
[get_ports y0]
set_property IOSTANDARD LVCMOS33
[get_ports y1]

➔ Evidencias del reto

44
 Referencias
[1] Thomas L Floyd. Digital Fundamentals, 11/e. Pearson Education, 2015.

[2] Ronald J Tocci and Neal S Widmer. Sistemas digitales: principios y aplicaciones. Pearson
Educación, 2003.
s

45
 Rúbrica de Evaluación
Competencia Formular, sintetizar e implementar compuertas lógicas básicas usando Viva- do
y VHDL
Curso Circuitos Digitales Ciclo 4
Actividad Compuertas lógicas en VHDL Sesión 1
Nombre y apellido
Periodo 2023-2
del Alumno

Sección: Fecha Jefe de pr´acticas Adrian Hinostroza

Documentos de evaluación
Laboratorio X Taller Proyecto Otros

Requiere No
CRITERIOS DE EVALUACIÓN Excelente Bueno
Mejora aceptable
TEST DE ENTRADA

Grado de conocimiento del tema del laboratorio y del

4 3 2 1, 0
procedimiento
SESIÓN DE LABORATORIO

Diseñar y simular las compuertas lógicas AND, OR,

2.5 1.5 1 0
NOT usando VHDL
Diseñar y simular la versión equivalente con NANDs
2.5 1.5 1 0
usando VHDL
Diseñar y simular la función lógica final 10 5 2 0
INFORME DE TRABAJO DE EQUIPO

Presenta el informe puntualmente de acuerdo a lo

0.5 0 0 0
establecido
ACTITUDES

Participa con entusiasmo y seguridad (Puntualidad,

intervenciones, orden, limpieza y redacción.) Culmi- 0.5 0 0 0
na el laboratorio en el tiempo previsto.
PUNTAJE TOTAL

Comentario al alumno

Descripción de la evaluación
Excelente Completo entendimiento y realización de la actividad, cumpliendo todos los requerimientos

46
Bueno Entiende y realiza la actividad cumpliendo la mayoría de los requerimientos
Requiere
Bajo entendimiento de la actividad cumpliendo pocos requerimientos
Mejora
No
No demuestra entendimiento de la actividad
aceptable

47