UNIVERSIDAD NACIONAL DE SAN AGUSTÍN

FACULTAD DE PROCESOS Y SERVICIOS

ESCUELA DE INGENIERÍA ELECTRÓNICA

MICROELECTRONICA

Laboratorio 1

Integrantes:
- Cuadros Palomino, Leonardo Daniel
- Fraquet Quispe, Marco Andre
- Gomez Torres, Jhordam Maxwell
- Zevallos Huanca, Javier David

Ingeniero:
Prof. PhD. Alexander B. Hilario T
Contents
1 Objetivos 2

2 Programación en VHDL 2
2.1 Introducción a VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Construcción del modelo VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Placa FPGA Nexys4 DDRTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3 Desarrollo de la práctica 5
3.1 Problema 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.1.1 Código y circuito lógico del restador completo de 1 bit. . . . . . . . . . . . . 7
3.2 Restador completo de 4 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2.1 Circuito Lógico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2.2 Código VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2.3 Código Test-Bench VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2.4 Simulación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.5 Creación de archivo XDC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.6 Simulación Post-Implementación . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.7 Generación de archivo bitsream . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3 Problema 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3.1 Codigo VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3.2 Circuito Lógico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3.3 Test-Bench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3.4 Simulación de la ALU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.3.5 Archivo XDC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.3.6 Simulación despues de la implementación . . . . . . . . . . . . . . . . . . . . 17
3.3.7 Generación del archivo bitstream . . . . . . . . . . . . . . . . . . . . . . . . . 18

4 Conclusiones y Sugerencias 19

1
1 Objetivos
• Introducción a programación VHDL para FPGAs
• Aprender a escribir test − benches en VHDL
• Aprender el flujo de diseño en Vivado: Síntesis, simulación y generación del Bistream
• Aprender como asignar pins de entrada y salida del FPGA y cargar Bitstream en el Nexys-4
DDR Artix-7 FPGA Board.

2 Programación en VHDL
2.1 Introducción a VHDL
VHDL es un lenguaje de especificación definido por el IEEE utilizado para describir circuitos
digitales y para la automatización de diseño electrónico. VHDL es acrónimo proveniente de la
combinación de dos acrónimos: VHSIC (Very High Speed Integrated Circuits) y HDL (Hardware
Description Language).
Aunque puede ser usado de forma general para describir cualquier circuito digital se usa principalmente
para programar PLD (Programable Logic Device - Dispositivo Lógico Programable), FPGA (Field
Programmable Gate Array), ASIC y similares VHDL no es un lenguaje de programación, por
ello conocer su sintaxis no implica necesariamente saber diseñar con él. VHDL es un lenguaje de
descripción de hardware, que permite describir circuitos síncronos y asíncronos. Para realizar esto
debemos:
• Pensar en puertas y biestables, no en variables ni funciones
• Evitar bucles combinacionales y relojes condicionados
• Saber que parte del circuito es combinacional y cuál secuencial.
¿Por qué usar un lenguaje de descripción de hardware?
• Poder descubrir problemas en el diseño antes de su implementación física.
• La complejidad de los sistemas electrónicos crece exponencialmente, es necesaria una herramienta
que trabaje con el ordenador.
• Permite que más de una persona trabaje en el mismo proyecto.
En particular VHDL permite tanto una descripción de la estructura del circuito (descripción a partir
de subcircuitos más sencillos), como la especificación de la funcionalidad de un circuito utilizando
formas familiares a los lenguajes de programación.

2
2.2 Construcción del modelo VHDL
Un diseño VHDL describe un sistema único en un solo archivo. Dentro del archivo hay dos partes
que describen el sistema: la entidad y la arquitectura. La entidad describe la interfaz con el sistema
(es decir, las entradas y salidas) y la arquitectura describe el comportamiento. La funcionalidad
de VHDL (por ejemplo, operadores, tipos de señal, funciones, etc.) se define en el paquete. Los
paquetes se agrupan dentro de una biblioteca. IEEE define el conjunto básico de funcionalidades
para VHDL en el paquete estándar. Este paquete está contenido dentro de una biblioteca llamada
IEEE. La inclusión de la biblioteca y el paquete se establece al comienzo de un archivo VHDL antes
de la entidad y la arquitectura.

Paquete

Entidad

Arquitectura

2.3 Placa FPGA Nexys4 DDRTML

La placa Nexys4 DDR es una plataforma de desarrollo de circuito digital completa y lista para usar
basada en la última matriz de puertas programables de campo Artix-7TM (FPGA) de Xilinx®.
Posee un FPGA de alta capacidad, memorias externas y colección de USB, Ethernet y otros puertos,
el DDR Nexys4 puede albergar diseños que van desde circuitos combinacionales introductorios hasta
potentes procesadores integrados. Varios periféricos incorporados, que incluyen un acelerómetro, un
sensor de temperatura, un micrófono digital MEM, un amplificador de altavoz y varios dispositivos
de E / S permiten que el Nexys4 DDR se use para una amplia gama de diseños sin necesidad de
otros componentes. El FPGA Artix-7 está optimizado para la lógica de alto rendimiento y ofrece
más capacidad, mayor rendimiento.

Figure 1: Tarjeta Nexys4 DDR

3
Figure 2: Dispositivos de E / S de uso general en el Nexys4 DDR.

4
3 Desarrollo de la práctica
3.1 Problema 1
Escriba el código en VHDL de un restador completo de 1 bit utilizando ecuaciones lógicas.
• Para la realización de este problema lo primero que haremos será la creación de un proyecto,
teniendo como base la plataforma de evaluación Artyx 7.

Figure 3: Selección de la plataforma de evaluación Artyx 7

Para poder continuar y desarrollar el código necesitamos desarrollar el mapa de Karnaugh del
restador completo de 1 bit. Para este caso tenemos nuestra señal A y B las cuales deseamos
restar, pero también tenemos otra señal más de entrada, que sería nuestro acarreo inicial Bin ,
aparte tenemos nuestras salidas Bout y DIF , quedando la tabla de verdad de la siguiente
manera.

5
 Bin X Y Bout DIF
0 0 0 0 0
0 0 1 1 1
0 1 0 0 1
0 1 1 0 0
1 0 0 1 1
1 0 1 1 0
1 1 0 0 0
1 1 1 1 1

Table 1: Tabla de verdad para un Restador de 1 bit completo.

• Mapas de Karnaugh Bout : • Mapa de karnaugh de DIF :

xy xy
00 01 11 10 00 01 11 10
Cin Cin
0 0 1 0 0 0 0 1 0 1

1 1 1 1 0 1 1 0 1 0

Del mapa de Karnaugh tenemos el acarreo Del mapa de Karnaugh tenemos la

Bout : Bout = xy + Bin xy + Bin x y diferencia DIF :
Bout = xy + Bin (xy + x y) DIF = xyBin + xyBin + x yBin + xyBin
Bout = xy + Bin (x ⊕ y) DIF = Bin (xy + xy) + Bin (x y + xy)
DIF = Bin (x ⊕ y) + Bin (x ⊕ y)
DIF = Bin ⊕ (x ⊕ y)

6
3.1.1 Código y circuito lógico del restador completo de 1 bit.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity restador_completo_1bit is
Port ( X: in std_logic;
Y: in std_logic;
Bin: in std_logic;
DIFF: out std_logic;
Bout: out std_logic);
end restador_completo_1bit;

architecture Behavioral of restador_completo_1bit is

signal A_out: std_logic;

signal B_out: std_logic;
signal C_out: std_logic;
signal D_out: std_logic;

begin
A_out<=X xor Y;
DIFF<=A_out xor Bin;

C_out<=(not X) and Y;
D_out<=Bin and (not A_out);
Bout<=C_out or D_out;

end Behavioral;

Figure 4: Circuito lógico del Restador Completo de 1 Bit.

7
3.2 Restador completo de 4 bits
Es una concatenación de 4 restadores binarios completos de 1 bit, la concatenación se realiza
a través de los terminales del acarreo negativo entrante (Binput ) y de salida (Boutput ).
3.2.1 Circuito Lógico

Figure 5: Representación esquemática del restador de 4 bits

Figure 6: Vista interna de cada módulo restador de 4 bits

3.2.2 Código VHDL

entity restador4B is
Port ( Cin : in STD_LOGIC;
a : in STD_LOGIC_VECTOR (3 downto 0);
b : in STD_LOGIC_VECTOR (3 downto 0);
S : out STD_LOGIC_VECTOR (3 downto 0); --Diferencia
Cout : out STD_LOGIC);
end restador4B;

architecture Behavioral of restador4B is

--Utilzamos el restador completo de 1 bit realizado anteriormente
COMPONENT restador_completo_1bit
Port ( X: in std_logic;
Y: in std_logic;
Bin: in std_logic;

8
 DIFF: out std_logic;
Bout: out std_logic);
END COMPONENT;

SIGNAL t: std_logic_vector(3 downto 1);

begin
--Mapeo por posiciones
FA1: restador_completo_1bit PORT MAP (a(0), b(0), Cin, S(0), t(1));
FA2: restador_completo_1bit PORT MAP (a(1), b(1), t(1), S(1), t(2));
FA3: restador_completo_1bit PORT MAP (a(2), b(2), t(2), S(2), t(3));
FA4: restador_completo_1bit PORT MAP (a(3), b(3), t(3), S(3), Cout);

end Behavioral;

3.2.3 Código Test-Bench VHDL

entity restador4B_tb is
-- Port ( );
end restador4B_tb;

architecture Behavioral of restador4B_tb is

COMPONENT restador4B
Port ( Cin : in STD_LOGIC;
a : in STD_LOGIC_VECTOR (3 downto 0);
b : in STD_LOGIC_VECTOR (3 downto 0);
S : out STD_LOGIC_VECTOR (3 downto 0); --Diferencia
Cout : out STD_LOGIC);
END COMPONENT;

--INPUTS
signal Cin_s: std_logic;
signal a_s: STD_LOGIC_VECTOR (3 downto 0);
signal b_s: STD_LOGIC_VECTOR (3 downto 0);

--OUTPUTS
signal S_s: STD_LOGIC_VECTOR (3 downto 0);
signal Cout_s: std_logic;
begin
restador4B_comp:
COMPONENT restador4B
PORT MAP(Cin=>Cin_s,
a=>a_S,
b=>b_S,
S=>S_s,
Cout=>Cout_s);

Cin_s<='0', -- overflow

9
 '1' AFTER 1400 ns; -- saturate

a_s<="1111", -- 0
-- "1010" AFTER 100 ns, -- 10
-- "0100" AFTER 300 ns, -- 4
-- "0110" AFTER 700 ns, -- 6
-- "0111" AFTER 800 ns, -- 7
-- "0101" AFTER 1000 ns, -- 5
-- "0000" AFTER 1400 ns, -- 0
-- "1001" AFTER 1500 ns, -- 9
-- "1110" AFTER 1700 ns, -- 14
-- "1101" AFTER 2100 ns, -- 13
-- "0010" AFTER 2200 ns, -- 2
"1110" AFTER 2400 ns; -- 14

b_s<="0000", -- 0
"0001" AFTER 100 ns, -- 1
"1000" AFTER 200 ns, -- 8
"0110" AFTER 400 ns, -- 6
"1000" AFTER 500 ns, -- 8
"0111" AFTER 600 ns, -- 7
"0000" AFTER 700 ns, -- 0
"1101" AFTER 800 ns, -- 13
"1000" AFTER 900 ns, -- 8
"1000" AFTER 1000 ns, -- 8
"0110" AFTER 1100 ns, -- 6
"1000" AFTER 1200 ns, -- 8
"1001" AFTER 1300 ns, -- 9
"0000" AFTER 1400 ns, -- 0
"1101" AFTER 1500 ns, -- 13
"1000" AFTER 1600 ns, -- 8
"0110" AFTER 1800 ns, -- 6
"1000" AFTER 1900 ns, -- 8
"1001" AFTER 2000 ns, -- 9
"0000" AFTER 2100 ns, -- 0
"0001" AFTER 2200 ns, -- 1
"1100" AFTER 2300 ns, -- 12
"0011" AFTER 2400 ns, -- 3
"0000" AFTER 2500 ns, -- 0
"1100" AFTER 2600 ns, -- 12
"1111" AFTER 2700 ns; -- 15

end Behavioral;

10
3.2.4 Simulación
Ejecutamos la simulación de comportamiento y verificar el diseño.

Figure 7: Run Behavioral Simulation for 3000ns

3.2.5 Creación de archivo XDC

Asignaremos las entradas con switches y las salidas con leds, con ayuda del manual de la
tarjeta Nexys4 DDR que se muestra en la Figura 2.

Figure 8: Archivo XDC para la asignación de I/O

3.2.6 Simulación Post-Implementación

En esta etapa de simulación posterior a la implementación, es un tipo de emulación más
cercana a la descarga real del diseño en el dispositivo.

11
 Figure 9: Run Post-Implementation Timing Simulation for 3000 ns

3.2.7 Generación de archivo bitsream

Figure 10: Visualización de reporte tras la generación de bitstream

3.3 Problema 2
Diseño de la unidad aritmetica y logica (ALU) que implemente las funciones descritas como se
muestra en la tabla 2

Control Instrucción Operación

000 Add Suma de A+B+Cin
001 Sub Resta de A-B-Cin
010 Or A or B
011 And A and B
100 Shl Desplazamiento a la Izquierda
101 Shr Dezplazamiento a la derecha
110 Rol Rotación a la izquierda
111 Ror Rotación a la derecha

Table 2: Instrucciones del ALU

3.3.1 Codigo VHDL

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.all;
use ieee.std_logic_arith.all;

12
entity ALU is
Port ( CN : in STD_LOGIC_VECTOR (2 downto 0);
A : in STD_LOGIC_VECTOR (3 downto 0);
B : in STD_LOGIC_VECTOR (3 downto 0);
Cin : in STD_LOGIC;
S : out STD_LOGIC_VECTOR (3 downto 0); --Salida
Cout : out STD_LOGIC);
end ALU;

architecture Behavioral of ALU is

signal Saux: STD_LOGIC_VECTOR (4 downto 0);

begin
process(CN,Saux,A,B,Cin)
begin
if (CN = "000" ) then -- SUMA
Saux <= '0'&A + B + Cin; ;
S <= Saux(3 downto 0);
Cout<= Saux(4);
elsif (CN = "001") then -- RESTA
Saux <= '0'&A - B - Cin; ;
S <= Saux(3 downto 0);
Cout<= Saux(4);
elsif (CN = "010") then -- OR
S <= A or B;
elsif (CN = "011" ) then --AND
S <= A and B;
elsif (CN = "100") then --DES IZQUI 1
S <= A (2 downto 0)&'0';
elsif (CN = "101") then -- DES DERE 1
S <= '0'& A (3 downto 1);
elsif (CN = "110") then -- ROT IZ
S <= A(2 downto 0)& A(3);
else
S <= A(0)& A(3 downto 1); -- ROT DE
end if;
end process;
end Behavioral;

13
3.3.2 Circuito Lógico

Figure 11: Circuito Equivalente de la ALU

3.3.3 Test-Bench
Generamos el test−bench para poder simular todas las posibles combinaciones en las entradas
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.all;
use ieee.std_logic_arith.all;

entity ALU_tb is
-- Port ( );
end ALU_tb;

architecture Behavioral of ALU_tb is

COMPONENT ALU
Port ( CN : in STD_LOGIC_VECTOR (2 downto 0);
A : in STD_LOGIC_VECTOR (3 downto 0);
B : in STD_LOGIC_VECTOR (3 downto 0);
Cin : in STD_LOGIC;
S : out STD_LOGIC_VECTOR (3 downto 0); --Salida
Cout : out STD_LOGIC);
END COMPONENT;

--INPUTS
signal CN_s: STD_LOGIC_VECTOR (2 downto 0);
signal Cin_s: std_logic;
signal A_s: STD_LOGIC_VECTOR (3 downto 0);
signal B_s: STD_LOGIC_VECTOR (3 downto 0);

--OUTPUTS
signal S_s: STD_LOGIC_VECTOR (3 downto 0);
signal Cout_s: std_logic;

14
begin

ALU_comp:
COMPONENT ALU
PORT MAP(CN=>CN_s,
A=>A_S,
B=>B_S,
Cin=>Cin_s,
S=>S_s,
Cout=>Cout_s);

CN_s <= "000", -- modo1

"001" AFTER 500 ns, -- modo2
"010" AFTER 1200 ns, -- modo3
"011" AFTER 1500 ns, -- modo4
"100" AFTER 1800 ns, -- modo5
"101" AFTER 2000 ns, -- modo5
"110" AFTER 2300 ns, -- modo7
"111" AFTER 2700 ns; -- modo8

Cin_s<='0', -- Acarreo 0 para suma

'1' AFTER 300 ns, -- Acarreo 1 para suma
'0' AFTER 500 ns, -- Acarreo 0 para resta
'1' AFTER 900 ns, -- Acarreo 0 para suma
'0' AFTER 1200 ns; -- Acarreo 0 para resta

A_s<="0000", -- 0
"0101" AFTER 100 ns, -- 85
"0101" AFTER 300 ns, -- -27
"0101" AFTER 500 ns,
"0000" AFTER 700 ns, -- 0
"1111" AFTER 800 ns, -- 85
"0101" AFTER 1000 ns, -- -27
"0000" AFTER 1400 ns, -- 0
"0110" AFTER 1500 ns,
"0101" AFTER 1600 ns, -- 85
"1110" AFTER 1700 ns, -- -27
"0110" AFTER 1800 ns, -- 6
"1000" AFTER 1900 ns, -- -56
"1001" AFTER 2000 ns, -- -105
"0110" AFTER 2100 ns, -- 0
"0101" AFTER 2200 ns, -- 29
"1100" AFTER 2300 ns, -- -56
"0011" AFTER 2400 ns, -- 56
"1011" AFTER 2500 ns, -- 6
"1100" AFTER 2600 ns, -- -56
"0111" AFTER 2700 ns, -- 105
"1001" AFTER 2800 ns;

15
 B_s<="0000", -- 0
"0001" AFTER 100 ns, -- 29
"1000" AFTER 200 ns, -- 56
"0110" AFTER 400 ns, -- 6
"1000" AFTER 500 ns, -- -56
"0111" AFTER 600 ns, -- -105
"0000" AFTER 700 ns, -- 0
"1101" AFTER 800 ns, -- 29
"1000" AFTER 900 ns, -- -56
"1000" AFTER 1000 ns, -- 56
"0110" AFTER 1100 ns, -- 6
"1000" AFTER 1200 ns, -- -56
"1001" AFTER 1300 ns, -- 105
"0000" AFTER 1400 ns, -- 0
"1101" AFTER 1500 ns, -- 29
"1000" AFTER 1600 ns, -- 56
"0000" AFTER 1800 ns;

end Behavioral;

3.3.4 Simulación de la ALU

Se realiza la RunBehavioralSimulation para probar el funcionamiento del circuito

Figure 12: Run Behavioral Simulation de la ALU a 1000ns

3.3.5 Archivo XDC

Se le asignan los pines de entrada y salida segun el FPGA FPGA Nexys4 DDRTML mostrado
en la Figura 2

16
 Figure 13: Archivo XDC con las I/O de la ALU

3.3.6 Simulación despues de la implementación

Una vez implementado, se realiza otra simulación

Figure 14: Run Post-Implementation Timing Simulation de la ALU a 1000ns

17
3.3.7 Generación del archivo bitstream

Figure 15: Reporte Bitstream de la ALU

18
4 Conclusiones y Sugerencias
• Con el lenguage VHDL logramos describir circuitos especificando sus caracteristicas funcionales
y fisicas como entradas y salidas.
• Se logro la implementacion de los circuitos secuenciales requeridos, creando un archivo XDC
con el que especificamos las entradas y salidas del FPGA Nexys4 DDRTML.
• Con el uso del Timing simulation además de permitirnos una emulación más cercana a la
descarga real de un diseño en un dispositivo, nos permitió verificar que el diseño implementado
cumple con todos los requisitos funcionales garantizando que el diseño final este libre de
defectos.
• No se puede realizar la declaracion de portmaps dentro de procesos, esto pues no podemos
hacer que el hardware aparezca y desaparezca magicamente a voluntad. No podemos decidir
si una parte de hardware existe o no basados en entradas, por ello se declara el hardware a
usar al inicio de la parte de la arquitectura y no despues.
• Si bien se puede realizar una simulacion del circuito pre implementado, es importante realizar
una simulacion post implementación pues esta sera la aproximación mas cercana que tendremos
a como se comportara el dispositivo una vez implementado, considerando el retraso en los
tiempos de propagacion por la naturaleza de los componentes, situacion en los que salida
tendra un valor indefinido, entre otras situaciones no contempladas en la simulacion pre
implementación.

19