Reporte de Practicas para Fpga

DIVISIÓN ACADÉMICA DE
MECÁNICA INDUSTRIAL
REPORTE DE PRACTICAS PARA

FPGA EN QUARTUS
Técnico Superior Universitario en

Mecatrónica/ Automatización
Asignatura de:
Dispositivos digitales
VARGAS PÉREZ JORGE

VILLANUEVA MARTÍNEZ LUIS ANTONIO
ESPEJO SIGLER IAN RAÚL
ALBARRAN FLORES JORDAN MICHEL
ÍNDICE
Marco teórico .......................................................................................................................................... 3

Fpga ..................................................................................................................................................... 3
Quartus II ............................................................................................................................................. 3
Decodificador 7447 ............................................................................................................................ 4
Material......................................................................................................................................................... 6
Problemas a resolver ......................................................................................................................... 7
CONCLUSION .......................................................................................................................................... 28
Marco teórico
Fpga
Desde los inicios de los circuitos integrados digitales, siempre se había planteado la
posibilidad de crear dispositivos con hardware reconfigurable, es decir, circuitos que no
sólo se limitaran a ejecutar instrucciones pre-configuradas, como ocurre en un
microprocesador, si no, que fuera el mismo hardware en sí, el que se configurará para
un propósito específico. Sin embargo, no fue hasta la década de los 70’s cuando
salieron al mercado los primeros dispositivos lógicos programables (PLD). Esta idea fue
evolucionando a lo largo de la década de los 80’s, pasando por diversas
transformaciones y mejoras hasta llegar al dispositivo que hizo posible la
popularización de esta corriente de desarrollo en base a la descripción de hardware:
el FPGA.
Los FPGA o Field Programmable Gate Array (arreglo de compuertas programables en

campo) es un circuito integrado de electrónica digital, que tiene la capacidad de
reconfiguración del hardware en su interior. Esto plantea la posibilidad de que es el
propio FPGA el que se reforma o reconstituye internamente para que sea un dispositivo
con una aplicación específica, desde una calculadora sencilla hasta uno o varios
microprocesadores funcionando al mismo tiempo en paralelo. El FPGA es entonces un
dispositivo muy versátil, con capacidades prácticamente ilimitadas para crear diseños
digitales a la medida y eficientes, en comparación con un microprocesador tradicional.
Quartus II
Es una herramienta de software producida por Altera para el análisis y la síntesis de
diseños realizados en HDL.
Quartus II permite al desarrollador o desarrolladora compilar sus diseños, realizar

análisis temporales, examinar diagramas RTL y configurar el dispositivo de destino con
el programador.
Con el programa de diseño Quartus ® II los diseñadores pueden usar los dispositivos
HardCopy Stratix de manera que puede prever y verificar su rendimiento, el cual resulta
en promedio un 50 por ciento más rápido que su FPGA equivalente. Además, en el flujo
de diseño del HardCopy Stratix, Quartus II incluye una serie de utilidades que reducen
el tiempo de diseño. Como contraste adicional el bajo precio del Quartus II en
comparación con otras herramientas de diseño de ASIC.
Decodificador 7447
Los decodificadores (fig.1) son circuitos integrados que convierten una entrada de
código binario a código BCD correspondiente para encender los segmentos de un
display para que se forme el valor en decimal que responde al número binario. Los
más usados son el 7447 y el 7448, los cuales son tecnología TTL, es decir, que su
voltaje de alimentación es de 5 voltios.
Los display de 7 segmentos (fig.1) pueden ser de ánodo o cátodo común, y para cada
uno corresponde el decodificador a usar, para el display de ánodo común usamos un
7447 y para uno de cátodo común el 7448.
(fig.1decodificador7447 y display de 7 segmentos)
Los pines A, B, C y D son las entradas, si en ellas ponemos un numero binario de 4

bits, siendo A el bit menos significativo y D el más significativo, obtenemos en las
salidas a, b, c, d, e, f y g el código BCD (Binary-Coded Decimal – Decimal Codificado
en Binario), para que en un display de 7 segmentos se enciendan los correspondientes
para formar ese número en decimal.
LT (Lamp Test): Poniendo en estado Lógico 0 este pin y manteniendo BI/RBO en 1, el

decodificador encenderá todos los segmentos del display (sin importar el valor que este
en las entradas A, B, C y D), es una forma de probar que ninguno se encuentre
dañado.
BI/RBO (Blanking Input/Ripple Blanking Output): Siempre permanece en estado alto

(1), a menos que RBI, A, B, C y D estén es estado bajo, de este modo, BI/RBO también
pasará a estado bajo. Al aplicarle directamente un estado bajo, sin importar el estado
de las demás entradas, apagará los segmentos del display.
Material
1. Cable jumper (fig.2).
2. Display de 7 segmentos (fig.3).
3. Luces led (fig.4).
(fig.2 cable jumper).
(fig.3 display de 7 segmentos).

(fig.4 luces led).
Problemas a resolver
1. Programar un sumador de 3 bits (6 entradas y 4 salidas), para sumar hasta el
número 14, añadiendo dos decodificadores, el primero debe indicar unidades (0
a 9) y el segundo indicará decenas (0 y 1). Lo primero es realizar una tabla de
verdad (tabla 1).
A B C D E F S3 S2 S1 S0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 1
0 0 0 0 1 0 0 0 1 0
0 0 0 0 1 1 0 0 1 1
0 0 0 1 0 0 0 1 0 0
0 0 0 1 0 1 0 1 0 1
0 0 0 1 1 0 0 1 1 0
0 0 0 1 1 1 0 1 1 1
0 0 1 0 0 0 0 0 0 1
0 0 1 0 0 1 0 0 1 0
0 0 1 0 1 0 0 0 1 1
0 0 1 0 1 1 0 1 0 0
0 0 1 1 0 0 0 1 0 1
0 0 1 1 0 1 0 1 1 0
0 0 1 1 1 0 0 1 1 1
0 0 1 1 1 1 1 0 0 0
0 1 0 0 0 0 0 0 1 0
0 1 0 0 0 1 0 0 1 1
0 1 0 0 1 0 0 1 0 0
0 1 0 0 1 1 0 1 0 1
0 1 0 1 0 0 0 1 1 0
0 1 0 1 0 1 0 1 1 1
0 1 0 1 1 0 1 0 0 0
0 1 0 1 1 1 1 0 0 1
0 1 1 0 0 0 0 0 1 1
0 1 1 0 0 1 0 1 0 0
0 1 1 0 1 0 0 1 0 1
0 1 1 0 1 1 0 1 1 0
0 1 1 1 0 0 0 1 1 1
0 1 1 1 0 1 1 0 0 0
0 1 1 1 1 0 1 0 0 1
0 1 1 1 1 1 0 0 0 0
1 0 0 0 0 0 0 1 0 0
1 0 0 0 0 1 0 1 0 1
1 0 0 0 1 0 0 1 1 0
1 0 0 0 1 1 0 1 1 1
1 0 0 1 0 0 1 0 0 0
1 0 0 1 0 1 1 0 0 1
1 0 0 1 1 0 0 0 0 0
1 0 0 1 1 1 0 0 0 1
1 0 1 0 0 0 0 1 0 1
1 0 1 0 0 1 0 1 1 0
1 0 1 0 1 0 0 1 1 1
1 0 1 0 1 1 1 0 0 0
1 0 1 1 0 0 1 0 0 1
1 0 1 1 0 1 0 0 0 0
1 0 1 1 1 0 0 0 0 1
1 0 1 1 1 1 0 0 1 0
1 1 0 0 0 0 0 1 1 0
1 1 0 0 0 1 0 1 1 1
1 1 0 0 1 0 1 0 0 0
1 1 0 0 1 1 1 0 0 1
1 1 0 1 0 0 0 0 0 0
1 1 0 1 0 1 0 0 0 1
1 1 0 1 1 0 0 0 1 0
1 1 0 1 1 1 0 0 1 1
1 1 1 0 0 0 0 1 1 1
1 1 1 0 0 1 1 0 0 0
1 1 1 0 1 0 1 0 0 1
1 1 1 0 1 1 0 0 0 0
1 1 1 1 0 0 0 0 0 1
1 1 1 1 0 1 0 0 1 0
1 1 1 1 1 0 0 0 1 1
1 1 1 1 1 1 0 1 0 0
(Tabla 1)
El paso siguiente es realizar los Mapas de karnaugh y reducir sus expreciones (tablas
2-6)
DEF
ABC 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0
0 0 0 0 0 1 0 1
0 0 0 0 0 0 1 1
0 0 0 0 1 1 0 0
0 0 1 0 1 0 0 0
0 1 0 1 0 0 0 0
0 0 1 1 0 0 0 0
(Tabla 2 expresión )
̅ ̅ ̅ ̅ ̅̅̅̅ ̅ ̅ ̅̅̅̅ ̅̅̅̅ ̅ ̅ ̅̅̅̅ ̅ ̅

̅ ̅ ̅̅̅̅
DEF
ABC 0 0 0 0 1 1 1 1
0 0 1 0 1 1 0 1
0 1 1 1 1 0 0 0
0 0 1 1 1 1 0 0
1 1 1 1 0 0 0 0
1 1 0 1 0 0 0 0
1 0 0 0 0 0 1 0
1 1 0 0 0 0 0 0
̅̅̅̅̅̅ ̅̅̅̅ ̅ ̅̅̅̅ ̅ ̅̅̅̅ ̅ ̅ ̅̅̅̅ ̅ ̅ ̅̅̅̅̅̅ ̅̅̅̅̅̅ ̅̅̅̅̅̅

̅̅̅̅̅̅ ̅̅̅̅̅̅ ̅ ̅ ̅ ̅
DEF
ABC 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1
1 0 1 0 1 0 0 0
1 1 0 0 1 1 0 0
0 0 1 1 0 0 0 0
0 1 0 1 0 0 1 0
1 0 0 0 0 1 0 1
1 1 0 0 0 0 1 1
̅̅̅̅̅̅ ̅̅̅̅̅̅̅̅ ̅̅̅̅̅̅̅̅ ̅ ̅̅̅̅ ̅̅̅̅̅̅ ̅ ̅̅̅̅ ̅̅̅̅̅̅ ̅̅̅̅ ̅ ̅̅̅̅

̅ ̅ ̅ ̅ ̅ ̅
DEF
ABC 0 1 1 0 0 1 1 0
1 0 0 1 1 0 0 1
1 0 0 1 1 0 0 1
0 1 1 0 0 1 1 0
0 1 1 0 0 1 1 0
1 0 0 1 1 0 0 1
1 0 0 1 1 0 0 1
0 1 1 0 0 1 1 0
̅ ̅
DEF
ABC 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 1
0 0 0 0 1 1 1 1
0 0 1 0 1 1 1 1
0 0 0 0 1 1 1 1
(Tabla 6)
Esta expresión es usada para los decimales cuando la suma supera el número 10.
El código de programación es el siguiente:
ENTITY suma3bi IS
-- {{ALTERA_IO_BEGIN}} DO NOT REMOVE THIS LINE!
PORT
e : IN STD_LOGIC_VECTOR(5 downto 0);
s : OUT STD_LOGIC_VECTOR(4 downto 0)
);
-- {{ALTERA_IO_END}} DO NOT REMOVE THIS LINE!
END suma3bi;
-- Architecture Body
ARCHITECTURE suma3_architecture OF suma3bi IS
BEGIN
process(e)
begin
case e is
when "000000" => s <= "00000";--0
when "000001" => s <= "00001";--1
when "000010" => s <= "00010";--2
when "000011" => s <= "00011";--3
when "000100" => s <= "00100";--4
when "000101" => s <= "00101";--5
when "000110" => s <= "00110";--6
when "000111" => s <= "00111";--7
when "001000" => s <= "00001";--8
when "001001" => s <= "00010";--9
when "001010" => s <= "00011";--10
when "001011" => s <= "00100";--11
when "001100" => s <= "00101";--12
when "001101" => s <= "00110";--13

when "001110" => s <= "00111";--14
when "001111" => s <= "01000";--15
when "010000" => s <= "00010";--16
when "010001" => s <= "00011";--17
when "010010" => s <= "00100";--18
when "010011" => s <= "00101";--19
when "010100" => s <= "00110";--20
when "010101" => s <= "00111";--21
when "010110" => s <= "01000";--22
when "010111" => s <= "01001";--23
when "011000" => s <= "00011";--24
when "011001" => s <= "00100";--25
when "011010" => s <= "00101";--26
when "011011" => s <= "00110";--27
when "011100" => s <= "00111";--28
when "011101" => s <= "01000";--29
when "011110" => s <= "01001";--30
when "011111" => s <= "10000";--31
when "100000" => s <= "00100";--32

when "100001" => s <= "00101";--33
when "100010" => s <= "00110";--34
when "100011" => s <= "00111";--35
when "100100" => s <= "01000";--36
when "100101" => s <= "01001";--37
when "100110" => s <= "10000";--38
when "100111" => s <= "10001";--39
when "101000" => s <= "00101";--40
when "101001" => s <= "00110";--41
when "101010" => s <= "00111";--42
when "101011" => s <= "01000";--43
when "101100" => s <= "01001";--44
when "101101" => s <= "10000";--45
when "101110" => s <= "10001";--46
when "101111" => s <= "10010";--47
when "110000" => s <= "00110";--48
when "110001" => s <= "00111";--49
when "110010" => s <= "01000";--50
when "110011" => s <= "11001";--51

when "110100" => s <= "10000";--52
when "110101" => s <= "10001";--53
when "110110" => s <= "10010";--54
when "110111" => s <= "10011";--55
when "111000" => s <= "00111";--56
when "111001" => s <= "01000";--57
when "111010" => s <= "01001";--58
when "111011" => s <= "10000";--59
when "111100" => s <= "10001";--60
when "111101" => s <= "10010";--61
when "111110" => s <= "10011";--62
when "111111" => s <= "10100";--63
end case;
end process;
2. Programar un comparador para dos números de tres bits, añadiendo un display

de 7 segmentos para visualizar la diferencia entre los dos números.
Ejemplo: si a la entrada se tienen los números A = 100 y B = 110, a la salida se
debe prender el led que indica A < B, pero en el display se debe visualizar el
número dos, que es la diferencia entre los dos números. Realizar tabla de
verdad (tabla 7).
A B C D E F X=Y X>Y X<Y

0 0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 1 1 0 0 1
0 0 0 0 0 1 0 2 0 0 1
0 0 0 0 0 1 1 3 0 0 1
0 0 0 0 1 0 0 4 0 0 1
0 0 0 0 1 0 1 5 0 0 1
0 0 0 0 1 1 0 6 0 0 1
0 0 0 0 1 1 1 7 0 0 1
1 0 0 1 0 0 0 0 0 1 0
1 0 0 1 0 0 1 1 1 0 0
1 0 0 1 0 1 0 2 0 0 1
1 0 0 1 0 1 1 3 0 0 1
1 0 0 1 1 0 0 4 0 0 1
1 0 0 1 1 0 1 5 0 0 1
1 0 0 1 1 1 0 6 0 0 1
1 0 0 1 1 1 1 7 0 0 1
2 0 1 0 0 0 0 0 0 1 0
2 0 1 0 0 0 1 1 0 1 0
2 0 1 0 0 1 0 2 1 0 0
2 0 1 0 0 1 1 3 0 0 1
2 0 1 0 1 0 0 4 0 0 1
2 0 1 0 1 0 1 5 0 0 1
2 0 1 0 1 1 0 6 0 0 1
2 0 1 0 1 1 1 7 0 0 1
3 0 1 1 0 0 0 0 0 1 0
3 0 1 1 0 0 1 1 0 1 0
3 0 1 1 0 1 0 2 0 1 0
3 0 1 1 0 1 1 3 1 0 0
3 0 1 1 1 0 0 4 0 0 1
3 0 1 1 1 0 1 5 0 0 1
3 0 1 1 1 1 0 6 0 0 1
3 0 1 1 1 1 1 7 0 0 1
4 1 0 0 0 0 0 0 0 1 0
4 1 0 0 0 0 1 1 0 1 0
4 1 0 0 0 1 0 2 0 1 0
4 1 0 0 0 1 1 3 0 1 0
4 1 0 0 1 0 0 4 1 0 0
4 1 0 0 1 0 1 5 0 0 1
4 1 0 0 1 1 0 6 0 0 1
4 1 0 0 1 1 1 7 0 0 1
5 1 0 1 0 0 0 0 0 1 0
5 1 0 1 0 0 1 1 0 1 0
5 1 0 1 0 1 0 2 0 1 0
5 1 0 1 0 1 1 3 0 1 0
5 1 0 1 1 0 0 4 0 1 0
5 1 0 1 1 0 1 5 1 0 0
5 1 0 1 1 1 0 6 0 0 1
5 1 0 1 1 1 1 7 0 0 1
6 1 1 0 0 0 0 0 0 1 0
6 1 1 0 0 0 1 1 0 1 0
6 1 1 0 0 1 0 2 0 1 0
6 1 1 0 0 1 1 3 0 1 0
6 1 1 0 1 0 0 4 0 1 0
6 1 1 0 1 0 1 5 0 1 0
6 1 1 0 1 1 0 6 1 0 0
6 1 1 0 1 1 1 7 0 0 1
7 1 1 1 0 0 0 0 0 1 0
7 1 1 1 0 0 1 1 0 1 0
7 1 1 1 0 1 0 2 0 1 0
7 1 1 1 0 1 1 3 0 1 0
7 1 1 1 1 0 0 4 0 1 0
7 1 1 1 1 0 1 5 0 1 0
7 1 1 1 1 1 0 6 0 1 0
7 1 1 1 1 1 1 7 1 0 0
(Tabla 7)
̅̅̅̅ ̅ +̅ ̅̅̅̅ ̅ + ̅
̅̅̅̅( ̅ ̅̅̅̅ ̅ ̅̅̅̅ ̅

El código es:
Library ieee;
use
ieee.std_logic_1164.ALL;
entity Comparador3bits is
Port(
ABCDEF: in std_logic_vector (5 downto 0);
Leds: out std_logic_vector (2 downto 0);
Dif: out std_logic_vector (6 downto 0));
End Comparador3bits;
architecture compara of Comparador3bits is
Begin
WITH ABCDEF SELECT
Leds <=
("010") WHEN ("000000"), --0
("001") WHEN ("000001"), --1
("001") WHEN ("000010"), --2
("001") WHEN ("000011"), --3
("001") WHEN ("000100"), --4
("001") WHEN ("000101"), --5
("001") WHEN ("000110"), --6
("001") WHEN ("000111"), --7
("100") WHEN ("001000"), --1

("010") WHEN ("001001"), --0
("001") WHEN ("001010"), --1
("001") WHEN ("001011"), --2
("001") WHEN ("001100"), --3
("001") WHEN ("001101"), --4
("001") WHEN ("001110"), --5
("001") WHEN ("001111"), --6
("100") WHEN ("010000"), --2
("100") WHEN ("010001"), --1
("010") WHEN ("010010"), --0
("001") WHEN ("010011"), --1
("001") WHEN ("010100"), --2
("001") WHEN ("010101"), --3
("001") WHEN ("010110"), --4
("001") WHEN ("010111"), --5
("100") WHEN ("011000"), --3
("100") WHEN ("011001"), --2
("100") WHEN ("011010"), --1
("010") WHEN ("011011"), --0
("001") WHEN ("011100"), --1
("001") WHEN ("011101"), --2
("001") WHEN ("011110"), --3
("001") WHEN ("011111"), --4
("100") WHEN ("100000"), --4
("100") WHEN ("100001"), --3
("100") WHEN ("100010"), --2
("100") WHEN ("100011"), --1
("010") WHEN ("100100"), --0
("001") WHEN ("100101"), --1

("001") WHEN ("100110"), --2
("001") WHEN ("100111"), --3
("100") WHEN ("101000"), --5
("100") WHEN ("101001"), --4
("100") WHEN ("101010"), --3
("100") WHEN ("101011"), --2
("100") WHEN ("101100"), --1
("010") WHEN ("101101"), --0
("001") WHEN ("101110"), --1
("001") WHEN ("101111"), --2
("100") WHEN ("110000"), --6
("100") WHEN ("110001"), --5
("100") WHEN ("110010"), --4
("100") WHEN ("110011"), --3
("100") WHEN ("110100"), --2
("100") WHEN ("110101"), --1
("010") WHEN ("110110"), --0
("001") WHEN ("110111"), --1
("100") WHEN ("111000"), --7
("100") WHEN ("111001"), --6
("100") WHEN ("111010"), --5
("100") WHEN ("111011"), --4
("100") WHEN ("111100"), --3
("100") WHEN ("111101"), --2
("100") WHEN ("111110"), --1
("010") WHEN OTHERS; --0
WITH ABCDEF SELECT

Dif<=
("1111110") WHEN ("000000"), --0
("0110000") WHEN ("000001"), --1
("1101101") WHEN ("000010"), --2
("1111001") WHEN ("000011"), --3
("0110011") WHEN ("000100"), --4
("1011011") WHEN ("000101"), --5
("1011111") WHEN ("000110"), --6
("1110000") WHEN ("000111"), --7
("0110000") WHEN ("001000"), --1
("1111110") WHEN ("001001"), --0
("0110000") WHEN ("001010"), --1
("1101101") WHEN ("001011"), --2
("1111001") WHEN ("001100"), --3
("0110011") WHEN ("001101"), --4
("1011011") WHEN ("001110"), --5
("1011111") WHEN ("001111"), --6
("1101101") WHEN ("010000"), --2
("0110000") WHEN ("010001"), --1
("1111110") WHEN ("010010"), --0
("0110000") WHEN ("010011"), --1
("1101101") WHEN ("010100"), --2
("1111001") WHEN ("010101"), --3
("0110011") WHEN ("010110"), --4
("1011011") WHEN ("010111"), --5
("1111001") WHEN ("011000"), --3
("1101101") WHEN ("011001"), --2
("0110000") WHEN ("011010"), --1
("1111110") WHEN ("011011"), --0

("0110000") WHEN ("011100"), --1
("1101101") WHEN ("011101"), --2
("1111001") WHEN ("011110"), --3
("0110011") WHEN ("011111"), --4
("0110011") WHEN ("100000"), --4
("1111001") WHEN ("100001"), --3
("1101101") WHEN ("100010"), --2
("0110000") WHEN ("100011"), --1
("1111110") WHEN ("100100"), --0
("0110000") WHEN ("100101"), --1
("1101101") WHEN ("100110"), --2
("1111001") WHEN ("100111"), --3
("1011011") WHEN ("101000"), --5
("0110011") WHEN ("101001"), --4
("1111001") WHEN ("101010"), --3
("1101101") WHEN ("101011"), --2
("0110000") WHEN ("101100"), --1
("1111110") WHEN ("101101"), --0
("0110000") WHEN ("101110"), --1
("1101101") WHEN ("101111"), --2
("1011111") WHEN ("110000"), --6
("1011011") WHEN ("110001"), --5
("0110011") WHEN ("110010"), --4
("1111001") WHEN ("110011"), --3
("1101101") WHEN ("110100"), --2
("0110000") WHEN ("110101"), --1
("1111110") WHEN ("110110"), --0
("0110000") WHEN ("110111"), --1
("1110000") WHEN ("111000"), --7

("1011111") WHEN ("111001"), --6
("1011011") WHEN ("111010"), --5
("0110011") WHEN ("111011"), --4
("1111001") WHEN ("111100"), --3
("1101101") WHEN ("111101"), --2
("0110000") WHEN ("111110"), --1
("1111110") WHEN OTHERS; --0
END compara;
3. Programar un convertidor de número gray a sistemas decimal de 4 bits

desplegando los números en display de siete segmentos realizando la tabla de
verdad (tabla 8).
A B C D A B C D E F G
0 0 0 0 1 1 1 1 1 1 0
0 0 0 1 0 1 1 0 0 0 0
0 0 1 1 1 1 0 1 1 0 1
0 0 1 0 1 1 1 1 0 0 1
0 1 1 0 0 1 1 0 0 1 1
0 1 1 1 1 0 1 1 0 1 1
0 1 0 1 1 0 1 1 1 1 1
0 1 0 0 1 1 1 0 0 0 0
1 1 0 0 1 1 1 1 1 1 1
1 1 0 1 1 1 1 0 0 1 1
1 1 1 1 1 1 1 1 1 1 0
1 1 1 0 0 1 1 0 0 0 0
1 0 1 0 1 1 0 1 1 0 1
1 0 1 1 1 1 1 1 0 0 1
1 0 0 1 0 1 1 0 0 1 1
1 0 0 0 1 0 1 1 0 1 1
(Tabla 8)
Realizando los mapas de karnaugh y reduciendo expresiones (tablas9-15):
Mapa de karnaugh para la salida en display del segmento G
(Tabla 9)
B D+ C+A +A
Mapa de karnaugh para la salida en display del segmento F
(Tabla 10)
+ BC+A +BC
Mapa de karnaugh para la salida en display del segmento E
(Tabla 11)
DEBIDO A LA EXPRECION, en el mapa no se pueden hacer agrupaciones.
Por lo tanto, pasamos la expresión tal cual.
+ CD+ B D+A C +AB +ABCD
Mapa de karnaugh para la salida en display del segmento D
(Tabla 12)
A + BD+ +CD
Mapa de karnaugh para la salida en display del segmento C
(Tabla 13)
+AD+ +B
Mapa de karnaugh para la salida en display del segmento B
(Tabla 14)
D+C +B +AB
Mapa de karnaugh para la salida en display del segmento A
(Tabla 15)
C+BD
El código es el siguiente:
LIBRARY ieee;
USE ieee.std_logic_1164.all;
entity graydecima is
port
(
e: in std_logic_vector(3 downto 0);
s: out std_logic_vector(8 downto 0)
);
end graydecima;
architecture deci of graydecima is
BEGIN
process(e)
begin
--La primer fila de salidas es para los decimales 1 y 0
case e is
when "0000" => s <= "000000111";
when "0001" => s <= "100111111";
when "0011" => s <= "001001011";
when "0010" => s <= "000011011";
when "0110" => s <= "100110011";
when "0111" => s <= "010010011";
when "0101" => s <= "010000011";

when "0100" => s <= "000111111";
when "1100" => s <= "000000011";
when "1101" => s <= "000110011";
when "1111" => s <= "000000100";
when "1110" => s <= "100111100";
when "1010" => s <= "001001000";
when "1011" => s <= "000011000";
when "1001" => s <= "100110000";
when "1000" => s <= "010010000";
end case;
end process;
end deci;
CONCLUSION
El lenguaje de descripción de hardware VHDL para describir algunas de las
arquitecturas para simular las descripciones con parámetros de interés establecidos se
llevó a cabo con el lenguaje VHDL y el uso de herramientas modernas como la tarjeta
FPGA que facilitan de sobremanera el diseño de sistemas digitales y de programación
de señales al no tener que realizar explícitamente el circuito lógico o el circuito eléctrico
solo haciendo el programa con las especificaciones requeridas.

Reporte de Practicas para Fpga

Cargado por

Información del documento

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

Reporte de Practicas para Fpga

Cargado por

Copyright:

Formatos disponibles

DIVISIÓN ACADÉMICA DE

REPORTE DE PRACTICAS PARA

Técnico Superior Universitario en

VARGAS PÉREZ JORGE

Marco teórico .......................................................................................................................................... 3

Los FPGA o Field Programmable Gate Array (arreglo de compuertas programables en

Quartus II permite al desarrollador o desarrolladora compilar sus diseños, realizar

(fig.1decodificador7447 y display de 7 segmentos)

Los pines A, B, C y D son las entradas, si en ellas ponemos un numero binario de 4

LT (Lamp Test): Poniendo en estado Lógico 0 este pin y manteniendo BI/RBO en 1, el

BI/RBO (Blanking Input/Ripple Blanking Output): Siempre permanece en estado alto

2. Display de 7 segmentos (fig.3).

3. Luces led (fig.4).

(fig.2 cable jumper).

(fig.3 display de 7 segmentos).

(fig.4 luces led).

̅ ̅ ̅ ̅ ̅̅̅̅ ̅ ̅ ̅̅̅̅ ̅̅̅̅ ̅ ̅ ̅̅̅̅ ̅ ̅

̅̅̅̅̅̅ ̅̅̅̅ ̅ ̅̅̅̅ ̅ ̅̅̅̅ ̅ ̅ ̅̅̅̅ ̅ ̅ ̅̅̅̅̅̅ ̅̅̅̅̅̅ ̅̅̅̅̅̅

̅̅̅̅̅̅ ̅̅̅̅̅̅̅̅ ̅̅̅̅̅̅̅̅ ̅ ̅̅̅̅ ̅̅̅̅̅̅ ̅ ̅̅̅̅ ̅̅̅̅̅̅ ̅̅̅̅ ̅ ̅̅̅̅

El código de programación es el siguiente:

-- {{ALTERA_IO_BEGIN}} DO NOT REMOVE THIS LINE!

e : IN STD_LOGIC_VECTOR(5 downto 0);

s : OUT STD_LOGIC_VECTOR(4 downto 0)

-- {{ALTERA_IO_END}} DO NOT REMOVE THIS LINE!

ARCHITECTURE suma3_architecture OF suma3bi IS

when "000000" => s <= "00000";--0

when "000001" => s <= "00001";--1

when "000010" => s <= "00010";--2

when "000011" => s <= "00011";--3

when "000100" => s <= "00100";--4

when "000101" => s <= "00101";--5

when "000110" => s <= "00110";--6

when "000111" => s <= "00111";--7

when "001000" => s <= "00001";--8

when "001001" => s <= "00010";--9

when "001010" => s <= "00011";--10

when "001011" => s <= "00100";--11

when "001100" => s <= "00101";--12

when "001101" => s <= "00110";--13

when "001110" => s <= "00111";--14

when "001111" => s <= "01000";--15

when "010000" => s <= "00010";--16

when "010001" => s <= "00011";--17

when "010010" => s <= "00100";--18

when "010011" => s <= "00101";--19

when "010100" => s <= "00110";--20

when "010101" => s <= "00111";--21

when "010110" => s <= "01000";--22

when "010111" => s <= "01001";--23

when "011000" => s <= "00011";--24

when "011001" => s <= "00100";--25

when "011010" => s <= "00101";--26

when "011011" => s <= "00110";--27

when "011100" => s <= "00111";--28

when "011101" => s <= "01000";--29

when "011110" => s <= "01001";--30

when "011111" => s <= "10000";--31

when "100000" => s <= "00100";--32

when "100001" => s <= "00101";--33

when "100010" => s <= "00110";--34

when "100011" => s <= "00111";--35

when "100100" => s <= "01000";--36

when "100101" => s <= "01001";--37