UNIVERSIDAD NACIONAL AUTÓNOMA

DE MÉXICO

FACULTAD DE INGENIERÍA

DISEÑO DIGITAL

PROYECTO FINAL
CALCULADORA 4 BITS

PROFESOR
JOSÉ MIGUEL MARTÍNEZ ALCARAZ

ALUMNOS
DÍAZ ALVA ALEXIS
AGUILAR MENDOZA JOSÉ ULISES

SEMESTRE

2019-1
INTRODUCCIÓN
Las compuertas lógicas son de gran utilidad en el diseño de los circuitos lógicos. En el estudio de
las compuertas será analizada su operación lógica mediante el álgebra booleana. También veremos
cómo se combinan las compuertas lógicas para producir circuitos lógicos que serán analizados
mediante dicha álgebra.

El álgebra booleana se utiliza para expresar los efectos que los diversos circuitos digitales ejercen
sobre las entradas lógicas y para manipular variables lógicas con el objetivo de determinar el mejor
método de ejecución de cierta función de un circuito. De hecho en el álgebra de Boole solo existen
tres operaciones básicas:

• OR
• AND •
NOT.
Usaremos el álgebra booleana primero para describir y analizar estas compuertas lógicas básicas y
más tarde para analizar combinaciones de compuertas lógicas conectadas como circuitos lógicos.

Cuando trabajamos con puertas lógicas debemos diferenciar el si ́mbolo de la puerta lógica de su
apariencia fi ́sica.

Compuerta AND
Para la compuerta AND, La salida estará en estado alto de tal manera que solo si las dos entradas
se encuentran en estado alto. Por esta razón podemos considerar que es una multiplicación
binaria.

Compuerta OR
La compuerta OR, la salida estará en estado alto cuando cualquier entrada o ambas estén en
estado alto. De tal manera que sea una suma lógica.

Compuerta NOT
En la compuerta NOT, el estado de la salida es inversa a la entrada. Evidentemente, una negación.

Tabla de verdad y símbolo

Compuerta NAND
Para la compuerta NAND, cuando las dos entradas estén en estado alto la salida estará en estado
bajo. Como resultado de la negación de una AND.

Tabla de verdad y símbolo

Compuerta NOR
En la compuerta NOR, cuando las dos entradas estén estado bajo la salida estará en estado alto.
Esencialmente una OR negada.

Tabla de verdad y símbolo

Compuerta XOR
La compuerta XOR Su salida estará en estado bajo cuando las dos entradas se encuentren en
estado bajo o alto. Al mismo tiempo podemos observar que entradas iguales es cero y diferentes
es uno.

Tabla de verdad y símbolo

Compuerta XNOR
Su salida de hecho estará en estado bajo cuando una de las dos entradas se encuentre en estado
alto. Igualmente, la salida de una XOR negada.

Tabla de verdad y símbolo

Las compuertas además de tener un nombre, también se pueden identificar con una numeración,
la cual es:

AND = 7408

OR = 7432

NOT = 7404

NAND = 7400

NOR = 7402

XOR = 7486

En resumen una compuerta lógica es la mínima operación digital que se puede realizar. Existen al
menos 4 operaciones básicas, la multiplicación lógica (AND), suma lógica (OR), la negación lógica
(NOT) y la comparación lógica (XOR). El resto de las operaciones se realizan con las anteriores y sus
negaciones.

Una compuerta lógica es un conjunto de transistores que realizan dichas operaciones. Estas son los
bloques básicos con los que están construidos los sistemas digitales actuales.
Como se trata de un circuito integrado debe ir alimentado, conectado a una pila. En este caso, la
patilla 7 corresponde con el polo negativo o tierra (GND) y la patilla 14 con la alimentación positiva
(Vcc). El resto corresponde a las puertas lógicas, por ejemplo, la patilla 1 y 2 corresponden con las
entradas de una puerta AND y la patilla 3 seri ́a la salida a dicha puerta.

DESARROLLO
Sumador
Partiendo de la tabla de verdad de un sumador completo de 1 bit:

Se obtiene el circuito basándose en compuertas NOR y AND:

Para obtener un sumador completo de 4 bit se necesita conectar 4 sumadores completos, como se
muestra a continuación:
En donde los valores de los dos números de 4 bit a sumar son ingresados mediante dos dipswitch.

Restador

Partiendo de la tabla de verdad de una resta completa de un bit:

Se logra obtener el circuito restador completo de un bit:

Partiendo de este circuito, igualmente que el sumador, se puede implementar la resta binaria de 2
números de 4 bits conectándolos en serie, aunque para este caso y para poder manejar números
negativos se procedió a utilizar el complemento a2 para realizar la resta, quedando el circuito
siguiente:

En donde el bit más significativo en la salida, es el signo de la sustracción realizada.

Multiplicador
Partiendo de la estructura de una multiplicación binaria:
Y recordando la multiplicación de números binarios:

Se realizó el circuito multiplicador tomando en cuenta las consideraciones anteriores,

teniendo al final:

En donde las multiplicaciones bit por bit se realizan usando 16 compuertas AND
Y las sumas mediante sumadores de 4 bits, dejando los correspondientes corrimientos:
Divisor
Para el caso de la división, el proceso es más complejo, por lo que generalmente en este tipo
circuitos se utilizan memorias, o circuitos secuenciales.

En este caso se utilizó un Micro controlador 18F4550.

Cuya estructura interna es:

La cual fungirá como memoria y proseara los datos para posteriormente darnos el resultado de la
operación.

Se realizó de dos formas: mediante display de 7 segmentos:

Donde los dos primeros números son la parte entera de la división y los dos últimos la parte
fraccionaria.

En este circuito, se utilizaron decodificadores para implementar el uso de displays de 7 segmentos,

ya que el Microcontrolador, al igual que los demás circuitos lógico utiliza lógica binaria.

Por ejemplo la división de 10 entre 5:

Y 7 entre 14:
Y por medio de leds, en donde se obtiene la parte entera de la operación y se muestra en leds, y la
parte del sustraendo que igualmente es mostrada en leds:

Por ejemplo 15 entre 15:

En donde vemos que el led menos significativo enciende lo que es un 1 y el residuo e cero.

Otro ejemplo 15 entre 8:

En donde vemos que en la parte entera tenemos un uno, en el residuo un 7.

Los códigos utilizados fueron:

Para el primer caso:

 #include <18F4550.h> //incluye al procesador a utilizar
#fuses HSPLL, MCLR, NOWDT, NOPROTECT, NOLVP, NODEBUG, USBDIV,
PLL5, CPUDIV1, VREGEN
#device ADC=10 // convertidor AD a 10 BITS
#use delay (clock=48000000) // define la velocidad de procesamiento

//para bootloader *** no borrar nunca

#build (reset=0x800, interrupt=0x808:0x808) #org 0x000,
0x07FF{}
//

//macros para la definición de registros

#BYTE TRISA = 0x0f92 // registro de configuración puerto A

#BYTE TRISB = 0x0f93 // tris configura la dirección del flujo de datos (entrada o salida)
#BYTE TRISC = 0x0f94
#BYTE TRISD = 0x0f95
#BYTE TRISE = 0x0f96
#BYTE PORTA = 0x0f80 // registro de datos puerto A
#BYTE PORTB = 0x0f81
#BYTE PORTC = 0x0f82
#BYTE PORTD = 0x0f83
#BYTE PORTE = 0x0f84

#BYTE ADCON0 = 0x0fc2 // registro ADC

#BYTE ADCON1 = 0x0fc1
#BYTE ADCON2 = 0x0fc0

//Inicia programa principal

float div ;
float div1;
float valor1; float valor2, centenas,
decenas;
int num1, num2, num3, num4;

void main (void){

TRISD = 0x00;
TRISE = 0x01;
TRISB = 0x00;
TRISA=0x00;
TRISC=0x01;
TRISC=0x00;
 do{

valor1 =
(input(PIN_C5))*1+(input(PIN_C6))*2+(input(PIN_C7))*4+(input(PIN_E0))*8; valor2 =
(input(PIN_B4))*1+(input(PIN_B5))*2+(input(PIN_B6))*4+(input(PIN_B7))*8;
div=(valor1/valor2)*100; num4=div/1000;
centenas=div-num4*1000;
num3=centenas/100;

PORTA=num4;
PORTC=num3; decenas=centenas-
num3*100; num2=decenas/10;
PORTD=num2;

num1=decenas-num2*10;
PORTB=num1;

}while(1); }

Y para el segundo caso:

#include <18F4550.h> //incluye al procesador a utilizar

#fuses HSPLL, MCLR, NOWDT, NOPROTECT, NOLVP, NODEBUG, USBDIV, PLL5, CPUDIV1, VREGEN
#device ADC=10 // convertidor AD a 10 BITS
#use delay(clock=48000000) // define la velocidad de procesamiento

//para bootloader *** no borrar nunca

#build (reset=0x800, interrupt=0x808:0x808)
#org 0x000, 0x07FF{}
//

//macros para la definición de registros

#BYTE TRISA = 0x0f92 // registro de configuración puerto A

#BYTE TRISB = 0x0f93 // tris configura la dirección del flujo de datos (entrada o salida)
#BYTE TRISC = 0x0f94
#BYTE TRISD = 0x0f95
#BYTE TRISE = 0x0f96
#BYTE PORTA = 0x0f80 // registro de datos puerto A
#BYTE PORTB = 0x0f81
#BYTE PORTC = 0x0f82
#BYTE PORTD = 0x0f83
#BYTE PORTE = 0x0f84
 #BYTE ADCON0 = 0x0fc2 // registro ADC
#BYTE ADCON1 = 0x0fc1
#BYTE ADCON2 = 0x0fc0

//Inicia programa principal

int div ;
int valor1, valor2,res;

void main (void){

TRISD = 0x00;
TRISE = 0x01;
TRISB = 0x00;
TRISA=0x00;
TRISC=0x01;
TRISC=0x00;

do{

valor1 =
(input(PIN_B3))*8+(input(PIN_B2))*4+(input(PIN_B1))*2+(input(PIN_B0))*1; valor2 =
(input(PIN_B4))*1+(input(PIN_B5))*2+(input(PIN_B6))*4+(input(PIN_B7))*8; if (valor1
==0){ div=0;
res=0;
}
else{
div=(valor2/valor1); res=valor2%valor1;

}
PORTA=div;
PORTD=res;
}while(1);}