UNIVERSIDAD DE EL SALVADOR

FACULTAD DE INGENIERÍA Y ARQUITECTURA

ESCUELA DE INGENIERÍA ELÉCTRICA
SISTEMAS DIGITALES II

“FPGA”

CIUDAD UNIVERSITARIA, 09 DE NOVIEMBRE DE 2017

1
ÍNDICE

Contenido

ÍNDICE.................................................................................................................................................. 2
INTRODUCCIÓN ................................................................................................................................... 3
OBJETIVOS ........................................................................................................................................... 4
OBJETIVO GENERAL ......................................................................................................................... 4
OBJETIVOS ESPECÍFICOS .................................................................................................................. 4
MARCO TEÓRICO ................................................................................................................................. 5
CPLD ................................................................................................................................................ 5
Field-programmable gate array (FPGA) .......................................................................................... 7
DESARROLLO ..................................................................................................................................... 12
CONVERTIDOR ............................................................................................................................... 12
RELOJ DIGITAL ............................................................................................................................... 16
CHAPA ELÉCTRICA ......................................................................................................................... 23
CONCLUSIONES ................................................................................................................................. 28
BIBLIOGRAFÍA .................................................................................................................................... 28

2
INTRODUCCIÓN

Las principales diferencias entre los (dispositivos lógicos programables complejos) y los
FPGA son arquitectónicos. Un CPLD tiene una estructura algo restrictiva que consiste en
una o más matrices lógicas de suma de productos programables que alimentan un
número relativamente pequeño de registros sincronizados. El resultado de esto es una
menor flexibilidad, con la ventaja de retrasos de temporización más predecibles y una
mayor relación lógica-interconexión. Las arquitecturas FPGA, por otro lado, están
dominadas por la interconexión. Esto los hace mucho más flexibles pero también mucho
más complejos de diseñar.

En el presente trabajo se visualizará la implementación en FPGA desde el programa

VIVADO de un convertido, de un reloj digital y de una chapa eléctrica.

Algunos FPGA tienen funciones analógicas además de funciones digitales. La característica

analógica más común es la velocidad de giro programable en cada pin de salida, que
permite al ingeniero establecer bajas tasas en pines con poca carga que de lo contrario
suenan o se acoplan inaceptablemente, y establecer tasas más altas en pines con mucha
carga en canales de alta velocidad que de otra manera corre demasiado lento. También
son comunes los osciladores de cristal de cuarzo, los osciladores de resistencia-
capacitancia en el chip y los bucles de fase sincronizada con osciladores integrados
controlados por voltaje utilizados para la generación y gestión de reloj y para el
serializador-deserializador de alta velocidad transmitir relojes y recuperar el reloj del
receptor. Bastante comunes son los comparadores diferenciales en los pines de entrada
diseñados para ser conectados a los canales de señalización diferencial.

3
OBJETIVOS

OBJETIVO GENERAL

 Implementar circuitos digitales secuenciales, por medio del software VIVADO

basándose en lenguaje VHDL.

OBJETIVOS ESPECÍFICOS

 Presentar paso a paso el desarrollo de los circuitos y presentar el resultado de

estos.

 Utilizar un FPGA que posea las características más avanzadas para este desarrollo.

4
MARCO TEÓRICO

CPLD

Un CPLD (del acrónimo inglés Complex Programmable Logic Device) es un dispositivo

electrónico.

Los CPLD extienden el concepto de un PLD (del acrónimo inglés Programmable Logic
Device) a un mayor nivel de integración ya que permite implementar sistemas más
eficaces, ya que utilizan menor espacio, mejoran la fiabilidad del diseño, y reducen costos.
Un CPLD se forma con múltiples bloque lógicos, cada uno similar a un [[PLD]m]. Los
bloques lógicos se comunican entre sí utilizando una matriz programable de
interconexiones, lo cual hace más eficiente el uso del silicio, conduciendo a una mejor
eficiencia a menor costo. A continuación se explican brevemente las principales
características de la arquitectura de un CPLD.

Arquitectura

Matriz de Interconexiones Programables

Procesador de un CPLD de la marca Altera.

La matriz de interconexiones programables (PIM) permite unir los pines de entrada/salida

a las entradas del bloque lógico, o las salidas del bloque lógico a las entradas de otro
bloque lógico o inclusive a las entradas del mismo. La mayoría de los CPLDs usan una de
dos configuraciones para esta matriz: interconexión mediante bloques o interconexión
mediante multiplexores.

El primero se basa en una matriz de filas y columnas con una celda programable de
conexión en cada intersección. Al igual que en las GAL esta celda puede ser activada para
conecesconectar la correspondiente fila y columna. Esta configuración permite una total
interconexión entre las entradas y salidas del dispositivo o bloques lógicos. Sin embargo,
estas ventajas provocan que disminuya el rendimiento del dispositivo, además de
aumentar el consumo de energía y el tamaño del componente.

5
En la interconexión mediante multiplexores, existe un multiplexor por cada entrada al
bloque lógico. Las vías de interconexión programables son conectadas a las entradas de un
número de multiplexores por cada bloque lógico. Las líneas de selección de estos
multiplexores son programadas para permitir que sea seleccionada únicamente una vía de
la matriz de interconexión por cada multiplexor la cual se propagara a hacia el bloque
lógico. Cabe mencionar que no todas las vías son conectadas a las entradas de cada
multiplexor. La rutabilidad se incrementa usando multiplexores de mayor tamaño,
permitiendo que cualquier combinación de señales de la matriz de interconexión pueda
ser enlazada hacia cualquier bloque lógico. Sin embargo, el uso de grandes multiplexores
incrementa el tamaño de dispositivo y reduce su eficiencia.

Bloques Lógicos

Un bloque lógico es similar a un PLD, cada uno pose un bloque de compuertas AND y OR
en forma de suma de productos, una configuración para la distribución de estas sumas de
productos, y macroceldas. El tamaño del bloque lógico es una medida de la capacidad del
CPLD, ya que de esto depende el tamaño de la función booleana que pueda ser
implementada dentro del bloque. Los bloques lógicos usualmente tienen de 4 a 20
macroceldas.

Macroceldas

Las macroceldas de un CPLD son similares a las de un PLD. Estas también están provistas
con registros, control de polaridad, y buffers para salidas en alta impedancia. Por lo
general un CPLD tiene macroceldas de entrada/salida, macroceldas de entrada y
macroceldas internas u ocultas (buried macrocells), en tanto que un 22V10 tiene
solamente macroceldas de entrada/salida. Una macrocelda interna es similar a una
macrocelda de entrada/salida, sólo que esta no puede ser conectada directamente a un
pin de salida. La salida de una macrocelda interna va directamente a la matriz de
interconexión programable.

Celda de entrada/salida

La función de una celda de entrada/salida es permitir el paso de una señal hacia dentro o
hacia el exterior del dispositivo. Dependiendo del fabricante y de la arquitectura del CPLD
estas celdas pueden o no ser consideradas parte del bloque lógico.

6
Field-programmable gate array (FPGA)

Una matriz de puertas programable en campo ( FPGA ) es un circuito integrado diseñado

para ser configurado por un cliente o un diseñador después de la fabricación, por lo tanto,
" programable en campo ". La configuración de FPGA generalmente se especifica
utilizando un lenguaje de descripción de hardware (HDL), similar al utilizado para un
circuito integrado específico de la aplicación (ASIC). (Los diagramas de circuitos se usaron
previamente para especificar la configuración, como lo fueron para los ASIC, pero esto es
cada vez más raro).

Un FPGA espartano de Xilinx

Los FPGA contienen una matriz de bloques lógicos programables y una jerarquía de
interconexiones reconfigurables que permiten que los bloques se "conecten entre sí",
como muchas puertas lógicas que pueden interconectarse en diferentes configuraciones.
Los bloques lógicos se pueden configurar para realizar funciones combinacionales
complejas, o simplemente compuertas lógicas simples como AND y XOR . En la mayoría de
los FPGA, los bloques lógicos también incluyen elementos de memoria, que pueden ser
simples flip-flops o bloques de memoria más completos.

Diseño técnico

Los arreglos de compuertas programables en campo (FPGA) contemporáneos tienen

grandes recursos de compuertas lógicas y bloques de RAM para implementar cómputos
digitales complejos. Como los diseños de FPGA emplean E / S muy rápidas y buses de
datos bidireccionales, se convierte en un desafío verificar la sincronización correcta de los
datos válidos dentro del tiempo de configuración y tiempo de espera. La planificación del
piso permite la asignación de recursos dentro de los FPGA para cumplir con estas
limitaciones de tiempo. Los FPGA se pueden usar para implementar cualquier función
lógica que un ASIC pueda realizar. La capacidad de actualizar la funcionalidad después del
envío, la reconfiguración parcial de una parte del diseño y los bajos costos de ingeniería

7
no recurrentes relativos a un diseño ASIC (a pesar del costo unitario generalmente más
alto), ofrecen ventajas para muchas aplicaciones.

Algunos FPGA tienen funciones analógicas además de funciones digitales. La característica

analógica más común es la velocidad de giro programable en cada pin de salida, que
permite al ingeniero establecer bajas tasas en pines con poca carga que de lo contrario
suenan o se acoplan inaceptablemente, y establecer tasas más altas en pines con mucha
carga en canales de alta velocidad que de otra manera corre demasiado lento. También
son comunes los osciladores de cristal de cuarzo, los osciladores de resistencia-
capacitancia en el chip y los bucles de fase sincronizada con osciladores integrados
controlados por voltaje utilizados para la generación y gestión de reloj y para el
serializador-deserializador de alta velocidad (SERDES) transmitir relojes y recuperar el reloj
del receptor. Bastante comunes son los comparadores diferenciales en los pines de
entrada diseñados para ser conectados a los canales de señalización diferencial . Unos
"FPGA de señal mixta " han integrado convertidores analógicos a digitales periféricos
(ADC) y convertidores digital a analógico (DAC) con bloques de acondicionamiento de
señales analógicas que les permiten funcionar como un sistema en un chip.

Historia

La industria de FPGA brotó de la memoria programable de solo lectura (PROM) y los

dispositivos lógicos programables (PLD). Las PROM y las PLD tenían la opción de
programarse en lotes en una fábrica o en el campo (programable en el campo). Sin
embargo, la lógica programable estaba cableada entre puertas lógicas.

A fines de la década de 1980, el Naval Surface Warfare Center financió un experimento

propuesto por Steve Casselman para desarrollar una computadora que implementaría
600,000 puertas reprogramables. Casselman tuvo éxito y una patente relacionada con el
sistema se emitió en 1992.

Algunos de los conceptos y tecnologías fundamentales de la industria para arreglos lógicos

programables , compuertas y bloques lógicos se basan en patentes otorgadas a David W.
Page y LuVerne R. Peterson en 1985.

Los cofundadores de Xilinx , Ross Freeman y Bernard Vonderschmitt, inventaron el primer

conjunto de compuertas programables de campo comercialmente viables en 1985: el
XC2064. El XC2064 tenía puertas programables e interconexiones programables entre
puertas, el comienzo de una nueva tecnología y mercado. El XC2064 tenía 64 bloques
lógicos configurables (CLB), con dos tablas de búsqueda de tres entradas (LUT). Más de 20
años después, Freeman ingresó al Salón de la Fama de los Inventores Nacionales por su
invención.

Altera y Xilinx continuaron sin competencia y crecieron rápidamente desde 1985 hasta
mediados de la década de 1990, cuando surgieron competidores, erosionando una

8
importante cuota de mercado. En 1993, Actel (ahora Microsemi ) prestaba servicios al 18
por ciento del mercado. Para 2010, Altera (31 por ciento), Actel (10 por ciento) y Xilinx (36
por ciento) juntos representaban aproximadamente el 77 por ciento del mercado de
FPGA.

La década de 1990 fue un período explosivo para los FPGA, tanto en sofisticación como en
el volumen de producción. A principios de la década de 1990, los FPGA se usaban
principalmente en telecomunicaciones y redes. Hacia el final de la década, los FPGA
llegaron a las aplicaciones de consumo, automotrices e industriales.

Dispositivos lógicos programables complejos (CPLD)

Las principales diferencias entre los CPLD (dispositivos lógicos programables complejos) y
los FPGA son arquitectónicos. Un CPLD tiene una estructura algo restrictiva que consiste
en una o más matrices lógicas de suma de productos programables que alimentan un
número relativamente pequeño de registros sincronizados. El resultado de esto es una
menor flexibilidad, con la ventaja de retrasos de temporización más predecibles y una
mayor relación lógica-interconexión. Las arquitecturas FPGA, por otro lado, están
dominadas por la interconexión. Esto los hace mucho más flexibles (en términos de la
gama de diseños que son prácticos para la implementación dentro de ellos) pero también
mucho más complejos de diseñar.

En la práctica, la distinción entre FPGA y CPLD suele ser de tamaño, ya que los FPGA
suelen ser mucho más grandes en términos de recursos que los CPLD. Normalmente, solo
los FPGA contienen funciones integradas más complejas, como sumadores,
multiplicadores, memoria y serdes. Otra distinción común es que los CPLD contienen flash
incrustado para almacenar su configuración, mientras que los FPGA usualmente
requieren, pero no siempre, memoria externa no volátil.

Aplicaciones

Un FPGA se puede usar para resolver cualquier problema que sea computable. Esto se
prueba trivialmente por el hecho de que FPGA se puede usar para implementar un
microprocesador blando, como Xilinx MicroBlaze o Altera Nios II. Su ventaja radica en que
a veces son significativamente más rápidos para algunas aplicaciones debido a su
naturaleza paralela y la optimalidad en términos del número de puertas utilizadas para un
determinado proceso.

Los FPGA originalmente comenzaron como competidores de los CPLD para implementar la
lógica de pegamento para PCB. A medida que aumentaron su tamaño, capacidades y
velocidad, se hicieron cargo de funciones adicionales hasta el punto de que algunos se
comercializan ahora como sistemas completos en chips ( SoC ). Particularmente con la
introducción de multiplicadores dedicados en arquitecturas FPGA a finales de la década de

9
1990, las aplicaciones que tradicionalmente habían sido la única reserva de DSP
comenzaron a incorporar FPGA en su lugar.

Otra tendencia en el uso de FPGA es la aceleración de hardware, donde uno puede usar el
FPGA para acelerar ciertas partes de un algoritmo y compartir parte del cálculo entre el
FPGA y un procesador genérico.

Tradicionalmente, los FPGA se han reservado para aplicaciones verticales específicas

donde el volumen de producción es pequeño. Para estas aplicaciones de bajo volumen, la
prima que pagan las empresas en costos de hardware por unidad para un chip
programable es más asequible que los recursos de desarrollo utilizados en la creación de
un ASIC para una aplicación de bajo volumen. Hoy, las nuevas dinámicas de costo y
rendimiento han ampliado la gama de aplicaciones viables.

Tipos básicos de tecnología de proceso

 SRAM : basado en tecnología de memoria estática. In-system programable y

reprogramable. Requiere dispositivos de arranque externos. CMOS. Actualmente uso.
Vale la pena señalar que los dispositivos flash o EEPROM a menudo pueden cargar
contenidos en SRAM interna que controla el enrutamiento y la lógica.
 Fusible : programable por única vez. Bipolar. Obsoleto.
 Antifusa - Programable por única vez. CMOS.
 PROM - Tecnología de memoria programable de solo lectura. Una sola vez
programable debido a los envases de plástico. Obsoleto.
 EPROM : tecnología de memoria de solo lectura programable borrable. Una vez
programable pero con ventana, puede borrarse con luz ultravioleta (UV). CMOS.
Obsoleto.
 EEPROM : tecnología de memoria de solo lectura programable y borrable
eléctricamente. Se puede borrar, incluso en paquetes de plástico. Algunos, pero no
todos los dispositivos EEPROM pueden ser programados en el sistema. CMOS.
 Flash : tecnología EPROM de borrado de flash. Se puede borrar, incluso en paquetes
de plástico. Algunos, pero no todos los dispositivos flash pueden ser programados en
el sistema. Habitualmente, una célula flash es más pequeña que una célula EEPROM
equivalente y, por lo tanto, es menos costosa de fabricar. CMOS.

Diseño y programación

Para definir el comportamiento de la FPGA, el usuario proporciona un diseño en un

lenguaje de descripción de hardware (HDL) o como un diseño esquemático. La forma HDL
es más adecuada para trabajar con estructuras grandes porque es posible especificarlas
numéricamente en lugar de tener que dibujar cada pieza a mano. Sin embargo, la entrada
esquemática puede permitir una visualización más fácil de un diseño.

10
Luego, utilizando una herramienta de automatización de diseño electrónico , se genera
una lista de redes asignada por tecnología. La lista de conexiones puede ajustarse a la
arquitectura de FPGA real utilizando un proceso llamado lugar y ruta , generalmente
realizado por el software propietario de ruta y ruta de la compañía FPGA. El usuario
validará el mapa, colocará y enrutará los resultados a través del análisis de tiempo , la
simulación y otras metodologías de verificación . Una vez que se completa el proceso de
diseño y validación, el archivo binario generado (también utilizando el software
propietario de la empresa FPGA) se utiliza para (re) configurar el FPGA. Este archivo se
transfiere al FPGA / CPLD a través de una interfaz en serie ( JTAG ) o a un dispositivo de
memoria externo como una EEPROM.

Los HDL más comunes son VHDL y Verilog , aunque en un intento por reducir la
complejidad del diseño en HDL, que se han comparado con el equivalente de los lenguajes
ensambladores , hay movimientos para elevar el nivel de abstracción a través de la
introducción de lenguajes alternativos . El lenguaje de programación gráfica LabVIEW de
National Instruments (a veces denominado "G") tiene un módulo adicional FPGA
disponible para el hardware FPGA de destino y programa.

Para simplificar el diseño de sistemas complejos en FPGA, existen bibliotecas de funciones

y circuitos complejos predefinidos que han sido probados y optimizados para acelerar el
proceso de diseño. Estos circuitos predefinidos se conocen comúnmente como núcleos IP,
y están disponibles en proveedores de FPGA y proveedores de IP de terceros (rara vez
gratuitos, y normalmente lanzados bajo licencias propietarias). Otros circuitos
predefinidos están disponibles desde comunidades de desarrolladores como OpenCores
(normalmente lanzados bajo licencias de código abierto y gratuito como GPL, BSD o
similar) y otras fuentes.

En un flujo de diseño típico, un desarrollador de aplicaciones FPGA simulará el diseño en

múltiples etapas a lo largo del proceso de diseño. Inicialmente, la descripción de RTL en
VHDL o Verilog se simula creando bancos de prueba para simular el sistema y observar los
resultados. Luego, después de que el motor de síntesis ha mapeado el diseño a una lista
de redes, la lista de redes se traduce a una descripción del nivel de la puerta donde se
repite la simulación para confirmar que la síntesis se realizó sin errores. Finalmente, el
diseño se presenta en el FPGA en cuyo punto se pueden agregar retrasos de propagación
y la simulación se ejecuta nuevamente con estos valores anotados de nuevo en la lista de
conexiones.

Más recientemente, OpenCL está siendo utilizado por los programadores para aprovechar
el rendimiento y la eficiencia energética que proporcionan los FPGA. OpenCL permite a los
programadores desarrollar código en el lenguaje de programación C y seleccionar
funciones FPGA como kernels OpenCL usando construcciones OpenCL.

11
DESARROLLO

CONVERTIDOR
Código:

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

entity convertidor is

Port ( Entrada: in STD_LOGIC_VECTOR (5 DOWNTO 0) ;

Salida: out STD_LOGIC_VECTOR (6 DOWNTO 0);

display1: out STD_LOGIC;

display2: out STD_LOGIC;

display3: out STD_LOGIC;

display4: out STD_LOGIC);

end convertidor;

architecture Behavioral of convertidor is

begin

display1 <= '0';

display2 <= '1';

display3 <= '1';

display4 <= '1';

process (Entrada)

begin

case Entrada is

-- Code 8421 7421:

when "000000"=> Salida <= "0000001"; --0

when "000001"=> Salida <= "1001111"; --1

when "000010"=> Salida <= "0010010"; --2

when "000011"=> Salida <= "0000110"; --3

12
when "000100"=> Salida <= "1001100"; --4

when "000101"=> Salida <= "0100100"; --5

when "000110"=> Salida <= "0100000"; --6

when "000111"=> Salida <= "0001111"; --E

when "001000"=> Salida <= "0001111"; --7

when "001001"=> Salida <= "0000000"; --8

when "001010"=> Salida <= "0001100"; --9

when "001011"=> Salida <= "0110000"; --E

when "001100"=> Salida <= "0110000"; --E

when "001101"=> Salida <= "0110000"; --E

when "001110"=> Salida <= "0110000"; --E

when "001111"=> Salida <= "0110000"; --E

-- Code 8421 5421:

when "010000"=> Salida <= "0000001"; --0

when "010001"=> Salida <= "1001111"; --1

when "010010"=> Salida <= "0010010"; --2

when "010011"=> Salida <= "0000110"; --3

when "010100"=> Salida <= "1001100"; --4

when "010101"=> Salida <= "0110000"; --E

when "010110"=> Salida <= "0110000"; --E

when "010111"=> Salida <= "0110000"; --E

when "011000"=> Salida <= "0100100"; --5

when "011001"=> Salida <= "0100000"; --6

when "011010"=> Salida <= "0001111"; --7

when "011011"=> Salida <= "0000000"; --8

when "011100"=> Salida <= "0001100"; --9

when "011101"=> Salida <= "0110000"; --E

13
when "011110"=> Salida <= "0110000"; --E

when "011111"=> Salida <= "0110000"; --E

-- Code 8421 2421:

when "100000"=> Salida <= "0000001"; --0

when "100001"=> Salida <= "1001111"; --1

when "100010"=> Salida <= "0010010"; --2

when "100011"=> Salida <= "0000110"; --3

when "100100"=> Salida <= "1001100"; --4

when "100101"=> Salida <= "0110000"; --E

when "100110"=> Salida <= "0110000"; --E

when "100111"=> Salida <= "0110000"; --E

when "101000"=> Salida <= "0110000"; --E

when "101001"=> Salida <= "0110000"; --E

when "101010"=> Salida <= "0110000"; --E

when "101011"=> Salida <= "0100100"; --5

when "101100"=> Salida <= "0100000"; --6

when "101101"=> Salida <= "0001111"; --7

when "101110"=> Salida <= "0000000"; --8

when "101111"=> Salida <= "0001100"; --9

-- Code 8421 EXC3:

when "110000"=> Salida <= "0110000"; --E

when "110001"=> Salida <= "0110000"; --E

when "110010"=> Salida <= "0110000"; --E

when "110011"=> Salida <= "0000001"; --0

when "110100"=> Salida <= "1001111"; --1

when "110101"=> Salida <= "0010010"; --2

when "110110"=> Salida <= "0000110"; --3

14
when "110111"=> Salida <= "1001100"; --4

when "111000"=> Salida <= "0100100"; --5

when "111001"=> Salida <= "0100000"; --6

when "111010"=> Salida <= "0001111"; --7

when "111011"=> Salida <= "0000000"; --8

when "111100"=> Salida <= "0001100"; --9

when "111101"=> Salida <= "0110000"; --E

when "111110"=> Salida <= "0110000"; --E

when "111111"=> Salida <= "0110000"; --E

end case;

end process;

end Behavioral;

Simulación:

15
RELOJ DIGITAL
Código:

16
library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity digital_clock_top is

port (

clk50mhz: in STD_LOGIC;

display: out STD_LOGIC_VECTOR(7 downto 0);

cur_display: out STD_LOGIC_VECTOR(3 downto 0)

);

end digital_clock_top;

architecture Behavioral of digital_clock_top is

constant max_count: INTEGER := 25000000; -- 50000000/2

constant max_refresh_count: INTEGER := 100000; -- 50Mzh/100000=500Hz

signal count: INTEGER range 0 to max_count;

signal refresh_count: INTEGER range 0 to max_refresh_count;

signal refresh_state: STD_LOGIC_VECTOR(1 downto 0) := (others => '0');

signal clk_state: STD_LOGIC := '0';

signal display_sel: STD_LOGIC_VECTOR(3 downto 0) := (others => '0');

shared variable hora1, hora2, min1, min2: INTEGER range 0 to 10 := 0;

shared variable segundos: INTEGER range 0 to 59 := 0;

function digito(numero:INTEGER) return STD_LOGIC_VECTOR is

variable salida: STD_LOGIC_VECTOR(7 downto 0);

begin

case numero is

17
 when 0 => salida := "00000011"; -- 0

when 1 => salida := "10011111"; -- 1

when 2 => salida := "00100101"; -- 2

when 3 => salida := "00001101"; -- 3

when 4 => salida := "10011001"; -- 4

when 5 => salida := "01001001"; -- 5

when 6 => salida := "01000001"; -- 6

when 7 => salida := "00011111"; -- 7

when 8 => salida := "00000001"; -- 8

when 9 => salida := "00001001"; -- 9

when others => salida := "11111111";

end case;

return(salida);

end digito;

begin

cur_display <= display_sel;

gen_clock: process(clk50mhz, clk_state, count)

begin

if clk50mhz'event and clk50mhz='1' then

-- contador 1HZ

if count < max_count then

count <= count + 1;

else

clk_state <= not clk_state;

count <= 0;

18
 end if;

-- contador 500Hz (para refresco del display)

if refresh_count < max_refresh_count then

refresh_count <= refresh_count + 1;

else

refresh_state <= refresh_state + 1;

refresh_count <= 0;

end if;

end if;

end process;

show_display: process(refresh_state)

begin -- selección del display

case refresh_state is

when "00" => display_sel <= "1110"; -- display 0

when "01" => display_sel <= "1101"; -- display 1

when "10" => display_sel <= "1011"; -- display 2

when "11" => display_sel <= "0111"; -- display 3

when others => display_sel <= "1111";

end case;

-- mostrar hora

case display_sel is

when "1110" => display <= digito(hora2); -- display 0

when "1101" => display <= digito(hora1); -- display 1

when "1011" => display <= digito(min2); -- display 2

19
 when "0111" => display <= digito(min1); -- display 3

when others => display <= "11111111";

end case;

-- parpadeo del punto

if display_sel="1101" then

display(0) <= clk_state;

end if;

end process;

persecond: process (clk_state)

begin

if clk_state'event and clk_state='1' then

-- contador de segundos

if segundos < 59 then

segundos := segundos + 1;

else

segundos := 0;

min1 := min1 + 1; -- +1 minuto

end if;

-- segundo dígito minutero

if min1 = 10 then

min2 := min2 + 1;

min1 := 0;

end if;

20
 -- primer dígito hora

if min2 = 6 then

hora1 := hora1 + 1;

min2 := 0;

end if;

-- segundo dígito hora

if hora1 = 10 then

hora2 := hora2 + 1;

hora1 := 0;

end if;

if hora2=2 and hora1=4 then

hora2 := 0;

hora1 := 0;

end if;

end if;

end process;

end Behavioral;

21
Simulación:

22
CHAPA ELÉCTRICA
Código:

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

entity CHAPA is

Port ( CLK : in STD_LOGIC;

BTN : in STD_LOGIC_VECTOR (4 downto 0);

LED : out STD_LOGIC_VECTOR (5 downto 0));

end CHAPA;

---clave chapa 31771

architecture Behavioral of CHAPA is

-- alias

alias RST : STD_LOGIC is BTN(0);

alias A : STD_LOGIC is BTN(4);--#1

alias B : STD_LOGIC is BTN(2);--#3

alias C : STD_LOGIC is BTN(3);--#7

alias Y0 : STD_LOGIC is LED(0); --estado reset

23
 alias Y1 : STD_LOGIC is LED(1); --estado 1

alias Y2 : STD_LOGIC is LED(2); --estado 2

alias Y3 : STD_LOGIC is LED(3); --estado 3

alias Y4 : STD_LOGIC is LED(4); --estado 4

alias Y5 : STD_LOGIC is LED(5); --estado 5

-- declaraciones modelo CHAPA

type STATES is (S0, S1, S2, S3, S4, S5);--R 3-1-7-7-1

signal state_reg, state_next: STATES;

begin

-- registro de estados

process(CLK)

begin

if CLK'event and CLK='1' then

if RST='1' then

state_reg <= s0;

else

state_reg <= state_next;

end if;

end if;

end process;

-- Lógica de estado siguiente (circuito combinacional)

process (state_reg, A, B, C)

begin

state_next <= state_reg;

24
 case state_reg is

when S0 =>

if B='1' then --#3

state_next <= S1;

end if;

when S1 =>

if A='1' then --#1

state_next <= S2;

end if;

when S2 =>

if C='1' then --#7

state_next <= S3;

end if;

when S3 =>

if C='1' then --#7

state_next <= S4;

end if;

when S4 =>

if A='1' then --#1

state_next <= S5;

end if;

when S5 =>

state_next <= S5; ---fin de secuencia 31771

end case;

end process;

-- salida tipo Moore

25
 process (state_reg)

begin

-- estableciendo la salida por defecto

-- nos aseguramos de crear un circuito

-- combinacional sin latches.

Y0 <= '0';

Y1 <= '0';

Y2 <= '0';

Y3 <= '0';

Y4 <= '0';

Y5 <= '0';

case state_reg is

when S0 => Y0 <= '1'; --los led encenderan para mostrar en que estado estan

when S1 => Y1 <= '1';

when S2 => Y2 <= '1';

when S3 => Y3 <= '1';

when S4 => Y3 <= '1';

when S5 => Y3 <= '1';

end case;

end process;

end Behavioral;

26
Simulación:

27
CONCLUSIONES

 Con la ayuda de la herramienta VIVADO se logró implementar el convertidor de código

y del reloj digital con el cual solo fue necesaria generar la respectiva tabla de verdad y
declararla en un código VHDL y se logra verificar el buen funcionamiento del mismo
con la simulación por diagramas de tiempo.

 Para la realización de la chapa se utilizó una libreria bastante útil incluida en VIVADO
con la cual se generó una máquina de estados tipo Mealy la cual es de mucha utilidad
porque solo es necesario de diagrama de estados para poder realizar dicho diseño.

BIBLIOGRAFÍA

 Victor P. Nelson, H. Troy Nagle, Bill D.Carrol, J. David Irwin, Analisis y Diseño de
Circuitos Logicos Digitales, Prentince Hall.

28