PONTIFICIA UNIVERSIDAD JAVERIANA

INGENIERÍA ELECTRÓNICA

DISEÑO DE SISTEMAS DIGITALES

PROYECTO #2: CALCULADORA

INTEGRANTES:

BRIAN EMMANUEL ASCENCIÓN MARTÍNEZ

CRISTHIAM FELIPE GONZÁLEZ MÉNDEZ
JUAN MANUEL LÓPEZ HERNÁNDEZ

PRESENTADO A:

FRANCISCO FERNANDO VÍVEROS MORENO

FECHA DE ENTREGA:
04-11-2019

BOGOTÁ DC
I. Especificaciones preliminares del diseño.

a. Funcionamiento del sistema.

La propuesta recibida tiene como objetivo diseñar un dispositivo que tenga la capacidad de sumar dos
números, donde cada uno de estos dos únicos números no debe sobrepasar el valor de 999, es decir,
cada número a digitar puede tener un valor entre 0 a 999. Estos números serán ingresados por medio
de un teclado matricial 4x4. Además de esto, se debe mostrar el resultado de la suma de los dos
números en un display siete segmentos de cuatro dígitos. El sistema cogerá el primer valor de entrada,
luego se necesitará presionar el botón “confirmar” para dar paso al ingreso del segundo valor de
entrada y nuevamente se presiona el botón “confirmar” para que se prosiga a realizar la suma de estos
dos valores mencionados atrás. El número máximo de mostrar en este dispositivo de suma es de 1998,
es decir, en el display solo se podrá mostrar valores entre 0 y 1998. Cabe mencionar que, si algún
valor se ha ingresado de forma errónea, es decir que excedan los limites indicados anteriormente, se
dará una advertencia de que no es correcto y que se deberá volver a ingresar el valor o número que
fue advertido.

b. Descripción de las entradas, salidas del sistema y sus características.

La figura 1 muestra la caja negra del sistema, en donde se encuentran señaladas las entradas y salidas
que componen a todo nuestro sistema.

3 LED_RGB
EntradaTeclado1
SalidaTeclado1
EntradaTeclado2
SalidaTeclado2
EntradaTeclado4
EntradaTeclado3
Dispositivo SalidaTeclado3

BotonConfirmar SalidaTeclado4
sumador 4
Display1
4 Display2
4 Display3
4 Display4

Figura 1. Diagrama de entradas y salidas del dispositivo.

Teniendo en cuenta la figura 1, se prosigue a hablar sobre la descripción de las características de las
entradas y salidas, para esto, lo vamos a dividir en dos partes; entradas y salidas, cómo se mostrará a
continuación. Primero se hablará de las entradas:

EntradaTeclado: Corresponden a los 4 cables de salida del teclado, estos ingresan a la FPGA. Por
medio de estos el sistema es capaz de detectar la fila donde se encuentra la tecla presionada.
BotónConfirmar: Permite al usuario avanzar en el proceso, es decir, después de digitado el primer
número, continuar con el segundo, y por último visualizar el resultado.
Por otro lado, también tenemos las salidas, las cuales son:
 Display: Corresponde a la combinación de bits que hará visible en el display el número necesario.
Sabiendo que nuestra tarjeta tiene 4 displays de 7 segmentos, utilizaremos estos cuatro para visualizar
cualquier sumatoria en estos Displays, misma que puede ir de 0 a 1998, y como cada uno de estos se
componen de 7 bits para expresar cada segmento, se emplearan en total 28 cables.
SalidaTeclado: Estas corresponden a las columnas del teclado numérico, y al igual que para la
entrada teclado, necesitaremos 4 cables de esta.
LED_RGB: Corresponde a un led RGB que fungirá como señal visual para indicar al usuario en qué
parte del proceso se encuentra.

c. Diagrama de tiempos.

A continuación, se podrá observar el diagrama de tiempos de este sistema de seguridad o de la caja

fuerte, en la figura 2:

clk

SalidaTeclado1

SalidaTeclado2

SalidaTeclado3

SalidaTeclado4

EntradaTeclado1

EntradaTeclado2

EntradaTeclado3

EnreadaTeclado4

Display 1 12 123 4 45 456 579

LEDRGB 100 010 001

Figura 2. Diagrama de tiempos del dispositivo.
II. Diagramas generales.

a. Diagrama en bloques del sistema, entradas y salidas generales del sistema. Descripción
de las entradas y salidas de cada bloque y sus interfaces entre bloques.

Se prosigue a hablar sobre lo que se hace dentro de la “caja negra”, es decir, en el interior del sistema
de seguridad, se representará con ayuda de un diagrama en bloques en la figura 4 y después, su
respectiva descripción para mayor comprensión.

Figura 3. Diagrama de bloques del dispositivo.

Básicamente nuestro sistema funciona de la siguiente manera: el usuario cuenta con una interfaz
compuesta por un teclado matricial de 4x4 y 4 display de 7 segmentos. El dispositivo permite realizar
una suma de dos cantidades y visualizar el resultado en los displays. Cada cantidad por sumar puede
tener un valor de 0 a 999, así el mayor resultado posible a obtener es 1998.
Como primer paso el usuario digita la primera cantidad, esto lo realiza presionando los números que
desee en el teclado matricial de 4x4, este valor es visualizado por el usuario para que, en caso de que
sea correcto presione la letra A del teclado matricial para avanzar en el proceso, y en caso de que se
haya equivocado presione la letra B y vuelva a digitar la primera cifra.
Completado el primer paso el usuario puede digitar la segunda cifra siguiendo el mismo proceso
usado para digitar la primera cifra. Con la diferencia de que, en este caso, de ser correcto el segundo
número y ser presionada la letra A, el proceso finaliza mostrando al usuario el resultado de la
operación de suma realizado con los dos números ingresados.

b. Explique el funcionamiento de cada bloque propuesto y cómo interactúa con los demás
bloques y el exterior (interfaces).

El bloque Control se encarga de gestionar el funcionamiento de cada bloque interno, este es

fundamental en nuestro esquema, de aquí parte todo.
El bloque Corrimiento realiza un barrido por toda la matriz del teclado, para darle a entender al
sistema que digito presiona el usuario. Este corresponde a la salida del teclado (identifica que
columna el usuario está utilizando).
El bloque Detector recibe los datos del teclado numérico y del bloque corrimiento, para saber que
digito se le está ingresando (el teclado numérico está conformado por filas y columnas, dependiendo
del digito ingresado el sistema hace un barrido e identifica el numero ingresado por la fila y columna
en la que este se encuentra), una vez identificado cada digito, este bloque procede a enviar la
información correspondiente a cada bloque de registro que se encarga de almacenar el primer número
y el segundo.
Los bloques N1 y N2 corresponden al bloque de registro que se encargan de almacenar
temporalmente el valor ingresado (se le ingresa un número proveniente del bloque detector) a través
del teclado numérico.
El bloque Sumador es el último proceso que el bloque control gestiona, este recibe el dato de N1 (el
primer número) y lo suma con N2 (segundo número), este bloque opera de manera binaria para
facilitar el procesamiento del sistema. Finalmente, el valor obtenido en este bloque es enviado a los
displays.
También se incluye un bloque llamado Control Displays, se trata de una red combinatoria que, de
acuerdo con el valor que reciba de los bloques de memoria, envía señales a 4 displays de 7 segmentos
para que el usuario pueda visualizar cada número ingresado, o en su defecto el resultado de la suma
el cual proviene del bloque sumador.
III. Descripción AHPL – Documentado.
Flag = (EntradaTeclado(1) x (Corrimiento(1) + Corrimiento(2) + Corrimiento(3) +
Corrimiento(4))) + (EntradaTeclado(2) x (Corrimiento(1) + Corrimiento(2) + Corrimiento(3)
+ Corrimiento(4))) + (EntradaTeclado(3) x (Corrimiento(1) + Corrimiento(2) +
Corrimiento(3) + Corrimiento(4))) + (EntradaTeclado(4) x (Corrimiento(1) + Corrimiento(2)
+ Corrimiento(3) + Corrimiento(4))) –Corresponde a la ecuación que detecta cuando una
tecla del teclado ha sido presionada.
1. C1← C4, C2← C1, C3← C2, C4← C3 –Se habilita el barrido en las entradas del
teclado matricial
→ (Flag x2) + ( ̅̅̅̅̅̅
𝐹𝑙𝑎𝑔 x1) –Se presiona una tecla del teclado correspondiente a un
número
2. N1_1 ← 1 –Se ingresa el primer digito del primer número
3. → (Flag x3) + ( ̅̅̅̅̅̅
𝐹𝑙𝑎𝑔 x4)
4. C1← C4, C2← C1, C3← C2, C4← C3 –Se habilita el barrido en las entradas del
teclado matricial
̅̅̅̅̅̅ x4) –Se presiona una tecla del teclado correspondiente a un
→ (Flag x5) + ( 𝐹𝑙𝑎𝑔
número
5. N1_2 ← 1 –Se ingresa el segundo digito del primer número
6. → (Flag x6) + ( ̅̅̅̅̅̅
𝐹𝑙𝑎𝑔 x7)
7. C1← C4, C2← C1, C3← C2, C4← C3 –Se habilita el barrido en las entradas del
teclado matricial
̅̅̅̅̅̅ x7) –Se presiona una tecla del teclado correspondiente a un
→ (Flag x8) + ( 𝐹𝑙𝑎𝑔
número
8. N1_3 ← 1 –Se ingresa el tercer digito del primer número
9. → (Flag 9) + ( ̅̅̅̅̅̅
𝐹𝑙𝑎𝑔 x10)
10. Enable_Display← “001”, --Se habilita el display para mostrar el primer número
ingresado
→ (Boton_confirmar x11) + ( ̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
𝐵𝑜𝑡𝑜𝑛_𝑐𝑜𝑛𝑓𝑖𝑟𝑚𝑎𝑟 x10) –Botón confirmar
presionado
11. → (Boton_confirmar x11) + ( ̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
𝐵𝑜𝑡𝑜𝑛_𝑐𝑜𝑛𝑓𝑖𝑟𝑚𝑎𝑟 x12)
12. C1← C4, C2← C1, C3← C2, C4← C3 –Se habilita el barrido en las entradas del
teclado matricial
̅̅̅̅̅̅ x10) –Se presiona una tecla del teclado correspondiente a
→ (Flag x11) + ( 𝐹𝑙𝑎𝑔
un número
13. N2_1 ← 1 –Se ingresa el primer digito del segundo número
14. → (Flag x12) + ( ̅̅̅̅̅̅
𝐹𝑙𝑎𝑔 x13)
15. C1← C4, C2← C1, C3← C2, C4← C3 –Se habilita el barrido en las entradas del
teclado matricial
̅̅̅̅̅̅ x13) –Se presiona una tecla del teclado correspondiente a
→ (Flag x14) + ( 𝐹𝑙𝑎𝑔
un número
16. N2_2 ← 1 –Se ingresa el segundo digito del segundo número
17. → (Flag x15) + ( ̅̅̅̅̅̅
𝐹𝑙𝑎𝑔 x16)
18. C1← C4, C2← C1, C3← C2, C4← C3 –Se habilita el barrido en las entradas del
teclado matricial
→ (Flag x17) + ( ̅̅̅̅̅̅
𝐹𝑙𝑎𝑔 x16) –Se presiona una tecla del teclado correspondiente a
un número
19. N2_3 ← 1 –Se ingresa el tercer digito del segundo número
20. → (Flag x20) + ( ̅̅̅̅̅̅
𝐹𝑙𝑎𝑔 x21)
21. Enable_Display← “010”, --Se habilita el display para mostrar el segundo número
ingresado
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅ x21) –Botón confirmar
→ (Boton_confirmar x22) + ( 𝐵𝑜𝑡𝑜𝑛_𝑐𝑜𝑛𝑓𝑖𝑟𝑚𝑎𝑟
presionado
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅ x23)
22. → (Boton_confirmar x22) + ( 𝐵𝑜𝑡𝑜𝑛_𝑐𝑜𝑛𝑓𝑖𝑟𝑚𝑎𝑟
23. Enable_Display← “100”, --Se habilita el display para mostrar el resultado de la
suma
→ (Boton_confirmar x24) + ( ̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
𝐵𝑜𝑡𝑜𝑛_𝑐𝑜𝑛𝑓𝑖𝑟𝑚𝑎𝑟 x23) –Botón confirmar
presionado
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅ x1)
24. → (Boton_confirmar x24) + ( 𝐵𝑜𝑡𝑜𝑛_𝑐𝑜𝑛𝑓𝑖𝑟𝑚𝑎𝑟
IV. Esquemático (circuito).

Figura 4. Tabla para crear las ecuaciones del sumador de 3 bits.

𝑆 = ̅̅̅ ̅̅̅2 𝑋3 + 𝑋2 ̅̅̅

𝑋1 (𝑋 𝑋3 ) + 𝑋1 (𝑋2 𝑋3 + ̅̅̅
𝑋2 ̅̅̅
𝑋3 )
̅̅̅1 𝑋2 + 𝑋1 ̅̅̅
𝐴 = 𝑋1 𝑋2 + 𝑋3 (𝑋 𝑋2 )

Figura 5. Circuito para salida.

Figura 6. Circuito para generar el acarreo.

Figura 7. Circuito para bloque corrimiento.

Figura 8. Circuito para bloque N.

V. Descripción VHDL documentado.

Calculadora – Programa principal

--Iniciación de Librerías--
LIBRARY IEEE;
USE ieee.std_logic_1164.all;

--Programa--

--Caja negra--
Entity calculadora is
Port(

--Entradas--
BC_P : in std_logic; --Boton confirmar
clk_P : in std_logic; --Reloj de la tarjeta
rst_P : in std_logic; --Reset de la máquina de estados
col_P : in std_logic_vector(3 downto 0); --Columnas del teclado matricial
--Salidas--
Ind : out std_logic_vector(4 downto 0); --Señales indicadoras del estado de la máquina de
estados
fil_P : out std_logic_vector(3 downto 0); --Filas del teclado matricial
D1, D2, D3, D4 : out std_logic_vector(6 downto 0)); --Displays para visualización
end calculadora;

--Diagramas en bloques--
Architecture gateLevel of calculadora is
-Señales internas
SIGNAL flag_s : STD_logic; --señl de bandera
SIGNAL N1_s : STD_logic_vector (2 downto 0);
SIGNAL N2_s : STD_logic_vector (2 downto 0);
SIGNAL EN1_S, EN2_S, ENS_S : STD_logic; --SEÑALES HABILITADORAS DE
DISPLAY
SIGNAL N1_D, N2_D : STD_logic_vector (11 downto 0); --Contenido de los bloques N
SIGNAL S_D : STD_logic_vector (12 downto 0); --Contenido del bloque sum
SIGNAL F_S : STD_logic_vector (3 downto 0); --FILAS DEL TECLADO MAATRICIAL
SIGNAL D_N1, D_N2 : STD_logic_vector (3 downto 0);--NUMERO EN BINARIO 0-9
SIGNAL N1_Sum, N2_Sum : STD_logic_vector (11 downto 0); --Contenido de los bloque
N

BEGIN

control: ENTITY work.control –Llamado del bloque Control

PORT MAP ( flag => flag_s,
BC => BC_P,
 clk => clk_P,
rst => rst_P,
I => Ind,
--cmto => cmto_s,
N1 => N1_s,
N2 => N2_s,
EN1 => EN1_S,
EN2 => EN2_S,
ES => ENS_S);

controlD: ENTITY work.controldisplay –Llamado del bloque Control Display

PORT MAP ( N1 => N1_D,
N2 => N2_D,
S => S_D,
E1 => EN1_S,
E2 => EN2_S,
E3 => ENS_S,
Y1 => D1,
Y2 => D2,
Y3 => D3,
Y4 => D4);

corrimiento: ENTITY work.corrimiento –Llamado del bloque Corrimiento

PORT MAP ( E => not flag_s,
clk => clk_P,
S => F_s,
--SI =>Ind2,
Sb => fil_P);

detector: ENTITY work.detector –Llamado del bloque Detector

PORT MAP ( F => F_s,
C => col_P,
FlagO => flag_s,

--s3 => Ind2,

S1 => D_N1,
s2 => D_N2);

N_1: ENTITY work.n –Llamado del primer bloque N

PORT MAP ( Enable_1 => N1_s(2),
Enable_2 => N1_s(1),
Enable_3 => N1_s(0),
X => D_N1,
Y1 => N1_D,
Y2 => N1_sum);

N_2: ENTITY work.n –Llamado del segundo bloque N

PORT MAP ( Enable_1 => N2_s(2),
 Enable_2 => N2_s(1),
Enable_3 => N2_s(0),
X => D_N2,
Y1 => N2_D,
Y2 => N2_sum);

sumador: ENTITY work.sumador –Llamado del bloque Sumador

PORT MAP ( NP1 => N1_sum,
NP2 => N2_sum,
suma => S_D);

END ARCHITECTURE gateLevel;

--Este programa es la estructura principal, ya que, conecta cada bloque de acuerdo a lo requerido.
En el se mandan a llamar todos los bloques y por medio de las entradas y salidas del sistema,
además de señales internas, se realizan las conexiones necesarias.

Control
--Iniciación de Librerías--
LIBRARY IEEE;
USE ieee.std_logic_1164.all;
LIBRARY altera;
USE altera.altera_primitives_components.all;
-------------------------------------------
ENTITY control IS
PORT( --Entradas
flag : IN STD_LOGIC; --Señal de bander
BC : IN STD_LOGIC; --BOTON CONFIRMAR
clk : IN STD_LOGIC; --Reloj del sistema
rst : IN STD_LOGIC; --Reset de la maquina de estados
I: OUT STD_LOGIC_VECTOR(4 downto 0); --Indicador de cada estado
N1, N2: OUT STD_LOGIC_VECTOR(2 downto 0);--Habilitadores para
los bloques n EN1, EN2, ES: OUT STD_LOGIC); --Habilitadores para el display
END ENTITY control;
-------------------------------------------
ARCHITECTURE functional OF control IS

component dffe is –Declaración de Flip Flop tipo D

port (
d, clk, clrn ,prn, ena: in STD_LOGIC;
q: out STD_LOGIC
);
end component;
--Señales internas
SIGNAL S1 : STD_LOGIC;
SIGNAL S2 : STD_LOGIC;
SIGNAL S3 : STD_LOGIC;
SIGNAL S4 : STD_LOGIC;
SIGNAL S5 : STD_LOGIC;
SIGNAL S6 : STD_LOGIC;
SIGNAL S7 : STD_LOGIC;
SIGNAL S8 : STD_LOGIC;
SIGNAL S9 : STD_LOGIC;
SIGNAL S10 : STD_LOGIC;
SIGNAL S11 : STD_LOGIC;
SIGNAL S12 : STD_LOGIC;
SIGNAL S13 : STD_LOGIC;
SIGNAL S14 : STD_LOGIC;
SIGNAL S15 : STD_LOGIC;
SIGNAL S16 : STD_LOGIC;
SIGNAL S17 : STD_LOGIC;
SIGNAL S18 : STD_LOGIC;
SIGNAL S19 : STD_LOGIC;
SIGNAL S20 : STD_LOGIC;
SIGNAL S21 : STD_LOGIC;
SIGNAL S22 : STD_LOGIC;
SIGNAL S23 : STD_LOGIC;
SIGNAL S24 : STD_LOGIC;

SIGNAL C1 : STD_LOGIC;
SIGNAL C2 : STD_LOGIC;
SIGNAL C3 : STD_LOGIC;
SIGNAL C4 : STD_LOGIC;
SIGNAL C5 : STD_LOGIC;
SIGNAL C6 : STD_LOGIC;
SIGNAL C7 : STD_LOGIC;
SIGNAL C8 : STD_LOGIC;
SIGNAL C9 : STD_LOGIC;
SIGNAL C10 : STD_LOGIC;
SIGNAL C11 : STD_LOGIC;
SIGNAL C12 : STD_LOGIC;
SIGNAL C13 : STD_LOGIC;
SIGNAL C14 : STD_LOGIC;
SIGNAL C15 : STD_LOGIC;
SIGNAL C16 : STD_LOGIC;
SIGNAL C17 : STD_LOGIC;
SIGNAL C18 : STD_LOGIC;
SIGNAL C19 : STD_LOGIC;
SIGNAL C20 : STD_LOGIC;
SIGNAL C21 : STD_LOGIC;
SIGNAL C22 : STD_LOGIC;
SIGNAL C23 : STD_LOGIC;
SIGNAL C24 : STD_LOGIC;
SIGNAL BCN : STD_LOGIC;

BEGIN
BCN<= not BC; --Los botones de la tarjeta son activos en bajo, aquí se utiliza una compuerta not
para que el BC sea activo en alto
--Declaración de los Flip Flop, uno por cada estado
f_f1: dffe PORT MAP(C1, clk, not rst, '1', '1', s1);
f_f2: dffe PORT MAP(C2, clk, not rst, '1', '1', s2);
f_f3: dffe PORT MAP(C3, clk, not rst, '1', '1', s3);
f_f4: dffe PORT MAP(C4, clk, not rst, '1', '1', s4);
f_f5: dffe PORT MAP(C5, clk, not rst, '1', '1', s5);
f_f6: dffe PORT MAP(C6, clk, not rst, '1', '1', s6);
f_f7: dffe PORT MAP(C7, clk, not rst, '1', '1', s7);
f_f8: dffe PORT MAP(C8, clk, not rst, '1', '1', s8);
f_f9: dffe PORT MAP(C9, clk, not rst, '1', '1', s9);
f_f10: dffe PORT MAP(C10, clk, not rst, '1', '1', s10);
f_f11: dffe PORT MAP(C11, clk, not rst, '1', '1', s11);
f_f12: dffe PORT MAP(C12, clk, not rst, '1', '1', s12);
f_f13: dffe PORT MAP(C13, clk, not rst, '1', '1', s13);
f_f14: dffe PORT MAP(C14, clk, not rst, '1', '1', s14);
f_f15: dffe PORT MAP(C15, clk, not rst, '1', '1', s15);
f_f16: dffe PORT MAP(C16, clk, not rst, '1', '1', s16);
f_f17: dffe PORT MAP(C17, clk, not rst, '1', '1', s17);
f_f18: dffe PORT MAP(C18, clk, not rst, '1', '1', s18);
f_f19: dffe PORT MAP(C19, clk, not rst, '1', '1', s19);
f_f20: dffe PORT MAP(c20, clk, not rst, '1', '1', s20);
f_f21: dffe PORT MAP(C21, clk, not rst, '1', '1', s21);
f_f22: dffe PORT MAP(C22, clk, not rst, '1', '1', s22);
f_f23: dffe PORT MAP(C23, clk, not rst, '1', '1', s23);
f_f24: dffe PORT MAP(C24, clk, not rst, '1', '1', s24);

--Condiciones para cambio de estado

C1<=(s24 and not BCN) or (not s1 and not s2 and not s3 and not s4 and not s5 and not s6 and not s7
and not s8 and not s9 and not s10 and not s11
and not s12 and not s13 and not s14 and not s15 and not s16 and not s17 and not s18 and not s19
and not s20 and not s21 and not s22 and not s23
and not s24) or (s1 and not c2);
C2<=s1 and flag;
C3<=s2 or (s3 and not C4);
C4<=(s3 and not flag) or (s4 and not C5);
C5<=s4 and flag;
C6<=s5 or (s6 and not C7);
C7<=(s6 and not flag) or (s7 and not C8);
C8<=s7 and flag;
C9<=s8 or (s9 and not C10);
C10<=(s9 and not flag) or (s10 and not C11);
C11<=(s10 and BCN) or (s11 and not C12);
C12<=(s11 and not BCN) or (s12 and not C13);
C13<=(s12 and flag) or (s13 and not C14);
C14<=s13 or (s14 and not C15);
C15<=(s14 and not flag) or (s15 and not C16);
C16<=(s15 and flag) or (s16 and not C17);
C17<=s16 or (s17 and not C18);
C18<=(s17 and not flag) or (s18 and not C19);
C19<=(s18 and flag) or (s19 and not C20);
C20<=s19 or (s20 and not C21);
C21<=(s20 and not flag) or (s21 and not C22);
C22<=(s21 and BCN) or (s22 and not C23);
C23<=(s22 and not BCN) or (s23 and not C24);
C24<=(s23 and BCN) or (s24 and not C1);

--Declracion de los estados en los que se activa cada salida

N1(2)<=S2;
N1(1)<=S5;
N1(0)<=S8;
N2(2)<=S13;
N2(1)<=S16;
N2(0)<=S19;
EN1<=S10;
EN2<=S21;
ES<=S23;
--Indicadores de estado
I(4)<=s16 or s17 or s18 or s19 or s20 or s21 or s22 or s23 or s24;
I(3)<=s8 or s9 or s10 or s11 or s12 or s13 or s14 or s15 or s24;
I(2)<=s4 or s5 or s6 or s7 or s12 or s13 or s14 or s15 or s20 or s21 or s22 or s23;
I(1)<=s2 or s3 or s6 or s7 or s10 or s11 or s14 or s15 or s18 or s19 or s22 or s23;
I(0)<=s1 or s3 or s5 or s7 or s9 or s11 or s13 or s15 or s17 or s19 or s21 or s23;
END ARCHITECTURE functional;

--Este bloque es el cerebro de todo el programa, se encarga de llevar el orden de actuación de

manera secuencial de los demás bloques por medio de una máquina de estados elaborada con 24
Flip Flop, la lógica se describe en el aprtado de AHPL. De ahí se derivan las condiciones para
avanzar entre cada estado.

Corrimiento
--Iniciación de Librerías--

LIBRARY IEEE;
USE ieee.std_logic_1164.all;
LIBRARY altera;
USE altera.altera_primitives_components.all;
-------------------------------------------
ENTITY corrimiento IS
PORT( --Entradas
E : IN STD_LOGIC;
clk : IN STD_LOGIC;
 --Salidas
S, Sb : OUT STD_LOGIC_Vector(3 downto 0));
END ENTITY corrimiento;
-------------------------------------------
ARCHITECTURE functional OF corrimiento IS

component dffe is –Declaración de Flip Flop tipo D

port (
d, clk, clrn ,prn, ena: in STD_LOGIC;
q: out STD_LOGIC
);
end component;

--Señales internas
SIGNAL S1 : STD_LOGIC;
SIGNAL S2 : STD_LOGIC;
SIGNAL S3 : STD_LOGIC;
SIGNAL S4 : STD_LOGIC;
SIGNAL S5 : STD_LOGIC;
BEGIN
S5<=S4 or (not s1 and not s2 and not s3 and not s4);
--Declaración de los Flip Flop
f_f1: dffe PORT MAP(s5, clk, '1', '1', E, S1);
f_f2: dffe PORT MAP(s1, clk, '1', '1', E, s2);
f_f3: dffe PORT MAP(s2, clk, '1', '1', E, S3);
f_f4: dffe PORT MAP(s3, clk, '1', '1', E, S4);
--Declaración de las salidas
S(3)<=S1;
S(2)<=S2;
S(1)<=S3;
S(0)<=S4;
Sb(3)<=S1;
Sb(2)<=S2;
Sb(1)<=S3;
Sb(0)<=S4;
END ARCHITECTURE functional;
--Este bloque es el encargado de realizar un barrido a través de las 4 filas del teclado matricial, para
esto se conectan 4 Flip Flop de manera cíclica, sin ninguna condición para el avance entre uno y
otro, así, con cada cilclo de reloj sólo una de las 4 salidas está en alto, mientras las demás están en
bajo.

Detector
--Iniciación de Librerías--

LIBRARY IEEE;
USE ieee.std_logic_1164.all;
-------------------------------------------
ENTITY detector IS
 PORT( --Entradas
F, C : IN STD_LOGIC_VECTOR(3 downto 0);
--Salidas
FlagO : OUT STD_LOGIC;
S1, S2 : OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
END ENTITY detector;
-------------------------------------------
ARCHITECTURE functional OF detector IS
signal flag : std_LOGIC;
BEGIN
--Declaración de las salidas
S1(3)<=(F(2)and(C(1) or C(2))) and flag;
S1(2)<=((F(1)and(C(0) or C(1) or C(2))) or (F(2) and C(0))) and flag;
S1(1)<=((F(0)and(C(1) or C(2))) or (F(1) and C(2)) or (F(2) and C(0))) and flag;
S1(0)<=((F(0)and(C(0) or C(2))) or (F(2)and(C(0) or C(2))) or (F(1) and C(1))) and flag;
S2(3)<=(F(2)and(C(1) or C(2))) and flag;
S2(2)<=((F(1)and(C(0) or C(1) or C(2))) or (F(2) and C(0))) and flag;
S2(1)<=((F(0)and(C(1) or C(2))) or (F(1) and C(2)) or (F(2) and C(0))) and flag;
S2(0)<=((F(0)and(C(0) or C(2))) or (F(2)and(C(0) or C(2))) or (F(1) and C(1))) and flag;
Flag<=((F(0)and(C(0) or C(1) or C(2))) and not F(1) and not F(2) and not F(3))
or((F(1)and(C(0) or C(1) or C(2)))and not F(0) and not F(2) and not F(3))
or((F(2)and(C(0) or C(1) or C(2)))and not F(0) and not F(1) and not F(3))
or((F(3) and C(1))and not F(0) and not F(1) and not F(2));
FLagO<=Flag;
END ARCHITECTURE functional;

--Este bloque se encarga de enviar la combinación binaria de acuerdo con la tecla que se detecta que
es presionada en el teclado, además, al presionar una tecla, cualquiera que sea, se envía una señal de
bandera al bloque Control, lo que le indica el ingreso de datos.

N
--Iniciación de Librerías--
LIBRARY IEEE;
USE ieee.std_logic_1164.all;

Entity N is
Port(

--Entradas--
Enable_1, Enable_2, Enable_3 : in std_logic;
X : in std_logic_vector(3 downto 0);
--Salidas--
Y1, Y2 : out std_logic_vector(11 downto 0));
end N;
Architecture gateLevel of N is
BEGIN
--Se declaran tres bloques para almacenar 4 bits en cada uno
N_1: ENTITY work.caracter
 PORT MAP ( x1 => X(0),
x2 => X(1),
x3 => X(2),
x4 => X(3),
x5 => Enable_1,
y_1(3) => Y1(11),
y_1(2) => Y1(10),
y_1(1) => Y1(9),
y_1(0) => Y1(8),
y_2(3) => Y2(11),
y_2(2) => Y2(10),
y_2(1) => Y2(9),
y_2(0) => Y2(8));

N_2: ENTITY work.caracter

PORT MAP ( x1 => X(0),
x2 => X(1),
x3 => X(2),
x4 => X(3),
x5 => Enable_2,
y_1(3) => Y1(7),
y_1(2) => Y1(6),
y_1(1) => Y1(5),
y_1(0) => Y1(4),
y_2(3) => Y2(7),
y_2(2) => Y2(6),
y_2(1) => Y2(5),
y_2(0) => Y2(4));

N_3: ENTITY work.caracter

PORT MAP ( x1 => X(0),
x2 => X(1),
x3 => X(2),
x4 => X(3),
x5 => Enable_3,
y_1(3) => Y1(3),
y_1(2) => Y1(2),
y_1(1) => Y1(1),
y_1(0) => Y1(0),
y_2(3) => Y2(3),
y_2(2) => Y2(2),
y_2(1) => Y2(1),
y_2(0) => Y2(0));
END ARCHITECTURE gateLevel;
--Existen dos bloques de este tipo para almacenar los dos números a sumar, cada uno se forma por 3
sub-bloques que almacenan 4 bits cada uno, cada bloque puede almacenar la combinación adecuada
para un número entre 0-9. El almacenamiento se logra al recibir una señal del bloque control.
Sumador
--Iniciación de Librerías--
LIBRARY IEEE;
USE ieee.std_logic_1164.all;

Entity sumador is
Port(

--Entradas--
NP1,NP2 : in std_logic_vector(11 downto 0);
--Salidas--
Suma : out std_logic_vector(12 downto 0));
end sumador;

Architecture gateLevel of sumador is

--Señales internas
SIGNAL A1 : STD_logic;
SIGNAL A2 : STD_logic;

BEGIN

sumador_1: ENTITY work.principal

PORT MAP ( N1(3) => NP1(3),
N1(2) => NP1(2),
N1(1) => NP1(1),
N1(0) => NP1(0),
N2(3) => NP2(3),
N2(2) => NP2(2),
N2(1) => NP2(1),
N2(0) => NP2(0),
A => '0',
y(4) => A1,
y(3) => Suma(3),
y(2) => Suma(2),
y(1) => Suma(1),
y(0) => Suma(0));
sumador_2: ENTITY work.principal
PORT MAP ( N1(3) => NP1(7),
N1(2) => NP1(6),
N1(1) => NP1(5),
N1(0) => NP1(4),
N2(3) => NP2(7),
N2(2) => NP2(6),
N2(1) => NP2(5),
N2(0) => NP2(4),
A => A1,
y(4) => A2,
 y(3) => Suma(7),
y(2) => Suma(6),
y(1) => Suma(5),
y(0) => Suma(4));
sumador_3: ENTITY work.principal
PORT MAP ( N1(3) => NP1(11),
N1(2) => NP1(10),
N1(1) => NP1(9),
N1(0) => NP1(8),
N2(3) => NP2(11),
N2(2) => NP2(10),
N2(1) => NP2(9),
N2(0) => NP2(8),
A => A2,
y(4) => Suma(12),
y(3) => Suma(11),
y(2) => Suma(10),
y(1) => Suma(9),
y(0) => Suma(8));
END ARCHITECTURE gateLevel;

--Este bloque recibe los valores almacenados en ambos bloques N y los suma por medio de
sumadores de 3 bits, la suma permite enviar el resultado en bloques de 4 bits por digito.

Control Display
--Iniciación de Librerías--
LIBRARY IEEE;
USE ieee.std_logic_1164.all;

Entity controldisplay is
Port(

--Entradas--
N1,N2 : in std_logic_vector(11 downto 0);
S : in std_logic_vector(12 downto 0);
E1, E2, E3 : in std_logic;
--Salidas--
Y1, Y2, Y3, Y4 : out std_logic_vector(6 downto 0));
end controldisplay;

Architecture gateLevel of controldisplay is

--Señales internas
SIGNAL S1 : STD_LOGIC_VECTOR(3 DOWNTO 0);
SIGNAL S2 : STD_LOGIC_VECTOR(3 DOWNTO 0);
SIGNAL S3 : STD_LOGIC_VECTOR(3 DOWNTO 0);
SIGNAL S4 : STD_LOGIC_VECTOR(3 DOWNTO 0);

BEGIN
selector_1: ENTITY work.selector
PORT MAP ( N_1(0) => N1(0),
N_1(1) => N1(1),
N_1(2) => N1(2),
N_1(3) => N1(3),
N_2(0) => N2(0),
N_2(1) => N2(1),
N_2(2) => N2(2),
N_2(3) => N2(3),
Sum(0) => S(0),
Sum(1) => S(1),
Sum(2) => S(2),
Sum(3) => S(3),
E(0) => E1,
E(1) => E2,
E(2) => E3,
Y => S1);
conversor_1: ENTITY work.conversor
PORT MAP ( x1 => S1(0),
x2 => S1(1),
x3 => S1(2),
x4 => S1(3),
Y => Y1);
selector_2: ENTITY work.selector
PORT MAP ( N_1(0) => N1(4),
N_1(1) => N1(5),
N_1(2) => N1(6),
N_1(3) => N1(7),
N_2(0) => N2(4),
N_2(1) => N2(5),
N_2(2) => N2(6),
N_2(3) => N2(7),
Sum(0) => S(4),
Sum(1) => S(5),
Sum(2) => S(6),
Sum(3) => S(7),
E(0) => E1,
E(1) => E2,
E(2) => E3,
Y => S2);
conversor_2: ENTITY work.conversor
PORT MAP ( x1 => S2(0),
x2 => S2(1),
x3 => S2(2),
x4 => S2(3),
Y => Y2);
selector_3: ENTITY work.selector
PORT MAP ( N_1(0) => N1(8),
 N_1(1) => N1(9),
N_1(2) => N1(10),
N_1(3) => N1(11),
N_2(0) => N2(8),
N_2(1) => N2(9),
N_2(2) => N2(10),
N_2(3) => N2(11),
Sum(0) => S(8),
Sum(1) => S(9),
Sum(2) => S(10),
Sum(3) => S(11),
E(0) => E1,
E(1) => E2,
E(2) => E3,
Y => S3);
conversor_3: ENTITY work.conversor
PORT MAP ( x1 => S3(0),
x2 => S3(1),
x3 => S3(2),
x4 => S3(3),
Y => Y3);
selector_4: ENTITY work.selector2
PORT MAP ( Sum => S(12),
E => E3,
Y => S4);
conversor_4: ENTITY work.conversor
PORT MAP ( x1 => S4(0),
x2 => S4(1),
x3 => S4(2),
x4 => S4(3),
Y => Y4);

END ARCHITECTURE gateLevel;

--Este bloque recibe los datos almacenados en los dos bloques N y en el bloque sumador,
dependiendo de la señal recibida del bloque control permite la visualización de un de los tres grupos
de bits. Esto permite visualizar el proceso en tres parte, el primer número ingresado, el segundo y el
resultado.
VI. Simulaciones en la herramienta QUARTUS II donde se cubran varios
comportamientos del sistema.

Figura 9. Simulación de la calculadora usando la herramienta Quartus.

VII. Descripción de los resultados de la simulación
Para este caso, el sistema cuenta con solo un posible comportamiento, este es:
Introducir un número de tres dígitos, el cual se visualiza en el display, presionar el botón
confirmar ingresando el valor y poniendo en cero el display.
Ingresar nuevamente un número de tres dígitos, que también se visualiza en el display, al
presionar el botón confirmar este valor es ingresado, mostrando el resultado de la suma en el
display.
Volviendo a presionar el botón confirmar el sistema vuelve a su estado inicial.
VIII. Esquemático definitivo extractando el RTL con la herramienta QUARTUS II

Figura 10. Esquema general del sistema.

Figura 11. Esquema del bloque corrimiento.

 Figura 12. Esquema del bloque detector.

Figura 13. Esquema del bloque control parte 1.

Figura 14. Esquema del bloque control parte 2.

Figura 15. Esquema del bloque control parte 3.
Figura 16. Esquema del bloque N_2.

Figura 17. Esquema del bloque N_1.

 Figura 18. Esquema del bloque Sumador.

Figura 19. Esquema del bloque Control Display.

IX. Pruebas del hardware implementado.

Figura 20. Tarjeta conectada al teclado numérico y a la protoboard.

X. Análisis de la entrega en hardware - incluir video de la entrega.
https://www.youtube.com/watch?v=bhcRHLxgOiw&feature=youtu.be
XI. Reflexión escrita, en la cual cada integrante del grupo autoevalúa su desempeño en el
proyecto, describiendo los logros de aprendizaje, las dificultades personales y los
alcances y proyecciones del proyecto.

El trabajo realizado durante el proyecto fue excelente, se reforzó lo aprendido en cuanto a compuertas
básicas (AND, NAND, OR, NOR, XOR, EQUI, NOT) y el uso de flip-flops, en cuanto a la suma de
los números binarios: tuve la capacidad de entender como decirle a un procesador (en este caso la
tarjeta de desarrollo) que efectué esta suma. En un principio encontré dificultades en cuanto a la suma
de binarios, y en el diseño del proyecto en Quartus hubo problemas con la máquina de estados por lo
que se le hicieron pequeños ajustes al AHPL. El proyecto fue enriquecedor y sería buena idea
continuar con este, pero agregándole otras operaciones (resta, división y multiplicación).
Juan Manuel López Hernández.

Desarrollar este proyecto tuvo un impacto en la concepción que tenía acerca de operaciones entre
números binarios, e integrar todo un sistema para la suma de dos números fue enriquecedor a mis
conocimientos. Como dificultad personal resalto la lógica que se tuvo que emplear para la
visualización del dato requerido en los displays, ya que involucró una secuencia lógica distinta a la
que se había usado en el proyecto anterior. Sin duda el proyecto podría ser complementado con nuevas
cosas, como la suma de más de dos números, o la suma de números más grande.
Brian Emmanuel Ascención Martínez.

El trabajo hecho alrededor de todo este proyecto fue bueno, debido a que no sólo aprendí a cómo
realizar una calculadora de forma teórica, sino también el proceso que esto conlleva. Se puede decir
que reforcé lo que es la operación entre números binarios más específicamente, y todo lo que conlleva
la suma de dos números, algo quizás especifico que no sabía, pero es fundamental para que este
proyecto funcionará es cuando es mayor a 9, ya que había que usar, por decirlo de alguna forma, la
ley de sumarle “6”. Algunas dificultades que tuve fue entender bien el funcionamiento de la máquina
de estados de este proyecto y AHPL. Pero aun así el proyecto en general fue de carácter muy
enriquecedor, pero queda cómo esa duda de; cómo sería el proceso de restar, multiplicar y dividir.
Cristhiam Felipe González Méndez.