UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

(Universidad del Perú, DECANA DE AMERICA)

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRÓNICA

CURSO PROCESAMIENTO DE SEÑALES DIGITALES

TEMA LABORATORIO DE FPGA

PROFESOR CARRILLO

HORARIO VIERNES DE 10am a 1pm

Ciudad Universitaria, 28 de julio del 2018

LABORATORIO Nº1
OBJETIVOS:
  En el siguiente proyecto experimentaremos con el módulo FPGA y usaremos los
softwares Max plus y Quartus para poder hacer las simulaciones.
 Preparar, experimentar y almacenar como datos las muestras de señales
generadas por un programa o señales de voz y audio para trabajarlo junto con
el módulo FPGA.
DESARROLLO

 Paso 1: Crear un nuevo proyecto

 Paso 2: Diseño Entrada (Esquema)
 Paso 3: Síntesis: En la etapa de síntesis, el análisis se realiza en el diseño
esquemático y se genera un circuito de orientación del dispositivo FPGA
seleccionado.
 Paso 4: Simulación: en este paso se usara un software adicional ModelSim
debido a que el programa no tiene un simulador o en este caso usaremos el
maxplux que es un software alternativo que también nos permite simular
circuitos digitales.

Instalamos el programa Quartus.

Una fotografía de la placa DE2-115 se muestra en la Figura 2-1, con sus respectivos
nombres y funciones.

Diagrama de bloques del DE2-115

Dado el diagrama de bloques de la placa DE2-115. Para proporcionar la máxima
flexibilidad para el usuario, todas las conexiones se realizan a través del dispositivo
FPGA Cyclone IV E. Por lo tanto, el usuario puede configurar el FPGA para implementar
cualquier diseño de sistema.
INFORMACIÓN TEÓRICA
Unidades de diseño
En un programa VHDL hay dos bloques básicos: La entidad y la arquitectura.
Entidad: La entidad, nos sirve para relacionar nuestro diseño con el mundo exterior, es
decir, analizamos lo que tratamos de crear como una "caja negra", de la que sólo
conocemos sus entradas, salidas y la disposición de las mismas.
Sintaxis:
entity identificador is
[genéricos]
[puertos]
end [identificador];
Nota: lo que se encuentra entre corchetes [] se considera que su uso es opcional.
Cada señal en una declaración de entidad está referida a un puerto (o grupo de
señales), el cual es análogo a un(os) pin(es) del símbolo esquemático. Un puerto es un
objeto de información, el cual puede ser usado en expresiones y a la vez se le pueden
asignar valores. A cada puerto se le debe asignar un nombre válido.

La declaración de un puerto consta de:

- nombre: identifica a un pin de la entidad
- modo: indica el flujo de la señal.
- tipo: indica el conjunto de valores que puede tomar un objeto, en este caso el
puerto.

El modo determina como las sentencias de la arquitectura pueden acceder al puerto.

Tenemos 4 tipos de modos:
- in: es de sólo lectura (no se puede escribir).
- out: es de sólo escritura (no se puede leer).
- buffer: se comporta como un puerto de salida (out) que se puede leer.
- Inout: es de tipo bidireccional, quiere decir que se puede leer y escribir.

Sólo para fines de simulación todo puerto puede tener un valor por defecto que
determina el valor inicial de la señal, los puertos de entrada pueden dejarse
desconectados si tienen un valor por defecto.

Arquitectura: En la declaración de la arquitectura es donde reside todo el

funcionamiento de un programa, ya que es ahí donde se indica que hacer con cada
entrada para obtener la salida. La arquitectura es el conjunto de detalles interiores de
la caja negra.
Sintaxis:
architecturenombreofentidadis
- - Zona de declaración
begin
sentencias concurrentes;
sentencias concurrentes;
sentencias concurrentes;
end nombre;
Estilo flujo de datos para el diseño de circuitos combinacionales:

Este estilo se caracteriza por utilizar las asignaciones concurrentes a señales (ACS).
Tenemos 3 tipos de ACS:
- ACS única
- ACS condicional
- ACS selectiva
Estas sentencias terminan asignando un valor a una señal después de evaluar toda una
expresión, esta evaluación se realiza cuando ocurre un evento en una de las señales
que se encuentran a la derecha del símbolo de asignación a señal (<=).

ACS única: se basa en expresiones muy parecidas a las ecuaciones booleanas, en la

mayoría de los casos se expresan en suma de términos producto.
Sintaxis:
señal<= expresión;

en la expresión pueden aparecer valores, señales, operadores lógicos o aritméticos.

Veamos algunos ejemplos:
enable<= ‘1’;
z <= a and b or c;
f <= p1 + p2;
temp<= var1 & var2;
y <= “10101”;

ACS condicional: se basa en expresiones que deben evaluar una condición y

dependiendo de la respuesta terminan asignando el resultado de la expresión a la
señal.
Sintaxis:
señal<= expresión1 when condición1 else expresión2;

En la declaración anterior, si la condición1 es verdadera entonces la señal toma el

resultado de la expresión1, caso contrario (si condición1 es falsa) entonces la señal
toma el resultado de la expresión2.

La sintaxis de la ACS condicional en su forma general es:

señal<= expresión1 when condición1 else

expresión2 when condición2 else
expresión3 when condición3 else
........
ExpresiónN when condiciónN else expresiónM;

En la declaración anterior se nota que hay una prioridad en la asignación a señal, por
ejemplo, para que la señal tome el resultado de la expresión3 debe cumplirse que la
condición1 y condición2 sean falsas y la condición3 sea verdadera. La prioridad la tiene
la condición1, si esta no se cumple se pasa a evaluar la condición2, si esta no se cumple
se pasa a evaluar la condición3 y así sucesivamente se evalúan todas las condiciones
hasta que cumpla alguna de ellas.

Hay que aclarar que siempre se termina evaluando una expresión y asignando la
respuesta a la señal así no se cumpla ninguna condición.

Veamos algunos ejemplos:

- compuerta AND:

C <= A when B =’1’ else ‘0’;

- multiplexor de 2 a 1:

Z <= A when SEL=’0’ else B;

- en el siguiente circuito:

F <= A when Z=’1’ else

B when Y =’1’ else
C when X = ‘1’ else ‘0’;

- decodificador de 3 a 8;
 ENTRADA <= C & B & A;
TEMPORAL <= “11111110” when ENTRADA = “000” else
“11111101” when ENTRADA = “001” else
“11111011” when ENTRADA = “010” else
“11110111” when ENTRADA = “011” else
“11101111” when ENTRADA = “100” else
“11011111” when ENTRADA = “101” else
“10111111”whenENTRADA=“110”else“01111111”
;
Y <= TEMPORAL when ENA =’1’ else “11111111”;

ACS selectivo: se utiliza mucho para implementar tablas de verdad de pequeños

circuitos. Se evalúa una expresión (la que sigue a la palabra with) y de acuerdo al valor
que tome se le asigna a la señal la respuesta de una expresión. Veamos su sintaxis:

with expresión select señal <= expresión1 when valor1,

expresión2 when valor2,
expresión3 when valor3,
............
expresiónNwhenvalorN;

Esta sentencia requiere que se especifique todos los posibles valores que puede tomar
la expresión a evaluar, por lo que generalmente la sentencia se escribe de la siguiente
manera:

with expresión select señal <= expresión1 when valor1,

expresión2 when valor2,
expresión3 when valor3,
............
expresiónNwhenothers;

Con la palabra others se está cubriendo el resto de valores que no han sido
especificados en la sentencia. Veamos algunos ejemplos:

- compuerta AND:

with A select C <= B when ’1’

‘0’ when ‘0’;
Asumimos que A sólo puede tomar los valores de ‘0’ y ‘1’ (tipo bit);
- multiplexor de 2 a 1:
 with SELselect Z <= A when ‘0’,
B whenothers;
Asumimos que SEL puede tomar otros valores aparte de ‘0’ y ‘1’ (tipo std_logic).
- Decoder de 2 a 4:

with E select Y <= “1110” when “00”,

“1101” when “01”,
“1011” when “10”
“0111” whenothers;

Laboratorio 2
Crear el circuito medio sumador mostrado en la Fig. 2.3 usando el editor de entradas de
diseño VHDL;

Paso 1: Crear un nuevo proyecto

Paso 2: Entrada de diseño (VHDL)

Como el QUARTUS no tiene simulador usamos el programa Model sim:

 LABORATORIO Nº3
DISEÑO JERARQUICO:
En este capítulo se introduce el concepto de diseño jerárquico en los sistemas digitales. Un
proyecto VHDL completa hecha de varios componentes se desarrolla como un estudio de
caso, y sus componentes están pegadas entre sí usando las palabras reservadas VHDL
componente y portmap.
IMPLEMENTACION DEL SIGUIENTE CIRCUITO POR MEDIO DE COMPONENT:

Primero hacemos el código de los 3 bloques C1, C2, C3 respectivamente:

Ahora implementamos el código para la parte C4

Ahora implementamos la parte de los component para unir las partes anteriores:
 Ahora declaramos las entradas y salidas del FPGA:

LOS VALORES QUE DEBEMOS OBTENER AL SIMULAR SON LOS SIGUIENTES:

 LABORATORIO 4:

 Multiplexores y Demultiplexores:
Los multiplexores son circuitos combinacionales con varias entradas y una única salida
de datos. Están dotados de entradas de control capaces de seleccionar una, y sólo una,
de las entradas de datos para permitir su transmisión desde la entrada seleccionada
hacia dicha salida.

Implementacion en VHDL multiplexor de 3 a 1:

Simulacion del multiplexor 3 a 1:

  Demultiplexor:
Un demultiplexor es un circuito combinacional que tiene una entrada de
información de datos d y n entradas de control que sirven para seleccionar una de las
2n salidas, por la que ha de salir el dato que presente en la entrada.

A continuación, un demultiplexor con una entrada de 3 bits, un enable, un

seleccionador, y 3 salidas dependientes del seleccionador.
Implementando en language VHD:
Realizando la simulación:

CIRCUITO A IMPLEMENTAR:

A. USAMOS LOS CODIGOS DEL LABORATORIO 4 PARA C1, C2, C3 Y AÑADIMOS LA

PARTE DEL MUX:
AÑADIMOS LA PARTE COMPONENT PARA UNIR LOS DEMAS BLOQUES:
 LABORATORIO 5
En este capítulo se introduce una categoría de circuitos conocidos como convertidores
de código. Este tipo de circuito incluye los codificadores y los decodificadores. Los
codificadores son circuitos utilizados en la conversión de la información en un formato
a otro. Los decodificadores son circuitos complementarios, usados para deshacer una
conversión realizada por un codificador. Los conceptos de circuitos convertidores de
código se investigan en este capítulo a través de su implementación en VHDL.

 Codificador:

Un codificador es un circuito combinatorio que cuenta con un número

determinado de entradas, de las cuales sólo una tiene el estado lógico 1, y se
genera un código de varios bits que depende decuál sea la entrada excitada.

Ejemplo de codificador de 3 a 2

Implementación en VHDL

 Decodificador:
Un decodificador es un circuito combinacional, cuya función es inversa a la
del codificador, es decir, convierte un código binario de entrada (natural, BCD, etc.)
de N bits de entrada y M líneas de salida (N puede ser cualquier entero y M es un
entero menor o igual a 2N), tales que cada línea de salida será activada para una
sola de las combinaciones posibles de entrada. Normalmente, estos circuitos
suelen encontrarse como decodificador / demultiplexor. Esto es debido a que un
demultiplexor puede comportarse como un decodificador.
Si por ejemplo se tiene un decodificador de 2 entradas con 2 2=4 salidas, su
funcionamiento sería el que se indica en la siguiente tabla, donde se ha
considerado que las salidas se activen con un "uno" lógico.

Ejemplo decodificador de 3 a 8 con habilitador:

Implemente el siguiente circuito en VHDL:

a) PARA IMPLEMENTAR EL SIGUIENTE CIRCUITO EN EL FPGA USAMOS EL

SIGUIENTE CODIGO:
 LABORATORIO 6

 SISTEMAS SECUENCIALES
A diferencia de los sistemas combinacionales, en los sistemas secuenciales, los valores
de las salidas, en un momento dado, no dependen exclusivamente de los valores de las
entradas en dicho momento, sino también dependen del estado anterior o estado interno.
El sistema secuencial más simple es el biestable, de los cuales, el de tipo D (o cerrojo) es
el más utilizado actualmente.
El sistema secuencial requiere de la utilización de un dispositivo de memoria que pueda
almacenar la historia pasada de sus entradas (denominadas variables de estado) y le
permita mantener su estado durante algún tiempo, estos dispositivos de memoria pueden
ser sencillos como un simple retardador o celdas de memoria de tipo DRAM, SRAM2 o
multivibradores biestables también conocido como Flip-Flop1 entre otros.

En este laboratorio se usará la sentencia PROCESS.

 Ejemplo_1 en VHDL

 PROCESS
Un PROCESS, como se ha dicho antes, es una sentencia concurrente en el sentido de
que todos los PROCESS y todas las demás sentencias concurrentes se ejecutarán sin un
orden establecido. No obstante las sentencias que hay dentro del PROCESS se ejecutan
de forma secuencial.
Por lo tanto se puede decir que una estructura secuencial va en el interior de
un PROCESS.
La estructura genérica de esta sentencia es:
 PROCESS [lista de sensibilidad]
[declaración de variables]
BEGIN
[sentencias secuenciales]
END PROCESS;

La lista de sensibilidad es una serie de señales que, al cambiar de valor, hacen que se
ejecute el PROCESS.
Un ejemplo sería:

PROCESS(señal1, señal2)
...

El PROCESS anterior sólo se ejecutará cuando señal1 o señal2 cambien de valor.

 Ejemplo_2 en VHDL
 Simulación del código anterior

 Latch SR
 El latch lógico más simple es el SR, donde R y S representan los estados
'reset' y 'set' respectivamente. El latch es construido mediante la
interconexión retroalimentada de puertas lógicas NOR (negativo OR), o
bien de puertas lógicas NAND (aunque en este caso la tabla de verdad
tiene salida en lógica negativa para evitar la incongruencia de los datos). El
bit almacenado está presente en la salida marcada como Q, y Q´ su
complementación (valor negativo a Q).
 Al tener dos entradas para el ingreso de datos (S y R), tenemos 4 posibles
combinaciones (recordando que 2n representa las combinaciones posibles
con datos binarios, donde 'n' representa el número de bits a trabajar). Cada
combinación define el estado presente en Q, de esta manera tenemos la
siguiente tabla de verdad:
  Ejemplo en vhdl

 Latch D
También conocido como latch transparente, debido a que el nivel presente en D se
almacenará en el latch en el momento en que la entrada Habilitar (Enable por su palabra
en inglés), sea activada, generalmente mediante un estado alto, es decir 1.
Al tener dos entradas para el ingreso de datos (EN y D), tenemos 4 posibles
combinaciones (recordando que 2n representa las combinaciones posibles con datos
binarios, donde 'n' representa el número de bits a trabajar). Cada combinación define el
estado presente en Q, de esta manera tenemos la siguiente tabla de verdad
  Ejemplo en vhdl

 D Flip-Flop
Un biestable (flip-flop en inglés), es un multivibrador capaz de permanecer en uno de dos
estados posibles durante un tiempo indefinido en ausencia de perturbaciones.1 Esta
característica es ampliamente utilizada en electrónica digital para memorizar información.
El paso de un estado a otro se realiza variando sus entradas. Dependiendo del tipo de
dichas entradas los biestables se dividen en:

 Asíncronos: solamente tienen entradas de control. El más empleado es el biestable

RS.
 Síncronos: además de las entradas de control posee una entrada de sincronismo o de
reloj.
Si las entradas de control dependen de la de sincronismo se denominan síncronas y en
caso contrario asíncronas. Por lo general, las entradas de control asíncronas prevalecen
sobre las síncronas.
 Ejemplo en vhdl
 D Flip-Flop con reset

 Ejemplo en vhdl
 D Flip-Flop con reset y con habilitador

 Ejemplo en vhdl

 Simulación

 Implementación de registros con Flip-Flop tipo D.

 Un registro es un grupo de celdas de almacenamiento binario

adecuadas para mantener información binaria. Un grupo de flip-flop
constituye un registro, ya que cada flip-flop es una celda binaria capaz
de almacenar un bit de información. Un registro de n-bit tiene un grupo
de n flip-flop y es capaz de almacenar cualquier información binaria que
contenga n bits. Además de los flip-flop, un registro puede tener
compuertas combinacionales que realicen ciertas tareas de
procesamiento de datos. En su definición más amplia, un registro consta
de un grupo de flip-flop y compuertas que efectúan una transición. Los
flip-flop mantienen la información binaria y las compuertas controlan
cuando y como se transfiere información nueva al registro.
 Ejemplo en vhdl
Registro de 4 bits con flip flops tipo D

Desarrollo del laboratorio

Se implementará el siguiente circuito
 Bloques:
 C1
 C2

 C3
 C4

 Mux4a1
 Registro de 4 bits

 Registro de 8 bits
 Decodificador de 7 segmentos

 Para la implementación del circuito se unió todos los bloques en un solo

archivo vhdl con ayuda de la sentencia component. Este circuito nos permite
realizar 4 distintas operaciones y mostrar el resultado en los display de 7
segmentos.

 Código VHDL del circuito

library ieee;
use ieee.std_logic_1164.all;

entity top_calc is
port ( sw: in std_logic_vector (17 downto 0);
clock,reset,enter: in std_logic;
hex0,hex1: out std_logic_vector(6 downto 0);
ledr: out std_logic_vector(7 downto 0)
);
end top_calc;

architecture solucion of top_calc is

signal f1,f2,f3,f4,f: std_logic_vector(7 downto 0);
signal g1,g2: std_logic_vector(3 downto 0);
component C1
port(
A,B: in std_logic_vector(7 downto 0);
F: out std_logic_vector(7 downto 0));
end component;

component C2
port(
A,B: in std_logic_vector(7 downto 0);
F: out std_logic_vector(7 downto 0));
end component;

component C3
port(
A,B: in std_logic_vector(7 downto 0);
F: out std_logic_vector(7 downto 0));
end component;

component C4
port(
A: in std_logic_vector(7 downto 0);
F: out std_logic_vector(7 downto 0));
end component;

component mux4x1
port(
w,x,y,z: in std_logic_vector(7 downto 0);
s: in std_logic_vector(1 downto 0);
m: out std_logic_vector(7 downto 0));
end component;
component D_4FF
port(
CLK,RST,ENABLE: in std_logic;
D: in std_logic_vector(3 downto 0);
Q: buffer std_logic_vector(3 downto 0));
end component;

component D_8FF
port(
CLK,RST,ENABLE: in std_logic;
D: in std_logic_vector(7 downto 0);
Q: buffer std_logic_vector(7 downto 0));
end component;

component DECO7SEG
port (ENT: in std_logic_vector(3 downto 0);
DISPLAY: out std_logic_vector(6 downto 0));
end component;

begin
L1: C1 port map (sw(15 downto 8),sw(7 downto 0),f1);
L2: C2 port map (sw(15 downto 8),sw(7 downto 0),f2);
L3: C3 port map (sw(15 downto 8),sw(7 downto 0),f3);
L4: C4 port map (sw(7 downto 0),f4);
L5: mux4x1 port map (f1,f2,f3,f4,sw(17 downto 16),f);
L6: D_4FF port map (clock,reset,enter,f(7 downto 4),g1);
L7: D_4FF port map (clock,reset,enter,f(3 downto 0),g2);
L8: D_8FF port map (clock,reset,enter,f,ledr);
L9: DECO7SEG port map (g1,hex1);
L10: DECO7SEG port map (g2,hex0);

end solucion;
 LABORATORIO 7
Maquinas de estados (FSM)
Se denomina máquina de estados a un modelo de comportamiento de un sistema con
entradas y salidas, en donde las salidas dependen no sólo de las señales de entradas
actuales sino también de las anteriores.
Las máquinas de estados se definen como un conjunto de estados que sirve de
intermediario en esta relación de entradas y salidas, haciendo que el historial de señales
de entrada determine, para cada instante, un estado para la máquina, de forma tal que la
salida depende únicamente del estado y las entradas actuales.
Una máquina de estados se denomina máquina de estados finitos (FSM por finite state
machine) si el conjunto de estados de la máquina es finito, este es el único tipo de
máquinas de estados que podemos modelar en un computador en la actualidad; debido a
esto se suelen utilizar los términos máquina de estados y máquina de estados finitos de
forma intercambiable. Sin embargo un ejemplo de una máquina de estados
infinitos sería un computador cuántico esto es debido a que los Qubit que utilizaría este
tipo de computadores toma valores continuos, en contraposición los bits toman valores
discretos (0 ó 1). Otro buen ejemplo de una máquina de estados infinitos es una Máquina
universal de Turing la cual se puede definir teóricamente con una "cinta" o memoria
infinita.
La representación de una máquina de estados se realiza mediante un Diagrama de
estados, sin embargo también es posible utilizar un Diagrama de flujo.

 Ejemplo de diagrama de máquinas de estados

 Máquina de Moore

 Una Máquina de Moore es un autómata de estados finitos para el cual la salida en

un momento dado sólo depende de su estado en ese momento, mientras la
transición al siguiente estado depende del estado en que se encuentre y de la
entrada introducida. El diagrama de estados para una máquina Moore incluirá una
 señal de salida para cada estado. Comparada con la Máquina de Mealy, la cual
mapea transiciones en la máquina a salidas.

 Ejemplo en VHDL
 Diseño de un contador anillo con máquinas de estados

 Simulación del contador

  Contador para generar un retraso de un segundo. Se hace uso de un
oscilador de 27 MHZ en este ejemplo.

Desarrollo del laboratorio

Se implementará el siguiente circuito
 Bloques:
 FSM

 Decodificador de 7 segmentos
 Para la implementación del circuito se unió todos los bloques en un solo
archivo vhdl con ayuda de la sentencia component. Este circuito nos permite
visualizar en los display las letras desde la A hasta la Z(los números en
hexadecimal es lo que se visualizará en los display).

 Código VHDL del circuito

library IEEE;
use IEEE.Std_Logic_1164.all;

entity topstate is
port (key : in std_logic_vector(3 downto 0);
clk : in std_logic;
TD_RESET : out std_logic;
HEX0, HEX1 : out std_logic_vector(6 downto 0);
LEDG : out std_logic_vector(7 downto 0));
end topstate;

architecture solucion of topstate is

signal F: std_logic_vector(7 downto 0);

component ASCII_counter
port (clk : in std_logic;
key : in std_logic;
ASCII : buffer std_logic_vector(7 downto 0));
end component;

component decod7seg
port(A: in std_logic_vector(3 downto 0);
F1: out std_logic_vector(6 downto 0));
end component;
begin

TD_RESET <= '1';

L0:ASCII_counter port map(clk,key(0),F);

L1:decod7seg port map(F(7 downto 4),HEX0);
L2:decod7seg port map(F(3 downto 0),HEX1);

LEDG<=F;

end solucion;
 LABORATORIO 8

Uso de maquinas de estado como controlador

 Objetivos:
 Comprender los conceptos básicos de la unidad de control de datos y
de control
 Para diseñar la máquina de estados de una unidad de control
 Implementar una unidad de control para nuestra calculadora

 Diseñando un controlador de máquina expendedora

 Diagrama de estados:

 Tabla de transición
 Código VHDL

Desarrollo del laboratorio

Se desarrollará el siguiente circuito:
 o Debido a que muchas partes de este circuito ya han sido desarrolladas
con anterioridad, solamente se añadirá los códigos restantes:

 Controlador FSM
library ieee;
use ieee.std_logic_1164.all;

entity FSMctrl is
port(clk, rst, enter: in std_logic;
operation: in std_logic_vector(1 downto 0);
--selection: out std_logic_vector(1 downto 0);
enable_1, enable_2: out std_logic);
end FSMctrl;

architecture solucion of FSMctrl is

type states is (s0, s1, s2, s3, s4, s5, s6, s7);
signal EP, ES: states;

begin
process(clk, rst)
begin
if rst = '0' then
 EP <= s0;
elsif rising_edge(clk) then
EP <= ES;
end if;
end process;

process (EP, enter)

begin
case EP is
when s0 =>
if enter = '1' then ES <= s0;
else ES <= s1;
end if;
enable_1 <= '0'; enable_2 <= '0';
when s1 =>
if enter = '1' then ES <= s2;
else ES <= s1;
end if;
enable_1 <= '1'; enable_2 <= '0';
when s2 => -- Operator
enable_1 <= '0'; enable_2 <= '0';
if operation = "00" then
ES <= s3; -- ADD
elsif operation = "01" then
ES <= s4; -- OR
elsif operation = "10" then
ES <= s5; -- XOR
else
ES <= s6; -- NOT
end if;
when s3 => -- A + B
if enter = '1' then ES <= s3;
else ES <= s7;
end if;
--selection <= "00";
when s4 => -- A OR B
if enter = '1' then ES <= s4; else ES <= s7; end if;
--selection <= "01";
when s5 => -- A XOR B
if enter = '1' then ES <= s5; else ES <= s7; end if;
--selection <= "10";
when s6 => -- NOT A
enable_1 <= '0'; enable_2 <= '1';
--selection <= "11";
 ES <= s0;
when s7 => -- WRITE
enable_1 <= '0'; enable_2 <= '1';
ES <= s0;
end case;
end process;
end solucion;

 Circuito Final
library IEEE;
use IEEE.std_logic_1164.all;

entity top_calc is
port(SW: in std_logic_vector(17 downto 0);
EN,CLK,RST: in std_logic;
DISP1, DISP0: out std_logic_vector(6 downto 0);
LEDR: out std_logic_vector(17 downto 0));
end top_calc;

architecture solucion of top_calc is

signal F, F1, F2, F3, F4,Q1,Q2: std_logic_vector(7 downto 0);
signal G1,G2: std_logic_vector(3 downto 0);
--signal selection: std_logic_vector(1 downto 0);
signal enable_1,enable_2: std_logic;
component C1
port(A: in std_logic_vector(7 downto 0);
B: in std_logic_vector(7 downto 0);
F: out std_logic_vector(7 downto 0));
end component;

component C2
port(A: in std_logic_vector(7 downto 0);
B: in std_logic_vector(7 downto 0);
F: out std_logic_vector(7 downto 0));
end component;

component C3
port(A: in std_logic_vector(7 downto 0);
B: in std_logic_vector(7 downto 0);
F: out std_logic_vector(7 downto 0));
end component;

component C4
port(A: in std_logic_vector(7 downto 0);
 F: out std_logic_vector(7 downto 0));
end component;

component mux4x1
port(w, x, y, z: in std_logic_vector(7 downto 0);
s: in std_logic_vector(1 downto 0);
m: out std_logic_vector(7 downto 0));
end component;

component reg4bits
port(CLK: in std_logic;
RST: in std_logic;
EN: in std_logic;
D: in std_logic_vector(3 downto 0);
Q: out std_logic_vector(3 downto 0));
end component;

component reg8bits
port(CLK: in std_logic;
RST: in std_logic;
EN: in std_logic;
D: in std_logic_vector(7 downto 0);
Q: out std_logic_vector(7 downto 0));
end component;

component decod7seg
port(A: in std_logic_vector(3 downto 0);
F1: out std_logic_vector(6 downto 0));
end component;

component FSMctrl
port(clk, rst, enter: in std_logic;
operation: in std_logic_vector(1 downto 0);
--selection: out std_logic_vector(1 downto 0);
enable_1, enable_2: out std_logic);
end component;

begin

L1:C1 port map(Q2,SW(15 downto 8),F1);

L2:C2 port map(Q2,SW(15 downto 8),F2);
L3:C3 port map(Q2,SW(15 downto 8),F3);
L4:C4 port map(Q2 ,F4);
L5:mux4x1 port map(F1, F2, F3, F4 ,sw(17 downto 16),F);
 L6:reg4bits port map(CLK,RST,enable_2,F(7 downto 4),G1);
L7:reg4bits port map(CLK,RST,enable_2,F(3 downto 0),G2);
L8:reg8bits port map(CLK,RST,enable_2,F,Q1);
L9:decod7seg port map(G1,DISP1);
L10:decod7seg port map(G2,DISP0);
L11: reg8bits port map(clk,rst,enable_1,SW(15 downto 8),Q2);
L12: FSMctrl port map(clk,rst,en,sw(17 downto 16),enable_1,enable_2);

LEDR(7 downto 0) <= Q1;

end solucion; -- END architecture