1. Indique los requerimientos del problema.

Se requiere un sistema digital que calcule operaciones aritméticas (suma, resta,

comparación y multiplicación utilizado el algoritmo de Booth) teniendo en cuenta el
“Carry”; operaciones lógicas con dos operandos (OR, AND), y sobre uno de los operandos
(NOT, desplazamiento y rotación). Se deben recibir dos números a la entrada por medio de
dos buses paralelos de 16 bits (un número por cada bus) y un habilitador, a la salida se debe
entregar el resultado y además decir el estado de las condiciones (la bandera de
disponibilidad, el cero, si es un número negativo, si hubo carry u overflow). Todo esto con
un reloj de operación de 20ns.
2. Especificaciones del diseño preliminares.
a. Redactar en un párrafo el funcionamiento del sistema a diseñar.

El sistema digital que se va a diseñar es asíncrono, opera con un reloj de 20ns, el cual
recibe a la entrada dos números de máximo 16 bits en binario, un selector de operaciones
de 4 bits (por medio de combinaciones para elegir la determinada operación a llevar a cabo)
y un habilitador de un bit con el cuál se da inicio, estas señales entrantes se llaman
“OperadorA”, “OperadorB”, “Selector” y “Habilitador” respectivamente. Los datos que se
encuentran a la salida serán dos buses paralelos, uno de tamaño de 16 bits y otro de 5 bits,
estos tienen como nombre “Resultado” (donde se mostrará la solución de la operación
elegida) y “Condicion” (donde se mostrará la información de las condiciones como la
bandera de disponibilidad, el cero, si es un número negativo, si hubo carry u overflow).

b. Describir entradas, salidas y sus características.

Para el diseño de la ALU, tenemos que comenzar con el diagrama de entradas y salidas, o
también llamado caja negra, donde veremos qué información le entra al sistema y que
salidas se producen sin tener en cuenta, por momento, el proceso interno, como se muestra
en la figura 1.

Entradas:

-OperadorA: Es un bus paralelo de tamaño 16 bits ingresado en binario, es el primer

operando. Este operador puede recibir tanto números positivos como negativos en
complemento 2.

-OperadorB: Es un bus paralelo de tamaño16 bits ingresado en binario, es el segundo

operando. Este operador puede recibir tanto números positivos como negativos en
complemento 2.

-Selector: Es un bus paralelo de 4 bits encargado de elegir el modo de operaciones

aritméticas (suma, resta, comparación, multiplicación) y lógicas de dos operadores (AND,
OR) y un operador (NOT, desplazamiento o rotación).

S Operaciones
0000 Suma
0001 Resta
 0010 Comparación
0011 Multiplicación
0100 Or
0101 And
0111 Not
1000 Desplazamiento
1001 Rotación
1011 Suma con carry

-Habilitador: Es el encargado de transmitir la información de manera serial asíncrona y es

de un bit. Cuando esté en espera el sistema, la señal estará en alto y para iniciar, se debe
recibir un bit en bajo.

-Clk: Es el reloj de 20ns del sistema.

Salidas

-Resultado: Es un bus paralelo de 16 bits, en este se encuentra el resultado de las

operaciones aplicadas a los dos operandos, se muestra del bit menos significativo al más
significativo.

-Overflow: Es una salida de un bit. Indica si hubo overflow en la operación realizada.

- Carry: Es una salida de un bit. Indica si hubo carry en la operación realizada.

- Cero: Es una salida de un bit. Indica si hubo cero en la operación realizada.

- Negativo: Es una salida de un bit. Indica si dio negativo en la operación realizada.

-Bandera: Es una señal encargada de demostrar la disponibilidad de la ALU.

3. Diagramas generales.

a. Dibuje en diagrama en bloques del sistema, indique las entradas y salidas de cada
bloque y sus interfaces entre bloques. Indique además las entradas y salidas
generales del sistema.
 Figura 1: Diagrama de entradas para el diseño de la ALU.

Figura 2: Diagrama de bloques del sistema.

b. Explique el funcionamiento de cada bloque propuesto y cómo interactúa con los

demás bloques y el exterior (interfaces).

Conversor1: Le ingresa el OperadorB de 16 bits, por medio de control. Se convertirá o no

el valor ingresado a complemento 2 si se selecciona el caso de la resta. Luego es enviado a
control a las operaciones aritméticas Multiplicador, Sumador-Resta y la operación lógica
OR-AND.

Contador1: Es el encargado de decir a Control cuando se hayan ingresados los 16 bits.

 Contador2: Es el encargado de decir a Control cuando se hayan ingresado los 16 bits.

Control: Es el encargado de determinar el orden en que van a interactuar los bloques

dentro del sistema.

Multiplicador: Le entra Conversor1 y Conversor2, se realiza la multiplicación de Booth y le

sale un bus de 17 bits hacia Comparador.

Sumador-Resta: Le entra Conversor1 y Conversor2, se realiza como su nombre lo indica las

operaciones aritméticas de suma y resta, le sale un bus de 17 bits hacia Comparador.

Desplazamiento: Le entran 16 bits de Conversor1, realiza el desplazamiento lógico hacia la

derecha y le salen 16 bits hacia resultado.

Desplazamiento2: Este bloque consta de 16 bits y es el encargado de hacer el

desplazamiento aritmético a la derecha del multiplicador.

Rotación: Le entran 16 bits de Conversor1, se realiza la rotación hacia la derecha y le salen

16 bits hacia resultado.

NOT: Le entran 16 bit de Conversor1, se le realiza la compuerta lógica NOT a cada bit y le
salen 16 bits hacia resultado.

OR: Le entran 16 bit tanto de Conversor1 como de Conversor2, se le realiza la compuerta

lógica OR a cada bit y le salen 16 bits hacia resultado.

AND: Le entran 16 bit tanto de Conversor1 como de Conversor2, se le realiza la compuerta

lógica AND a cada bit y le salen 16 bits hacia resultado.

Comparador: Le entra Multiplicador y Sumador-Resta, en el se verifican y salen las

condiciones de Overflow, Carry, Cero y Negativo como un “1” en caso de que cumplan y
como un “0” cuando no.

4. Descripción RTL/ AHPL.

1.
-> ( Habilitador x1) + ( Habilitador
´ x2)
2. Reset=1
-> 3
´
3. ((OperadorA ´
v OperadorB ) x3) + ((OperadorA ^ OperadorB) x4)
4. (Selector <- 0000 x9) v (Selector <- 0001 x6) v (Selector <- 0010 x10) v (Selector <- 0011
x11) v (Selector <- 0100 x12) v (Selector <- 0101 x13) v (Selector <- 0111 x14) v (Selector <-
1000 x15) v (Selector <- 1001 x16) v (Selector <-1011 x9)
5.
´
6. Conversor1 <- ((OperadorB [0:15] + 1)
->8

7.
Ec=1
->9
8.
Ec=0
->9
9.
Cx <- Ec ^ Cout[16];
Cout[0] <- Cx;
Suma-Resta[0] <- OperadorA[0] ⊕ OperadorB[0];
Cout[1] <-OperadorA[0] ^ OperadorB[0];
Suma-Resta[1] <- OperadorA[1] ⊕ OperadorB[1];
Cout[2] <- (OperadorA[1] ^ OperadorB[1]) ⊕ (Cout[1]);
Suma-Resta[2] <- OperadorA[2] ⊕ OperadorB[2];
Cout[3] <- (OperadorA[2] ^ OperadorB[2]) ⊕ (Cout[2]);
Suma-Resta[3] <- OperadorA[3] ⊕ OperadorB[3];
Cout[4] <- (OperadorA[3] ^ OperadorB[3]) ⊕ (Cout[3]);

Suma-Resta[4] <- OperadorA[4] ⊕ OperadorB[4];

Cout[5] <- (OperadorA[4] ^ OperadorB[4]) ⊕ (Cout[4]);
Suma-Resta[5] <- OperadorA[5] ⊕ OperadorB[5];
Cout[6] <- (OperadorA[5] ^ OperadorB[5]) ⊕ (Cout5]);
Suma-Resta[6] <- OperadorA[6] ⊕ OperadorB[6];
Cout[7] <- (OperadorA[6] ^ OperadorB[6]) ⊕ (Cout[6]);
Suma-Resta[7] <- OperadorA[7] ⊕ OperadorB[7];
Cout[8] <- (OperadorA[7] ^ OperadorB[7]) ⊕ (Cout[7]);
Suma-Resta[8] <- OperadorA[8] ⊕ OperadorB[8];
Cout[9] <- (OperadorA[8] ^ OperadorB[8]) ⊕ (Cout[8]);
Suma-Resta[9] <- OperadorA[9] ⊕ OperadorB[9];
Cout[10] <- (OperadorA[9] ^ OperadorB[9]) ⊕ (Cout[9]);
Suma-Resta[10] <- OperadorA[10] ⊕ OperadorB[10];
Cout[11] <- (OperadorA[10] ^ OperadorB[10]) ⊕ (Cout[10]);
Suma-Resta[11] <- OperadorA[11] ⊕ OperadorB[11];
Cout[12] <- (OperadorA[11] ^ OperadorB[11]) ⊕ (Cout[11]);
Suma-Resta[12] <- OperadorA[12] ⊕ OperadorB[12];
Cout[13] <- (OperadorA[12] ^ OperadorB[12]) ⊕ (Cout[12]);
Suma-Resta[13] <- OperadorA[13] ⊕ OperadorB[13];
Cout[14] <- (OperadorA[13] ^ OperadorB[13]) ⊕ (Cout[13]);
Suma-Resta[14] <- OperadorA[14] ⊕ OperadorB[14];
Cout[15] <- (OperadorA[14] ^ OperadorB[14]) ⊕ (Cout[14]);
Suma-Resta[15] <- OperadorA[15] ⊕ OperadorB[15];
Cout[16] <- (OperadorA[15] ^ OperadorB[15]) ⊕ (Cout[15]);

Resultadocom[0:15] <- Suma-Resta[0:15];

Coutcom<-Cout[16];
->10
10. Comparación
Resultadocom[15]
Carry=Coutcom
Overflow=OperadorA[]
Neg=Resultadocom[15]
Zero

11. Multiplicación
A[0:8]=0;
Q1=0;
M=OperadorB
-M
Resultadocom[0:15]= Suma-Resta[0:15];
Coutcom=Cout[16];
->10
12.

// OR

ORout[0] <- OperadorA[0] v OperadorB[0];

ORout[1] <- OperadorA[1] v OperadorB[1];
ORout[2] <- OperadorA[2] v OperadorB[2];
ORout[3] <- OperadorA[3] v OperadorB[3];
ORout[4] <- OperadorA[4] v OperadorB[4];
ORout[5] <- OperadorA[5] v OperadorB[5];
ORout[6] <- OperadorA[6] v OperadorB[6];
ORout[7] <- OperadorA[7] v OperadorB[7];
ORout[8] <- OperadorA[8] v OperadorB[8];
ORout[9] <- OperadorA[9] v OperadorB[9];
ORout[10] <- OperadorA[10] v OperadorB[10];
ORout[11] <- OperadorA[11] v OperadorB[11];
ORout[12] <- OperadorA[12] v OperadorB[12];
ORout[13] <- OperadorA[13] v OperadorB[13];
ORout[14] <- OperadorA[14] v OperadorB[14];
ORout[15] <- OperadorA[15] v OperadorB[15];

13. // AND

ANDout[0] <- OperadorA[0] ^ OperadorB[0];

ANDout[1] <- OperadorA[1] ^ OperadorB[1];
ANDout[2] <- OperadorA[2] ^ OperadorB[2];
ANDout[3] <- OperadorA[3] ^ OperadorB[3];
ANDout[4] <- OperadorA[4] ^ OperadorB[4];
ANDout[5] <- OperadorA[5] ^ OperadorB[5];
ANDout[6] <- OperadorA[6] ^ OperadorB[6];
ANDout[7] <- OperadorA[7] ^ OperadorB[7];
ANDout[8] <- OperadorA[8] ^ OperadorB[8];
ANDout[9] <- OperadorA[9] ^ OperadorB[9];
ANDout[10] <- OperadorA[10] ^ OperadorB[10];
ANDout[11] <- OperadorA[11] ^ OperadorB[11];
ANDout[12] <- OperadorA[12] ^ OperadorB[12];
ANDout[13] <- OperadorA[13] ^ OperadorB[13];
ANDout[14] <- OperadorA[14] ^ OperadorB[14];
ANDout[15] <- OperadorA[15] ^ OperadorB[15];

14. NOT
´
NOTout[0] <- OperadorA [0];
´
NOTout[1] <- OperadorA [1];
´
NOTout[2] <- OperadorA [2];
´
NOTout[3]<-OperadorA [3];
´
NOTout[4]<-OperadorA [4];
´
NOTout[5] <- OperadorA [5];
´
NOTout[6] <- OperadorA [6];
´
NOTout[7]<-OperadorA [7];
´
NOTout[8]<-OperadorA [8];
´
NOTout[9] <- OperadorA [9];
´
NOTout[10] <- OperadorA [10];
´
NOTout[11]<-OperadorA [11];
´
NOTout[12]<-OperadorA [12];
´
NOTout[13] <- OperadorA [13];
´
NOTout[14] <- OperadorA [14];
´
NOTout[15] <- OperadorA [15];

15. // Desplazamiento Lógico

SHL[0]<- 0;
SHL[1]<- OperadorA[0];
SHL[2]<- OperadorA[1];
SHL[3] <- OperadorA[2];
SHL[4] <- OperadorA[3];
SHL[5] <- OperadorA[4];
SHL[6] <- OperadorA[5];
SHL[7] <- OperadorA[6];
SHL[8] <- OperadorA[7];
SHL[9] <- OperadorA[8];
SHL[10] <- OperadorA[9];
SHL[11] <- OperadorA[10];
SHL[12] <- OperadorA[11];
SHL[13] <- OperadorA[12];
SHL[14] <- OperadorA[13];
SHL[15] <- OperadorA[14];

16. Rotación
ROL[0] <- OperadorA[15];
ROL[1] <- OperadorA[0];
ROL[2] <- OperadorA[1];
ROL[3] <- OperadorA[2];
ROL[4] <- OperadorA[3];
ROL[5] <- OperadorA[4];
ROL[6] <- OperadorA[5];
ROL[7] <- OperadorA[6];
ROL[8] <- OperadorA[7];
ROL[9] <- OperadorA[8];
ROL[10] <- OperadorA[9];
ROL[11] <- OperadorA[10];
ROL[12] <- OperadorA[11];
ROL[13] <- OperadorA[12];
ROL[14] <- OperadorA[13];
ROL[15] <- OperadorA[14];

5. Esquemático preliminar.
6. Proyecto funcional de la descripción VHDL documentado y coherente con diseño de los
puntos previos.
7. Protocolo de pruebas para simulación.
8. Diagramas de tiempo y descripción de los resultados de la simulación incluyendo análisis
de glitches y meta-estabilidad.
9. Reflexión personal 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.