Nombre de la práctica: Lógica Secuencial con PLD.

OBJETIVO

El alumno utilizará el software Quartus II para programar una tarjeta de desarrollo PLD
FPGA con diseños de circuitos lógicos secuenciales.

MARCO TEÓRICO

Las FPGAs por lo general, consisten en muchos módulos lógicos programables

relativamente pequeños e independientes, los cuales pueden interconectarse para crear
funciones más grandes. Es común que cada módulo pueda manejar sólo hasta cuatro o cinco
variables de entrada. La mayoría de los módulos lógicos FPGA utiliza el método de tabla de
búsqueda (LUT) para crear las funciones lógicas deseadas. Una tabla de búsqueda funciona
justo igual que una tabla de verdad, en la cual la salida puede programarse para crear la
función combinacional deseada, almacenando el 0 o 1 apropiado para cada combinación de
entrada. Los recursos de enrutamiento de la señal programable dentro del chip tienden a ser
muy variados, con muchas longitudes de ruta distintas disponibles. Los retrasos de la señal
producidos por un diseño dependen del enrutamiento actual de la señal seleccionado por el
software de programación. Los módulos lógicos también contienen registros programables y
no están asociados con ninguna terminal de E/S, sino que cada terminal de E/S se conecta a
un bloque de entrada/salida programable que, a su vez, se conecta a los módulos lógicos con
las líneas de enrutamiento seleccionadas. Los bloques de E/S pueden configurarse para
proporcionar capacidad de entrada, de salida o bidireccional, y pueden utilizarse los registros
integrados para fijar los datos entrantes o salientes. En la siguiente figura se muestra una
arquitectura general de las FPGAs. Todos los bloques lógicos y los de entrada/salida pueden
programarse para implementar casi cualquier circuito lógico. Las interconexiones
programables se realizan mediante líneas que pasan a través de las filas y columnas en los
canales entre los bloques lógicos. Algunas FPGAs incluyen bloques extensos de memoria
RAM; otras no.

P7 – Pág.1
MATERIAL Y HERRAMIENTAS A UTILIZAR EQUIPO A EMPLEAR
CANTIDAD DESCRIPCIÓN CANTIDAD DESCRIPCIÓN

1 FPGA Cyclone IV Serie 1 USB Blaster

EP4CE6E22C8N ó 1 Quartus II.
Cyclone II Serie 11 PC con Windows.
EP2C5T144C8 Manual
técnico
especificaciones. de

DESARROLLO

Resuelva los siguientes problemas de diseño lógico, mediante el lenguaje VHDL.

P7 – Pág.2
1. Diseñe con VHDL que un FPGA Cyclone IV Serie EP4CE6E22C8N funcione
como un contador modulo 16 𝑎𝑠𝑐/des#.

a) Una vez que concluya y no existan errores, pegue aquí la captura de pantalla de
la ventana Flow Summary.

b) Pegue aquí la captura de pantalla del Simulation Waveform Editor donde se

muestre el resultado de la simulación.

P7 – Pág.3
c) Pegue aquí el código fuente del diseño.

--
-- FILE ; CYCLONE\CONT_MOD16.vhd
--
-------------------------------------------------------------------------------------
-- Codigo VHDL para un FPGA Cyclone IV Series EP4CE6E22C8
-- EPCS16N memoria de configuracion no volatil.
-------------------------------------------------------------------------------------
--
-- Description : Contador MOD 16 asc/descripcion
-----------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all;
USE ieee.std_logic_unsigned.all;

P7 – Pág.4
 ENTITY pr7 IS
PORT ( Clock, ascendente: IN STD_LOGIC ;
Q : BUFFER
INTEGER RANGE 0 TO 15 :=0 ) ;
END pr7;

ARCHITECTURE Behavior OF pr7 IS

BEGIN
PROCESS ( Clock, ascendente )
BEGIN
IF (Clock'EVENT AND Clock = '1' AND ascendente
='0') THEN
Q <= Q - 1 ;
ELSIF (Clock'EVENT AND Clock = '1' AND ascendente ='1')
THEN
Q <= Q + 1 ;
END IF;
END PROCESS;
END Behavior;
2. Diseñe con VHDL que un FPGA Cyclone IV Serie EP4CE6E22C8N funcione
como un contador modulo 16 con una señal de reset.

a) Una vez que concluya y no existan errores, pegue aquí la captura de pantalla de
la ventana Flow Summary.

P7 – Pág.5
b) Pegue aquí la captura de pantalla del Simulation Waveform Editor donde se
muestre el resultado de la simulación.

P7 – Pág.6
 c) Pegue aquí el código fuente del diseño.

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity pr7 is
port (clk : in std_logic;
reset : in std_logic;
count : out std_logic_vector(3 downto 0)
);
end pr7;

architecture arquitec of pr7 is

signal cnt : unsigned(3 downto 0);

begin

P7 – Pág.7
 process (clk, reset) is
begin
if reset = '1' then
cnt <= "0000";
elsif (clk'event and clk='1') then
cnt <= cnt + 1;
end if;
end process;

count <= std_logic_vector(cnt);

end arquitec;

3. Diseñe con VHDL que un FPGA Cyclone IV Serie EP4CE6E22C8 funcione

como como un contador modulo 16, mostrara la secuencia de números pares y
luego los impares.

a) Una vez que concluya y no existan errores, pegue aquí la captura de pantalla de
la ventana Flow Summary.

P7 – Pág.8
b) Pegue aquí la captura de pantalla del Simulation Waveform Editor donde se
muestre el resultado de la simulación.

P7 – Pág.9
c) Pegue aquí el código fuente del diseño.

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY pr7_2 IS
PORT ( clock : IN STD_LOGIC;
q : BUFFER INTEGER
RANGE 0 TO 15 );
END pr7_2;

ARCHITECTURE Behavior OF pr7_2 IS

TYPE estados is (cero, uno, dos, tres, cuatro,
cinco, seis, siete, ocho, nueve, diez, once,
doce, trece, catorce, quince);

P7 – Pág.10
SIGNAL estado: estados;

BEGIN
PROCESS (clock)
BEGIN

IF rising_edge(clock) THEN

CASE estado IS
WHEN cero =>

q<= 0;

estado <= dos;

WHEN uno =>

q<= 1;

estado <= tres;

WHEN dos =>

q<= 2;

estado <= cuatro;

WHEN tres =>

q<= 3;

estado <= cinco;

WHEN cuatro =>

q<= 4;

estado <= seis;

WHEN cinco =>

q<= 5;

P7 – Pág.11
estado <= siete;
WHEN seis =>

q<= 6;

estado <= ocho;

WHEN siete =>

q<= 7;

estado <= nueve;

WHEN ocho =>

q<= 8;

estado <= diez;

WHEN nueve =>

q<= 9;

estado <= once;

WHEN diez =>

q<= 10;

estado <= doce;

WHEN once =>

q<= 11;

estado <= trece;

WHEN doce =>

q<= 12;

estado <= catorce;

P7 – Pág.12
 WHEN trece =>

q<= 13;

estado <= quince;

WHEN catorce
=>

q<= 14;

estado <= uno;

WHEN quince =>

q<= 15;

estado <= cero;

END CASE ;
END IF;
END PROCESS;
END Behavior;

4. Diseñe con VHDL que un FPGA Cyclone IV Serie EP4CE6E22C8 funcione

como como un contador modulo 10, mostrara indefinidamente la secuencia de
números la secuencia de números del 0 al 9, en un display de 7 segmentos.

a) Una vez que concluya y no existan errores, pegue aquí la captura de pantalla de
la ventana Flow Summary.

P7 – Pág.13
b) Pegue aquí la captura de pantalla del Simulation Waveform Editor donde se
muestre el resultado de la simulación.

P7 – Pág.14
c) Pegue aquí el código fuente del diseño.
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY pr7_3 IS
PORT ( clock : IN STD_LOGIC ;
display : BUFFER INTEGER RANGE 0 TO 255 );
END pr7_3 ;

--*************** Valores decimal para display empleando anodo comun,

-- Se considera los segmentos con la ponderacion dP G F E D C B A ***
--
*****************************************************************
**
-- Numero a mostrar 0. ; display = 64
-- Numero a mostrar 1. ; display = 121
-- Numero a mostrar 2. ; display = 36
-- Numero a mostrar 3. ; display = 48

P7 – Pág.15
-- Numero a mostrar 4. ; display = 25
-- Numero a mostrar 5. ; display = 18
-- Numero a mostrar 6. ; display = 2
-- Numero a mostrar 7. ; display = 120
-- Numero a mostrar 8. ; display = 0
-- Numero a mostrar 9. ; display = 16

ARCHITECTURE Behavior OF pr7_3 IS

TYPE estados is (cero, uno, dos, tres, cuatro,
cinco, seis, siete, ocho, nueve);
SIGNAL estado: estados;

BEGIN
PROCESS (clock)
BEGIN

IF(clock'EVENT and clock='1') THEN

CASE estado IS
WHEN cero =>
display<= 64;
estado <= uno;
WHEN uno =>
display<= 121;
estado <= dos;
WHEN dos =>
display<= 36;
estado <= tres;
WHEN tres =>
display<= 48;
estado <= cuatro;
WHEN cuatro =>
display<= 25;
estado <= cinco;
WHEN cinco =>
display<= 18;
estado <= seis;

P7 – Pág.16
 WHEN seis =>
display<= 2;
estado <= siete;
WHEN siete =>
display<= 120;
estado <= ocho;
WHEN ocho =>
display<= 0;
estado <= nueve;
WHEN nueve =>
display<= 16;
estado <= cero;
END CASE;
END IF;
END PROCESS;
END Behavior;

P7 – Pág.17