CIRCUITOS DIGITALES

SEGUNDO PARCIAL
5 DE JULIO DE 2017

INFORME PROYECTO

DISEÑO DE ALU

DOCENTE: ING. RAMIRO AUGUSTO RÍOS PAREDES

Integrantes:

 Patricio Gomez
 Rodrigo Rivas

NRC: 3658

Sangolquí - Ecuador
 Índice de Contenido
Índice de Contenido............................................................................................................................ 1
Índice de Figuras ...................................................................................Error! Bookmark not defined.
Índice de Tablas ....................................................................................Error! Bookmark not defined.
1. OBJETIVOS .............................................................................................................................. 2
1.1. Objetivo General................................................................................................................. 2
1.2. Objetivo Especifico ............................................................................................................. 2
2. MATERIALES Y EQUIPOS ................................................................................................... 2
3. MARCO TEORICO ................................................................................................................. 3
3.1. Códigos BCD: ....................................................................................................................... 3
3.2. Operaciones bit a bit .......................................................................................................... 4
3.3. Proceso para multiplicación bit a bit de dos números. ................................................... 11
3.4. Programación en memoria EPROM para multiplicación bit a bit ................................... 12
4. DESCRIPCION DE FUNCIONAMIENTO DE CIRCUITO ............................................. 15
5. CONCLUSIONES RECOMENDACIONES ........................................................................ 16
1. OBJETIVOS
1.1. Objetivo General
Diseñar y construir una ALU (Unidad Aritmética Lógica) que me permite realizar 8
operaciones lógicas y aritméticas, de dos números formados por una solo cifra y cuyo
resultados es visible en display y led’s.

1.2. Objetivo Especifico

Implementar el circuito de corrección BCD para las operaciones aritméticas.
Aplicar los conocimientos sobre memorias, y la programación en la EPROM 2732,
familiarizándose con la selección de datos en su programación.
Mostrar led’s para la visualización de las operaciones lógicas.

2. MATERIALES Y EQUIPOS

Materiales
 Dip switch de 4 posiciones.
 Resistencias.
 Display 7 segmentos cátodo común.
 Decodificadores BCD 74LS48.
 Compuertas lógicas: 74LS32, 74LS08, 74LS04.
 Memoria EPROM 2732.
 Led’s de varios colores.
 Cable conductor.

Equipos
 Protoboard
 Fuente de tensión 5V
 Grabador de memorias

3. Problema

Diseñar y construir una unidad Aritmética lógica ALU que cumpla con las siguientes
especificaciones:

1. Bloque funcional:
Funcionalidad:

4. Análisis

Para resolver el problema planteado se decidió utilizar dos memorias ROM 2732 que posee 8
localidades y 8 salidas para lo cual va a ser programada cada localidad dependiendo de
funcionalidad y sus entradas, para la primera ROM se programara las salidas del display uno y para
la memoria dos se programara las salidas del display 2 y 3

5. MARCO TEORICO

5.1. Códigos BCD:

Este tipo de códigos se denomina decimales codificado en binario (Binary Coded Decimal,
códigos BCD en lo sucesivo).
En estos códigos, se representan los diez números (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) del sistema
decimal mediante una codificación binaria.
 5.2. Suma aritmética BCD: A+B

El sumador binario es el circuito básico aritmético de cualquier computador. Un sumador paralelo

binario de n bits es un circuito digital combinacional que produce la suma binaria en su salida de
dos números binarios en paralelo de n bits presentes en sus entradas más el bit de entrada de
acarreo. Además de la suma de n bits de los dos números, genera en su salida el bit de acarreo que
se pueda producir.

Cuando se suman dos dígitos decimales representados en el código BCD (binary coded decimal) la
respuesta que se obtiene puede no estar en el código BCD, por lo que habría que efectuar una
corrección.

La corrección consiste en sumar el número 6 (0110) a los cuatro bits menos significativos

5.3. Programación en memoria EPROM para multiplicación bit a bit

Para empezar la programación, hemos hecho una tabla de suma de todas las posibles sumas
de números binarios BCD que podemos obtener
x 0 1 2 3 4 5 6 7 8 9
0 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001
1 0001 0010 0011 0100 0101 0110 0111 1000 1001 10000
2 0010 0011 0100 0101 0110 0111 1000 1001 10000 10001
3 0011 0100 0101 0110 0111 1000 1001 10000 10001 10010
4 0100 0101 0110 0111 1000 1001 10000 10001 10010 10011
5 0101 0110 0111 1000 1001 10000 10001 10010 10011 10100
6 0110 0111 1000 1001 10000 10001 10010 10011 10100 10101
7 0111 1000 1001 10000 10001 10010 10011 10100 10101 10110
8 1000 1001 10000 10001 10010 10011 10100 10101 10110 10111
9 1001 1010 10001 10010 10011 10100 10101 10110 10111 11000
Debido a que la programación se la hizo en hexadecimal procedemos a convertir la tabla de la
suma en números hexadecimales

x 0 1 2 3 4 5 6 7 8 9
0 0 1 2 3 4 5 6 7 8 9
1 1 2 3 4 5 6 7 8 9 10
2 2 3 4 5 6 7 8 9 10 11
3 3 4 5 6 7 8 9 10 11 12
4 4 5 6 7 8 9 10 11 12 13
5 5 6 7 8 9 10 11 12 13 14
6 6 7 8 9 10 11 12 13 14 15
7 7 8 9 10 11 12 13 14 15 16
8 8 9 10 11 12 13 14 15 16 17
9 9 10 11 12 13 14 15 16 17 18

Como nuestro circuito posee dos memorias con 8 salidas hemos decido utilizar una memoria para
poder la cual nos entregara en las primera 4 salidas el código del número BCD de las unidades del
resultado que se conectara a un decoder y este a su vez aun display y los 4 siguientes salidas para
las decenas que sería el acarreo y este se conectara de igual manera a un decoder y luego a un
display para poder visualizar el resultado como se puede visualizar en la imagen.

Figura 1 circuito de conexión de memorias a los displays y sus entradas

Para programar el archivo .bin se utilizó el programa Maxloader en el cual para una sencilla
programación se programó en hexadecimal

Donde las entradas FF son las direcciones con números que no son BCD por lo cual se puso un
valor que no tiene importancia ya que la programación esta validad para que apaguen cuando no
son BCD

5.4. Resta aritmética BCD: A+B

Tabla de las posibles restas de los números BCD

x 0 1 2 3 4 5 6 7 8 9
0 0000 10001 10010 10011 10100 10101 10110 10111 11000 11001
1 0001 0000 10001 10010 10011 10100 10101 10110 10111 11000
2 0010 0001 0000 10001 10010 10011 10100 10101 10110 10111
3 0011 0010 0001 0000 10001 10010 10011 10100 10101 10110
4 0100 0011 0010 0001 0000 10001 10010 10011 10100 10101
5 0101 0100 0011 0010 0001 0000 10001 10010 10011 10100
6 0110 0101 0100 0011 0010 0001 0000 10001 10010 10011
7 0111 0110 0101 0100 0011 0010 0001 0000 10001 10010
8 1000 0111 0110 0101 0100 0011 0010 0001 0000 10001
9 1001 1000 0111 0110 0101 0100 0011 0010 0001 0000

Donde podemos visualizar que en los números negativos posee un bit más que indica el signo
negativo

Al poseer dos memorias y tres display se decidió utilizar una memoria para poder visualizar los
números y la otra memoria con un display para poder visualizar el signo menos

La programación para la primera memoria en hexadecimal quedaría algo así

Para el signo debemos analizar que led se debe encender en el display para esto vemos en la tabla

signo A B C D E F G PT
valor 0 0 0 0 0 0 1 0

Como el numero binario 01000000 en hexadecimal es 40 utilizamos esta numero para programar

Obteniendo así nuestra respuesta en el display uno se visualizara el signo y en el display 2 y 3 los
números de la resta

5.5. Multiplicación aritmética BCD: A+B

De la misma forma haremos la tabla para todas las posibles multiplicaciones en BCD posibles
 x 0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0
1 0 1 10 11 100 101 110 111 1000 1001
2 0 10 100 110 1000 10000 10010 10100 10110 11000
3 0 11 110 1001 10010 10101 11000 100001 100100 100111
4 0 100 1000 10010 10110 100000 100100 101000 101100 110000
5 0 101 10000 10101 100000 100101 101010 101111 110100 111001
6 0 110 10010 11000 100100 101010 110000 110110 111100 1000010
7 0 111 10100 100001 101000 101111 110110 111101 1000100 1001011
8 0 1000 10110 100100 101100 110100 111100 1000100 1001100 1010100
9 0 1001 11000 100111 110000 111001 1000010 1001011 1010100 1011101

Debido a que para la rom uno tomaremos los dígitos para las primeras salidas y las unidades en las
4 últimas salidas la tabla a números hexadecimales

x 0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 5 6 7 8 9
1 0 1 2 3 4 6 7 8 9 10
2 0 2 4 6 8 7 8 9 10 11
3 0 3 6 9 12 8 9 10 11 12
4 0 4 8 12 16 9 10 11 12 13
5 0 5 10 15 20 10 11 12 13 14
6 0 6 12 18 24 11 12 13 14 15
7 0 7 14 21 28 12 13 14 15 16
8 0 8 16 24 32 13 14 15 16 17
9 0 9 18 27 36 14 15 16 17 18

Utilizando nuestro programa maxloader

De igual manera que en la suma nuestras entrada de FF son entradas de números BCD lo cual no
nos importa que este escrito debido a que los displays se apagaran en esos casos

5.6. División aritmética BCD: A+B

Haciendo una tabla de todas las posibles divisiones de números BCD en decimales

x 0 1 2 3 4 5 6 7 8 9
0 ERROR 0,00 0,00 0,00 0,00 0,00 0,00 0,00 0,00 0,00
1 ERROR 1,00 0,50 0,33 0,25 0,20 0,17 0,14 0,13 0,11
2 ERROR 2,00 1,00 0,67 0,50 0,40 0,33 0,29 0,25 0,22
3 ERROR 3,00 1,50 1,00 0,75 0,60 0,50 0,43 0,38 0,33
4 ERROR 4,00 2,00 1,33 1,00 0,80 0,67 0,57 0,50 0,44
5 ERROR 5,00 2,50 1,67 1,25 1,00 0,83 0,71 0,63 0,56
6 ERROR 6,00 3,00 2,00 1,50 1,20 1,00 0,86 0,75 0,67
7 ERROR 7,00 3,50 2,33 1,75 1,40 1,17 1,00 0,88 0,78
8 ERROR 8,00 4,00 2,67 2,00 1,60 1,33 1,14 1,00 0,89
9 ERROR 9,00 4,50 3,00 2,25 1,80 1,50 1,29 1,13 1,00

Como poseemos dos memorias y tres displays para la memoria uno con dos displays se visualizara
los números decimales y para la otra memoria se visualizara el número entero con punto

Para la memoria uno con números hexadecimal quedara

x 0 1 2 3 4 5 6 7 8 9
0 AA 0 0 0 0 0 0 0 0 0
1 AA 0 50 33 25 20 17 14 13 11
2 AA 0 0 67 50 40 33 29 25 22
3 AA 0 50 0 75 60 50 43 38 33
4 AA 0 0 33 0 80 67 57 50 44
5 AA 0 50 67 25 0 83 71 63 56
6 AA 0 0 0 50 20 0 86 75 67
 7 AA 0 50 33 75 40 17 0 88 78
8 AA 0 0 67 0 60 33 14 0 89
9 AA 0 50 0 25 80 50 29 13 0

Para la segunda memoria que nos entregara el número entero con punto

signo A B C D E F G PT
0 1 1 1 1 1 1 0 1
1 0 1 1 0 0 0 0 1
2 1 1 0 1 1 0 1 1
3 1 1 1 1 0 0 1 1
4 0 1 1 0 0 1 1 1
5 1 0 1 1 0 1 1 1
6 0 0 1 1 1 1 1 1
7 1 1 1 0 0 0 0 1
8 1 1 1 1 1 1 1 1
9 1 1 1 0 0 1 1 1
E 1 0 0 1 1 1 1 1

Ingresando los datos al maxloader

Para la memoria uno

Para la memoria dos

 5.7. Operaciones bit a bit
En una operación bit a bit, se opera en números binarios a nivel de bits individuales.
Considerada una acción primitiva rápida usando procesadores simples de bajo costo,
ejecutando las operaciones lógicas AND, OR, XOR, XNOR.
En estos procesadores las operaciones de suma y resta son más rápidas que la
multiplicación y división, actualmente los procesadores más modernos permiten realizar las
operaciones a la misma velocidad.

5.8. Proceso para multiplicación bit a bit de dos números.

La multiplicación de números binarios bit a bit es diferente a la forma de multiplicar los
números decimales. Así mismo diferente a la multiplicación de números binarios, usa el
mismo principio lógico de ella:
X 0 1
0 0 0
1 0 1
Tabla 1 Tabla de multiplicación Binaria
La tabla es equivalente a la operación AND Lógica, puesto que se toma cada bit
independientemente, no se lleva con si acarreos o productos parciales.
A B AND
0 0 0
0 1 0
1 0 0
1 1 1
Tabla 2 Tabla lógica de la compuerta AND
 El resultado en cada posición es 1 si el producto de los dos factores es 1, y 0 de lo contrario,
por ejemplo:

5.9. Programación en memoria EPROM para multiplicación bit a bit

Para empezar la programación, comenzamos multiplicando bit a bit cada combinación
posible y la aplicamos como una tabla de multiplicación común:
x 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
1 0000 0001 0000 0001 0000 0001 0000 0001 0000 0001 0000 0001 0000 0001 0000 0001
2 0000 0000 0010 0010 0000 0000 0010 0010 0000 0000 0010 0010 0000 0000 0010 0010
3 0000 0001 0010 0011 0000 0001 0010 0011 0000 0001 0010 0011 0000 0001 0010 0011
4 0000 0000 0000 0000 0100 0100 0100 0100 0000 0000 0000 0000 0100 0100 0100 0100
5 0000 0001 0000 0001 0100 0101 0100 0101 0000 0001 0000 0001 0100 0101 0100 0101
6 0000 0000 0010 0010 0100 0100 0110 0110 0000 0000 0010 0010 0100 0100 0110 0110
7 0000 0001 0010 0011 0100 0101 0110 0111 0000 0001 0010 0011 0100 0101 0110 0111
8 0000 0000 0000 0000 0000 0000 0000 0000 1000 1000 1000 1000 1000 1000 1000 1000
9 0000 0001 0000 0001 0000 0001 0000 0001 1000 1001 1000 1001 1000 1001 1000 1001
10 0000 0000 0010 0010 0000 0000 0010 0010 1000 1000 1010 1010 1000 1000 1010 1010
11 0000 0001 0010 0011 0000 0001 0010 0011 1000 1001 1010 1011 1011 1011 1011 1011
12 0000 0000 0000 0000 0100 0100 0100 0100 1000 1000 1000 1011 1100 1011 1011 1100
13 0000 0001 0000 0001 0100 0101 0100 0101 1000 1001 1000 1011 1011 1101 1011 1101
14 0000 0000 0010 0010 0100 0100 0110 0110 1000 1000 1010 1011 1011 1011 1110 1110
15 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
Tabla 3 Tabla de multiplicación Bit a Bit en Binario
Se conoce que en la programación, ingresamos un número hexadecimal de dos cifras, es
decir un número binario de 8 bits, pero en la tabla solo tenemos 4 por lo que se asume que
el faltante de bits es 0.
 Nuevamente repetimos la tabla 3, pero esta vez cambiando por el código hexadecimal que
estaría en la programación.

x 0 1 2 3 4 5 6 7 8 9 A B C D E F
0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
1 00 01 00 01 00 01 00 01 00 01 00 01 00 01 00 01
2 00 00 02 02 00 00 02 02 00 00 02 02 00 00 02 02
3 00 01 02 03 00 01 02 03 00 01 02 03 00 01 02 03
4 00 00 00 00 04 04 04 04 00 00 00 00 04 04 04 04
5 00 01 00 01 04 05 04 05 00 01 00 01 04 05 04 05
6 00 00 02 02 04 04 06 06 00 00 02 02 04 04 06 06
7 00 01 02 03 04 05 06 07 00 01 02 03 04 05 06 07
8 00 00 00 00 00 00 00 00 08 08 08 08 08 08 08 08
9 00 01 00 01 00 01 00 01 08 09 08 09 08 09 08 09
A 00 00 02 02 00 00 02 02 08 08 0A 0A 08 08 0A 0A
B 00 01 02 03 00 01 02 03 08 09 0A 0B 0B 0B 0B 0B
C 00 00 00 00 04 04 04 04 08 08 08 0B 0C 0B 0B 0C
D 00 01 00 01 04 05 04 05 08 09 08 0B 0B 0D 0B 0D
E 00 00 02 02 04 04 06 06 08 08 0A 0B 0B 0B 0E 0E
F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
Tabla 4 Tabla de multiplicación Bit a Bit en Hexadecimal

5.10. Proceso para suma bit a bit de dos números.

Para la suma bit a bit, se conserva el principio de suma binaria.

La tabla es parecida a la lógica OR y la aplicaremos para los posibles casos dados.

A B OR
0 0 0
0 1 1
1 0 1
1 1 1
Tabla 2 Tabla lógica de la compuerta AND
El resultado en cada posición es 1 si cualquiera de los sumandos es 1, y 0 cuando ambos
sean 0, por ejemplo:
 5.11. Programación en memoria EPROM para suma bit a bit
Realizamos un cuadro de suma para los posibles casos dados, la cual tiene semejanza con
un cuadro de suma normal:
+ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
1 0001 0001 0011 0011 0101 0101 0111 0111 1001 1001 1011 1011 1101 1101 1111 1111
2 0010 0011 0010 0011 0110 0111 0110 0111 1010 1011 1010 1011 1110 1111 1110 1111
3 0011 0011 0011 0011 0111 0111 0111 0111 1011 1011 1011 1011 1111 1111 1111 1111
4 0100 0101 0110 0111 0100 0101 0110 0111 1100 1101 1110 1111 1100 1101 1110 1111
5 0101 0101 0111 0111 0101 0101 0111 0111 1101 1101 1111 1111 1101 1101 1111 1111
6 0110 0111 0110 0111 0110 0111 0110 0111 1110 1111 1110 1111 1110 1111 1110 1111
7 0111 0111 0111 0111 0111 0111 0111 0111 1111 1111 1111 1111 1111 1111 1111 1111
8 1000 1001 1010 1011 1100 1101 1110 1111 1000 1001 1010 1011 1100 1101 1110 1111
9 1001 1001 1011 1011 1101 1101 1111 1111 1001 1001 1011 1011 1101 1101 1111 1111
10 1010 1011 1010 1011 1110 1111 1110 1111 1010 1011 1010 1011 1110 1111 1110 1111
11 1011 1011 1011 1011 1111 1111 1111 1111 1011 1011 1011 1011 1111 1111 1111 1111
12 1100 1101 1110 1111 1100 1101 1110 1111 1100 1101 1110 1111 1100 1101 1110 1111
13 1101 1101 1111 1111 1101 1101 1111 1111 1101 1101 1111 1111 1101 1101 1111 1111
14 1110 1111 1110 1111 1110 1111 1110 1111 1110 1111 1110 1111 1110 1111 1110 1111
15 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111
Aplicando el mismo concepto de figura 2, creamos una nueva tabla que tendrá la
programación:
+ 0 1 2 3 4 5 6 7 8 9 A B C D E F
0 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
1 01 01 03 03 05 05 07 07 09 09 0B 0B 0D 0D 0F 0F
2 02 03 02 03 06 07 06 07 0A 0B 0A 0B 0E 0F 0E 0F
3 03 03 03 03 07 07 07 07 0B 0B 0B 0B 0F 0F 0F 0F
4 04 05 06 07 04 05 06 07 0C 0D 0E 0F 0C 0D 0E 0F
5 05 05 07 07 05 05 07 07 0D 0D 0F 0F 0D 0D 0F 0F
6 06 07 06 07 06 07 06 07 0E 0F 0E 0F 0E 0F 0E 0F
7 07 07 07 07 07 07 07 07 0F 0F 0F 0F 0F 0F 0F 0F
8 08 09 0A 0B 0C 0D 0E 0F 08 09 0A 0B 0C 0D 0E 0F
9 09 09 0B 0B 0D 0D 0F 0F 09 09 0B 0B 0D 0D 0F 0F
A 0A 0B 0A 0B 0E 0F 0E 0F 0A 0B 0A 0B 0E 0F 0E 0F
B 0B 0B 0B 0B 0F 0F 0F 0F 0B 0B 0B 0B 0F 0F 0F 0F
C 0C 0D 0E 0F 0C 0D 0E 0F 0C 0D 0E 0F 0C 0D 0E 0F
D 0D 0D 0F 0F 0D 0D 0F 0F 0D 0D 0F 0F 0D 0D 0F 0F
E 0E 0F 0E 0F 0E 0F 0E 0F 0E 0F 0E 0F 0E 0F 0E 0F
F 0F 0F 0F 0F 0F 0F 0F 0F 0F 0F 0F 0F 0F 0F 0F 0F
6. DESCRIPCION DE FUNCIONAMIENTO DE CIRCUITO

Como se puede visualizar en el circuito las memorias están conectadas en las entradas los
números binarios de A y B y los selectores, los números binarios de A y B se conectaran a
su respectivo decoder que permitirá la visualización en los displays y estos se conectaran
con compuertas AND y OR para validar que sean números BCD caso contrario se apagaran
los diplasy y también los de salida

Las memroias 2732 serán programadas en un archivo .bin creados en maxloader en la

entrada de selección habrá un inversor que me permite apagar o encender los leds

Los leds estarán conectadas a la memoria 2 (la de arriba) que estar programada
dependiendo el caso que exista
7. CONCLUSIONES RECOMENDACIONES

 Conclusiones

 El uso de las memorias ROM nos pueden facilitar el circuito y a su vez disminuirlo ya
que al poder grabar las respuesta no será el uso necesario de varios integrados como
compradores o sumadores
 Se concluye que una ALU nos permite realizar varias operaciones aritméticas y lógicas
que pueden servirnos en diferentes casos

 Recomendaciones

 Se recomienda programar en números hexadecimales ya que es un número más

pequeño que el binario y así no deberemos escribir mucho números
 Se recomienda visualizar bien las datasheet de los integrados para que al momento de
armar el circuito no tener problemas