INSTITUTO POLITCNICO NACIONAL UNIDAD PROFESIONAL INTERDISCIPLINARIA EN INGENIERA Y TECNOLOGAS AVANZADAS

ARQUITECTURA DE COMPUTADORES

PRCTICA 1

DISEO LGICO DE ALGUNAS UNIDADES Y FUNCIONES QUE COMPONEN A UN COMPUTADOR

ALUMNOS:
RUZ ALCNTARA ROBERTO VZQUEZ NICOLS JESS MANUEL ZERN HERNNDEZ ALEJANDRO RAL

GRUPO: 6MV2

23.03.2011

Contenido
INTRODUCCIN ........................................................................................................... 4 OBJETIVOS..................................................................................................................... 5 ALU DE UN BIT .............................................................................................................. 6
Fundamento terico .................................................................................................................................... 6 Unidades aritmtica lgica. ....................................................................................................................... 6 Desarrollo ..................................................................................................................................................... 8 Cdigo en VHDL ........................................................................................................................................ 8 Resultados ................................................................................................................................................. 10 Ejemplos. ................................................................................................................................................. 10 Conclusiones ............................................................................................................................................. 16 Sumadores y restadores en serie ........................................................................................................... 17 Cdigo en VHDL ...................................................................................................................................... 20 Ejemplos. ................................................................................................................................................. 23

MEMORIA RAM DE 43 .............................................................................................. 28

- Tipos de RAM ........................................................................................................................................ 28 Desarrollo ................................................................................................................................................... 29 Resultados ................................................................................................................................................. 33 Conclusiones ............................................................................................................................................. 36

DOBLADOR DE FRECUENCIA ................................................................................... 37

Fundamento terico .................................................................................................................................. 37 Desarrollo ................................................................................................................................................... 40 Resultados ................................................................................................................................................. 43 Conclusiones ............................................................................................................................................. 46

MULTIPLICACIN SERIE DE 4 BITS ......................................................................... 47

Fundamento terico .................................................................................................................................. 47 Desarrollo ................................................................................................................................................... 48

Resultados ................................................................................................................................................. 51 Conclusiones ............................................................................................................................................. 53

DIVISIN SERIE DE 4 BITS ......................................................................................... 54

Fundamento terico .................................................................................................................................. 54 Desarrollo ................................................................................................................................................... 55 Resultados ................................................................................................................................................. 57 Conclusiones ............................................................................................................................................. 63

ALGORITMO DE BOOTH Y MULTIPLICACIN DE 4 BITS...................................... 64

Fundamento terico .................................................................................................................................. 64 Desarrollo ................................................................................................................................................... 66 Resultados ................................................................................................................................................. 69 Conclusiones ............................................................................................................................................. 73

MULTIPLICADOR PARALELO DE 4 BITS ................................................................. 74

Fundamento terico .................................................................................................................................. 74 Multiplicador matricial paralelo. ............................................................................................................... 74 Desarrollo ................................................................................................................................................... 75 Cdigo en VHDL ...................................................................................................................................... 75 Resultados ................................................................................................................................................. 78 Conclusiones ............................................................................................................................................. 80

Introduccin
El concepto de arquitectura de computadoras, enfocado desde el punto de vista de un programador, se relaciona con el comportamiento funcional de un sistema de computacin. Este punto de vista incluye aspectos tales como el tamao de los diferentes tipos de datos y los tipos de operaciones que se pueden realizar. La organizacin de computadoras se refiere a las relaciones estructurales que no son visibles para el programador, como las interfaces hacia los dispositivos perifricos, la frecuencia del reloj y la tecnologa utilizada en las memorias.

En este reporte describe algunas unidades y funciones propias de la arquitectura y la organizacin de cualquier computador. Por ende, conocer cmo funciona una computadora y de qu manera debemos interactuar con ella son necesidades bsicas.

El objeto de esta prctica fue proporcionar una comprensin de los fundamentos del diseo lgico y de los procesadores para una amplia visin y conocimiento del estudiante. El proceso de diseo se ha automatizado utilizando lenguajes de descripcin de hardware y sntesis lgica, y la bsqueda de alta velocidad y de bajo consumo han cambiado los fundamentos del diseo de los procesadores.

El contenido de este reporte se enfoca en los principios de arquitectura de computadores mientras que al mismo tiempo refleja la importancia relativa de los conceptos bsicos como la tecnologa y la evolucin del proceso de diseo bsico en VHDL y su implementacin en un FPGA. El desarrollo prctico comprende fundamentos de diseo lgico y de computadoras y ofrece un fuerte nfasis en los fundamentos que subyacen al diseo lgico actual utilizando lenguajes de descripcin hardware, sntesis y verificacin as como los cambios en el nfasis en el uso de los fundamentos del diseo de procesadores.

As que este reporte, describir algunas sencillas unidades y funciones que componen a una parte de la arquitectura de un computador.

Objetivos

Mediante lgica programable en VHDL y su implementacin en un FPGA, realizar las siguientes unidades y funciones que conforman a una cierta parte de la arquitectura de un computador:

Disear e implementar una unidad aritmtica lgica (ALU) de un bit.

Disear e implementar un sumador/restador de 8 bits.

Disear e implementar una memoria RAM 4x3.

Disear e implementar un doblador de frecuencia.

Disear e implementar un multiplicador serie de 4 bits.

Disear e implementar un divisor serie de 4 bits.

Disear e implementar un multiplicador de 4 bits con algoritmo de Booth.

Disear e implementar un multiplicador matricial (paralelo) de 4 bits.

ALU de un bit
Fundamento terico

Unidades aritmtica lgica.

Casi todas las computadoras contienen un solo circuito para obtener el AND, el OR, y la suma de dos palabras de mquina. Por lo regular, un circuito de este tipo para palabras de n bits se construye con n circuitos idnticos para las posiciones de bit individuales. La Figura 1es un ejemplo sencillo de un circuito de este tipo, llamado unidad aritmtica lgica o ALU (Arithmetic Logic Unit). Una unidad aritmtica y lgica pueden calcular cualquiera de cuatro funciones: A AND B, A OR B, , o A+B, dependiendo de si las lneas de entrada de seleccin de funcin F0 y F1 contienes 00, 01, 10 o 11 (binario). Cabe sealar que aqu A + B significa la suma aritmtica de A y B, no el AND booleano.

Figura 1

ALU de un bit

La esquina inferior izquierda de nuestra ALU contiene un decodificador de 2 bits que genera seales de habilitacin para las cuatro operaciones, con base en las seales de control F0 y F1, una y slo una de las cuatro lneas de habilitacin se selecciona. Un valor de 1 en una de estas lneas permite que la salida de la funcin seleccionada pase hasta la compuerta OR final y de ah a la salida. La esquina superior izquierda contiene la lgica necesaria para calcular A AND B, A OR B y , pero slo uno de estos resultados pasa a la compuerta OR final, dependiendo de las lneas de habilitacin que salen del decodificador. Dado que una y slo una de las lneas del decodificador es 1, una y slo una de las cuatro compuertas AND que alimentan a la compuerta OR estar habilitada; las otras tres producirn 0, sean cuales sean los valores de A y B. Adems de poder usar A y B como entradas de operaciones aritmticas o lgicas, es posible hacer que cualquiera de las dos sea 0 negado ENA o ENB, respectivamente. Tambin es posible obtener poniendo INVA. En condiciones normales, tanto ENA como ENB son 1 para habilitar ambas entradas, e INVA es 0. En este caso, A y B simplemente se alimentan a la unidad lgica sin modificacin. La esquina inferior derecha de la ALU contiene el sumador completo para calcular la suma de A y B, e incluye manejo de acarreos porque es probable que se conecten juntos varios de estos circuitos para efectuar operaciones con palabras enteras. Es posible conseguir circuitos como en la Figura 1, llamado porcin de bit (bit slice). Estas posiciones permiten al diseador de una computadora construir una ALU de la capacidad deseada. La Figura 2muestra una ALU de 8 bits formada por ocho ALU de porcin de un bit. La seal INC slo es til en operaciones de suma; se est presente, incrementa (es decir, suma 1 a) el resultado, lo que permite calcular sumas A + 1 y A + B + 1.

Figura 2.

Ocho tajadas de ALU de un Bit conectadas para formar una ALU de 8 bits

Por sencillez, no se muestran las seales de habilitacin y de inversin.

Desarrollo

Cdigo en VHDL
library IEEE use IEEE.STD_LOGIC_1164.ALL; entity Alu1bit is Port ( inva : in STD_LOGIC; a : in STD_LOGIC; ena : in STD_LOGIC; b : in STD_LOGIC; enb : in STD_LOGIC; acarreoin : in STD_LOGIC; f : in STD_LOGIC_VECTOR (1 downto 0); salida : out STD_LOGIC; acarreosal : out STD_LOGIC); end Alu1bit;

architecture ALU of Alu1bit is signal linea:std_logic_vector(3 downto 0); signal entrada:std_logic_vector(1 downto 0); signal logica:std_logic_vector(2 downto 0); signal suma: std_logic;

begin --Decodificador---process(f)begin linea(0)<=(not(f(0)))and(not(f(1))); linea(1)<=(not(f(0)))and((f(1))); linea(2)<=((f(0)))and(not(f(1))); linea(3)<=((f(0)))and((f(1))); end process;

--Entrada-process(inva,a,ena,b,enb)begin entrada(0)<=(ena and a) xor inva; entrada(1)<=b and enb; end process;

--Unidad logica__ process(entrada,linea)begin logica(0)<=(entrada(0) and entrada(1)) and linea(0); logica(1)<=(entrada(0) or entrada(1)) and linea(1); logica(2)<=(not(entrada(1))) and linea(2); end process;

--Sumador Completo-process(linea,entrada,acarreoin)begin acarreosal<=(entrada(0) and entrada(1) and linea(3)) or (linea(3) and (entrada(0) xor entrada(1)) and acarreoin); suma<=((entrada(0) xor entrada(1)) xor acarreoin) and linea(3); salida<= suma or logica(0) or logica(1) or logica(2); end process; end ALU; Asignacin de pines de entradas y salidas. NET "a" LOC = P11; NET "acarreoin" LOC = K3; NET "acarreosal" LOC = G1; NET "b" LOC = L3; NET "ena" LOC = B4; NET "enb" LOC = G3; NET "f[0]" LOC = N3; NET "f[1]" LOC = E2; NET "inva" LOC = F3; NET "salida" LOC = M5;

Resultados

Ejemplos.

Se prob nuestro programa y los resultados los iremos describiendo a continuacin. Pero antes se aclarar qu hace cada uno de los interruptores. Empezar de izquierda a derecha. El primer interruptor es F1 y el segundo es F0; el tercero es INVA; el cuarto y el quinto es ENB y ENA respectivamente; el sexto es el acarreo del sumador completo y finalmente el sptimo y el octavo son B y A respectivamente. Como podemos ver en la Figura 3, Figura 4 y Figura 5, se habilitan A y B y con la combinacin binaria 00, hacemos la operacin AND. En la Figura 6 se observa que al tener en 0 a A y activando la INVA con 1; hace la operacin AND correctamente. El LED del lado derecho nos muestra la salida de la ALU.

Figura 3

Operacin AND con A y B en 1

Figura 4

Operacin AND con A en 0 y B en 1

10

Figura 5

Operacin AND con A y B en 0

Figura 6

Operacin AND con A en 0; B en 1 en INVA en 1

En seguida, la Figura 7, Figura 8, Figura 9, Figura 10, se habilitan A y B y con la combinacin binaria 01, hacemos la operacin OR. En la Figura 11 se observa que al tener en 0 a A y B y activando la INVA con 1; hace la operacin OR correctamente. El LED del lado derecho nos muestra la salida de la ALU.

F IGURA 7 O PERACIN OR

CON

EN

11

Figura 8

Operacin OR con A en 1 y B en 0

Figura 9

Operacin OR con A y B en 1

Figura 10

Operacin OR con A en 0 y B en 1

12

Figura 11

Operacin OR con A y B en 0 e INVA en 1

En seguida, la Figura 12 y Figura 13, se habilitan A y B y con la combinacin binaria 10, hacemos la operacin . El LED del lado derecho nos muestra la salida de la ALU.

Figura 12

Operacin NOT con B en 0

Figura 13

Operacin NOT con B en 1

13

Por ltimo, la Figura 14, Figura 15, Figura 16 y Figura 17, se habilitan A y B y con la combinacin binaria 11, hacemos la suma de A + B. En la Figura 18, Figura 19, Figura 20 y Figura 21, se hace lo mismo que el anterior pero con acarreo de entrada. El LED del lado derecho nos muestra la salida de la ALU y el de la izquierda es el acarreo de la suma.

Figura 14

Operacin A+B con A y B en 0

Figura 15

Operacin A+B con A en 1 y B en 0

Figura 16

Operacin A + B con A en 0 y B en 1

14

Figura 17

Operacin A + B con A y B en 1 y acarreo final

Figura 18

Operacin A + B con A y B en 1, acarreo inicial y final.

Figura 19

Operacin A + B con B en 1 y A en 0; acarreo inicial y final

15

Figura 20

Operacin A + B con B en 0 y A en 1; acarreo inicial y final.

Figura 21

Operacin A + B con A y B en 0; acarreo inicial y final

Conclusiones

Tras la realizacin de esta prctica se pudo observar y comprobar realmente el funcionamiento de una ALU de 1 bit, la cual es una unidad fundamental de la cual todas las computadoras la tienen. Adems de que esta primera prctica fue de las ms sencillas de todas.

16

Sumador/restador de 8 bits
Fundamento terico

Sumadores y restadores en serie

El diseo de un sumador serie (ripple carry adder) para dos nmeros de cuatro bits. El circuito sumador sigue el modelo utilizado normalmente para la suma decimal, en el que se suman los dgitos de cada columna, en forma consecutiva una tras otra, de derecha a izquierda. La Figura 22 muestra el circuito del sumador serie de cuatro bits. Los dos nmeros binarios A y B se suman de derecha a izquierda, generando un bit de suma y uno de arrastre en cada columna binaria.

Figura 22

Sumador serie para dos nmeros de 4 bits.

En la Figura 23 se han conectado en cascada cuatro sumadores binarios serie para permitir la suma de dos nmeros de 16 bits. El sumador completo de la derecha tiene su entrada de arrastre en 0. Si bien este anlisis podra haber simplificado el circuito de tal sumador, se prefiere usar la forma ms general y forzar c0 a 0 para simplificar el posterior proceso de resta.

17

Figura 23

Sumador de 16 bits obtenido a partir de cuatro sumadores series de 4 bits cada uno.

La resta de nmeros binarios se resuelve en una forma similar a la de la suma. La resta entre dos nmeros puede realizarse trabajando de a una columna por vez, restando de derecha a izquierda los dgitos del sustraendo bi de los respectivos dgitos del minuendo ai. Tal como en la resta decimal, si el sustraendo es mayor que el minuendo o hay un arrastre (borrow) desde un digito previo, se deber propagar dicho arrastre hacia el bit ms significativo siguiente. La Figura 24ilustra la tabla de verdad y un diagrama en bloque del circuito restador.

Figura 24

Tabla de verdad y smbolo esquemtico para un restador serie de 1 bit.

Los circuitos restadores de dos nmeros de un bit pueden conectarse en cascada para crear un circuito restador serie, de la misma manera en que se conectan en serie los sumadores completos

18

de nmeros de un bit para formar un sumador serie. La Figura 25 ilustra un circuito restador serie de cuatro bits formado por cuatro restadores completos de un bit.

Figura 25

Restador Serie.

Tal como se analizara previamente, un mtodo alternativo para la implementacin de la resta consiste en determinar el complemento a dos del sustraendo y sumarlo al valor del minuendo. El circuito de la Figura 26 resuelve tanto la operacin de suma como la de resta sobre dos nmeros de cuatro bits, para lo cual requiere que las entradas bi puedan complementarse cuando se desea realizar una resta.

Una lnea de control SUMAR/RESTAR determina cual es la operacin a realizar. La barra por encima del smbolo SUMAR indica que la operacin de suma se activa cuando la seal est en su nivel bajo. Esto es, si la lnea de control est en su estado 0, las entradas ai y bi se transfieren al sumador, el que genera la suma si en sus salidas. Si la lnea de control est en 1, las entradas ai se transfieren al sumador, pero las entradas bi se complementan a uno en las compuertas XOR antes de su ingreso al sumador.

Para formar el complemento a dos, se debe sumar 1 al complemento a 1, lo que se logra colocando la lnea de arrastre de entrada c0 en 1 por medio de la entrada de control. De esta manera, la electrnica del sumador se comparte entre el sumador y el restador.

19

Figura 26

Circuito Sumador-Restador

Desarrollo

Cdigo en VHDL
library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity sumrest8b is Port ( push : in STD_LOGIC; int : in STD_LOGIC_VECTOR (7 downto 0); leds : out STD_LOGIC_VECTOR (7 downto 0)); end sumrest8b; architecture sr8b of sumrest8b is signal carry: std_logic_vector(8 downto 0); signal a: std_logic_vector(7 downto 0); signal b: std_logic_vector(7 downto 0); signal sor: std_logic; type edos is (e0,e1,e2,e3); signal edosp,edosf:edos; begin

20

process(push)begin if(push'event and push='1') then edosp<=edosf; end if; end process;

process(int)begin case edosp is when e0 => carry(0)<=int(0); --Selecciona suma o resta sor<=int(0); leds<="00000000"; edosf<=e1;

when e1 =>

a<=int; --Se introduce el primer numero en 8 bits leds<=int; edosf<=e2;

when e2 =>

b<=int; --Se introduce el segundo numero en 8 bits leds<=int; edosf<=e3;

when e3 => and carry(0)));

leds(0)<=(((sor xor b(0)) xor a(0)) xor carry(0));

--Suma o resta

carry(1)<=(((sor xor b(0)) and a(0)) or (((sor xor b(0)) xor a(0)) leds(1)<=(((sor xor b(1)) xor a(1)) xor carry(1)); carry(2)<=(((sor xor b(1)) and a(1)) or (((sor xor b(1)) xor a(1)) and carry(1))); leds(2)<=(((sor xor b(2)) xor a(2)) xor carry(2)); carry(3)<=(((sor xor b(2)) and a(2)) or (((sor xor b(2)) xor a(2)) and carry(2))); leds(3)<=(((sor xor b(3)) xor a(3)) xor carry(3)); carry(4)<=(((sor xor b(3)) and a(3)) or (((sor xor b(3)) xor a(3)) and carry(3)));

21

leds(4)<=(((sor xor b(4)) xor a(4)) xor carry(4)); carry(5)<=(((sor xor b(4)) and a(4)) or (((sor xor b(4)) xor a(4)) and carry(4))); leds(5)<=(((sor xor b(5)) xor a(5)) xor carry(5)); carry(6)<=(((sor xor b(5)) and a(5)) or (((sor xor b(5)) xor a(5)) and carry(5))); leds(6)<=(((sor xor b(6)) xor a(6)) xor carry(6)); carry(7)<=(((sor xor b(6)) and a(6)) or (((sor xor b(6)) xor a(6)) and carry(6))); leds(7)<=(((sor xor b(7)) xor a(7)) xor carry(7)); carry(8)<=(((sor xor b(7)) and a(7)) or (((sor xor b(7)) xor a(7)) and carry(7))); edosf<=e0; end case; end process; end sr8b; Asignacin de pines de entradas y salidas. NET "int[0]" LOC = P11; NET "int[1]" LOC = L3; NET "int[2]" LOC = K3; NET "int[3]" LOC = B4; NET "int[4]" LOC = G3; NET "int[5]" LOC = F3; NET "int[6]" LOC = E2; NET "int[7]" LOC = N3; NET "leds[0]" LOC = M5; NET "leds[1]" LOC = M11; NET "leds[2]" LOC = P7; NET "leds[3]" LOC = P6; NET "leds[4]" LOC = N5; NET "leds[5]" LOC = N4; NET "leds[6]" LOC = P4; NET "leds[7]" LOC = G1; NET "push" LOC = A7;

22

Resultados

Ejemplos.

Se prob nuestro programa y los resultados los describiremos a continuacin. Se ingresan 2 sumas y 2 restas. En la Figura 27 se ingresa con 0 lgico la suma, en la Figura 28 se ingresa el primer dato que es 01110110 que en decimal es 118. A continuacin en la Figura 29 se ingresa el segundo dato que es 00011010 que en decimal es 26. Finalmente en la Figura 30 se muestra el resultado de la suma que es 10010000 que en decimal es 144. Se verifica que hace correctamente la suma.

Figura 27

Se ingresa la operacin a realizar que ser la suma.

Figura 28

Primer dato a sumar

23

Figura 29

Segundo dato a sumar

Figura 30

Resultado de la Suma

En seguida, la Figura 31 se ingresa con 0 lgico la suma, en la Figura 32 se ingresa el primer dato que es 10111110 que en decimal es 190. A continuacin en la Figura 33 se ingresa el segundo dato que es 00001110 que en decimal es 14. Finalmente en la Figura 35 se muestra el resultado de la suma que es 11001100 que en decimal es 204. Se verifica que lo hace correctamente la suma.

Figura 31

Se ingresa la operacin a realizar que ser la suma

Figura 32

Primer dato a sumar

24

Figura 33

Segundo dato a sumar

Figura 34

Resultado de la suma

Despus, la Figura 35 se ingresa con 1 lgico la resta, en la Figura 36 se ingresa el primer dato que es 01110001 que en decimal es 113. A continuacin en la Figura 37 se ingresa el segundo dato que es 00011001 que en decimal es 25. Finalmente en la Figura 38 se muestra el resultado de la suma que es 01011000 que en decimal es 88. Se verifica que lo hace correctamente la resta

Figura 35

Se ingresa la operacin a realizar que ser resta

Figura 36

Se ingresa el primer dato.

25

Figura 37

Se ingresa el segundo dato a restar

Figura 38

Resultado de la Resta

Finalmente, la Figura 39 se ingresa con 1 lgico la resta, en la Figura 40 se ingresa el primer dato que es 00000111 que en decimal es 7. A continuacin en la Figura 41 se ingresa el segundo dato que es 01100001 que en decimal es 97. Finalmente en la Figura 42 se muestra el resultado de la suma que es 10100110 que en decimal es -83. Se verifica que lo hace correctamente la resta

Figura 39

Se ingresa la operacin a realizar que ser resta

26

Figura 40

Se ingresa el primer dato

Figura 41

Se ingresa el segundo dato a restar

Figura 42

Resultado de la resta

Conclusiones
Tras la realizacin de esta prctica se demostr el funcionamiento del sumadorrestador de 8 bits; esto nos llev a comprobar que con cualquier dato que se ingresa y al hacer resta o suma lo hace de forma correcta. Tambin al sumar dos nmeros muy grandes y que el resultado es mayor de 8 bits nos entrega el resultado de los 8 bits menos significativo y los dems los desprecia; mientras en resta, al tener un nmero pequeo menos un nmero ms grande que primero, el resultado es negativo.

27

Memoria RAM de 43
Fundamento terico
La memoria principal o RAM (Random Access Memory, Memoria de Acceso Aleatorio) es donde el computador guarda los datos que est utilizando en el momento presente. El almacenamiento es considerado temporal por que los datos y programas permanecen en ella mientras que la computadora este encendida o no sea reiniciada. Se le llama RAM por que es posible acceder a cualquier ubicacin de ella aleatoria y rpidamente. Fsicamente, estn constituidas por un conjunto de chips o mdulos de chips normalmente conectados a la tarjeta madre. Los chips de memoria son rectngulos negros que suelen ir soldados en grupos a unas plaquitas con "pines" o contactos, un mdulo tpico es el mostrado en la Figura

43.

Figura 43

Mdulo de Memoria RAM

La diferencia entre la RAM y otros tipos de memoria de almacenamiento, como los disquetes o los discos duros, es que la RAM es mucho ms rpida, y que se borra al apagar el computador, no como los Disquetes o discos duros en donde la informacin permanece grabada.

- Tipos de RAM

Hay muchos tipos de memorias DRAM, Fast Page, EDO, SDRAM, etc. Y lo que es peor, varios nombres. Trataremos estos cuatro, que son los principales, aunque mas adelante en este Informe encontrar prcticamente todos los dems tipos.

DRAM: Dinamic-RAM, o RAM DINAMICA, ya que es "la original", y por tanto la ms lenta. Usada hasta la poca del 386, su velocidad tpica es de 80 70 nanosegundos (ns), tiempo ste que tarda en vaciarse para poder dar entrada a la siguiente serie de datos. Por ello, es

28

ms rpida la de 70 ns que la de 80 ns. Fsicamente, aparece en forma de DIMMs o de SIMMs, siendo estos ltimos de 30 contactos.

Fast Page (FPM): a veces llamada DRAM (o slo "RAM"), puesto que evoluciona directamente de ella, y se usa desde hace tanto que pocas veces se las diferencia. Algo ms rpida, tanto por su estructura (el modo de Pgina Rpida) como por ser de 70 60 ns. Usada hasta con los primeros Pentium, fsicamente aparece como SIMMs de 30 72 contactos (los de 72 en los Pentium y algunos 486).

EDO: o EDO-RAM, Extended Data Output-RAM. Evoluciona de la Fast Page; permite empezar a introducir nuevos datos mientras los anteriores estn saliendo (haciendo su Output), lo que la hace algo ms rpida (un 5%, ms o menos). Muy comn en los Pentium MMX y AMD K6, con velocidad de 70, 60 50 ns. Se instala sobre todo en SIMMs de 72 contactos, aunque existe en forma de DIMMs de 168.

SDRAM: Sincronic-RAM. Funciona de manera sincronizada con la velocidad de la placa (de 50 a 66 MHz), para lo que debe ser rapidsima, de unos 25 a 10 ns. Slo se presenta en forma de DIMMs de 168 contactos; es usada en los Pentium II de menos de 350 MHz y en los Celeron.

PC100: o SDRAM de 100 MHz. Memoria SDRAM capaz de funcionar a esos 100 MHz, que utilizan los AMD K6-2, Pentium II a 350 MHz y computadores ms modernos; tericamente se trata de unas especificaciones mnimas que se deben cumplir para funcionar correctamente a dicha velocidad, aunque no todas las memorias vendidas como "de 100 MHz" las cumplen.

PC133: o SDRAM de 133 MHz. La ms moderna (y recomendable).

Desarrollo
Como base de este programa se toma el siguiente diagrama tomado del libro organizacin de computadoras (Figura 44).

29

Figura 44

Memoria RAM de 4x3

Para el desarrollo de esta memoria se utilizo el lenguaje VHDL para poder implementarlo en una FPGA. Para ello se desarrollo el cdigo que se muestra en la Figura 45.

Figura 45

Declaracin de Entradas y Libreras

30

En la pasada figura pudimos observar que se declararon las entradas que estn asociadas a cada uno de los elementos de la memoria, como lo son: CE (chip enable). Que permite activar o desactivar todo el modulo de la memoria, por lo que si CE esta en nivel bajo, no se podr grabar en la memoria ni tampoco se podr leer datos de ella. Si se encuentra en nivel lgico alto, permite la manipulacin de la memoria. RW (Read-Write). Permite realiza operacin de escritura o lectura segn sea el caso, en nivel lgico 0 permite la escritura, e nivel lgico 1 permite la lectura. OE (Output enable). Permite habilitar la salida que se desea obtener de algn registro de la memoria, en el caso de estar en nivel lgico 0 la salida no es habilitada y lo pone en estado de alta impedancia, en caso de estar en 1 permite visualizar la salida.

Tambin se dan de alta lo que son los leds donde se observaran las salidas, que se consideran a su vez como el bus de datos, as como los pines de seleccin tanto para lectura y escritura, lo que se conoce como bus de direcciones, en este caso un bus de direcciones de 2.

En la Figura 46 se presenta la declaracin de varias seales auxiliares que permitirn la programacin del algoritmo de la memoria RAM.

Figura 46

Declaracin de Seales auxiliares para la programacin

31

Ah mismo se puede observar la declaracin de un proceso, el cual en este caso es el proceso principal, que se puede apreciar mejor en la Figura 47. En este proceso se comienza con un case el cual har la funcin de bus de datos ya que dependiendo del valor del bus de datos asignara un valor a la seal x. Posteriormente se presenta una serie de ifs anidados que darn la pauta para realizar las diversas acciones como lo son las de escritura o lectura.

Figura 47

Proceso Principal y Sentencias case e if.

Como se puede observar, ah se hace uso de las seales auxiliares que en si misma permitirn guardar los datos. En la Figura 48 se presenta un segundo if el cual ser para poner la memoria en modos lectura y con OE activado para mostrar los datos en los leds.

32

Figura 48

Segunda Sentencia IF para habilitar la memoria en modo lectura.

En el caso que la salida OE esta en nivel bajo, no se realiza ninguna tarea lo que hace que los leds, se encuentren apagados pero los datos contenidos en las seales auxiliares no se vern modificados en ningn momento. Por lo que en el momento de activar la salida se mostraran los datos del registro seleccionado.

Resultados
A continuacin se presentara la implementacin de este programa en una FPGA. En la Figura 49 se observa la escritura del nmero 111 en el registro 00, esto es debido a que los pines son los siguientes (de derecha a izquierda): - Pin del 1 al 3.- Entradas para escribir el dato - Pin 4 y 5.- Bus de Datos - Pin 6.- Habilitacin de la memoria. - Pin 7.- Escritura-lectura. - Pin 8.- Habilitacin de la salida.

33

As observamos en la Figura 49 que el bus de direcciones es el 00, y que esta habilitada la memoria y la escritura, por lo que el valor 111 se guardara en la localidad 00.

Figura 49

Grabacin de 111 en el registro 00.

En la Figura 50 se muestra la escritura del valor 11 en el registro 10 ya que la escritura est habilitada al igual que el chip.

Figura 50

Escritura del nmero 11 en el registro 01.

En la Figura 51 se observa que se habilita la lectura de la memoria RAM, eso quiere decir que no importa lo que se escriba en los primeros pines, no se guardara en la memoria, pero adems no se mostrara nada en los LEDS ya que no est habilitada la salida.

34

Figura 51

Habilitacin de lectura sin mostrar el dato.

En la Figura 52, ahora si se tiene habilitada la salida por lo que se muestra el valor contenido en el registro 00 que es el valor 111.

Figura 52

Salida habilitada por lo que muestra el valor 111 en el registro 00.

En la Figura 53, se muestra ahora el dato guardado en el registro 01 que en este caso es el valor 011, ya que esta habilitada la lectura y la salida, adema ntese que en los primeros switchs esta 111 pero como esta en modo lectura el programa no lo toma en cuenta. 35

Figura 53

En Modo lectura. Se lee el registro 01 con el valor 011 previamente guardado

Conclusiones
La implementacin de una memoria es de gran importancia dentro de este curso, ya que en cualquier sistema computacional, siempre es necesario guardar datos y acceder a ellos en los momentos que sea necesario, ese es uno de los principios bsicos de la computacin y que han permitido el desarrollo de lo que hoy en da es la computacin, de ah radica la vital importancia dentro de este curso.

36

Doblador de frecuencia
Fundamento terico
En la electrnica digital hay unas compuertas que no son comunes. Una de ellas es la compuerta XOR compuerta O exclusiva compuerta O excluyente. En la siguiente Figura 54 muestra el smbolo de una compuerta XOR (O exclusiva) de 2 entradas:

Figura 54.

Compuerta XOR

Comprender el funcionamiento de esta compuerta digital es muy importante para despus poder implementar lo que se llama un comparador digital, que es una de las principales aplicaciones. La Figura 55 se muestra la tabla de verdad de una compuerta XOR de 2 entradas.

Figura 55

Tabla de Verdad Compuerta XOR.

Se representa con la siguiente funcin booleanas. X = A.B + A.B

37

A diferencia de la compuerta OR, la compuerta XOR tiene una salida igual a "0" cuando sus entradas son iguales a 1. Si se comparan las tablas de verdad de la compuerta OR y la compuerta XOR se observa que la compuerta XOR tendr un uno ("1") en su salida cuando la suma de los unos "1" en las entradas sea igual a un nmero impar.

Si tenemos una seal a la cual le aplicamos un defasamiento y luego operamos las 2 seales en una compuerta XOR que multiplican las 2 seales de dando como resultado una seal de referencia. A la salida de la XOR adems de niveles largos de 1 y 0 aparece una seal cuadrada de frecuencia doble a la de la original con un ciclo til diferente de 50 % (a menos que los defases sean de 90 grados). En la siguiente Figura 56 tenemos un ejemplo de las seales de entrada y la salida de una XOR.

Figura 56

Seales de Entrada y Salida de la XOR

Vamos a describir aqu, cmo se comporta un divisor de frecuencias. Trataremos de frecuencias (en lugar de pulsos individuales que lleguen al azar a intervalos), si aplicamos un tren de pulsos de frecuencia fija a un contador comenzamos a notar algunas caractersticas interesantes y algunas relaciones tiles, entre la seal de entrada y la seal de salida.

38

Consideremos un flip-flop con una sucesin continua de pulsos de reloj y con una frecuencia fija, como el que se muestra a la derecha. En la Figura 57 se presenta el diagrama de un Flip Flop tipo D.

Figura 57

Flip Flop Tipo D como Divisor de Frecuencia

Notamos tres hechos tiles sobre las seales de salida, vistas en Q y Q': Las seales, estn exactamente invertidas una de la otra. Las seales, son ondas cuadradas perfectas, rendimiento del 50 %. Las seales, tienen una frecuencia justamente la mitad del tren de impulsos de entrada. El divisor digital, ms simple es el compuesto por una bscula o flip-flop, elemento ste que puede estar formado por dos transistores y unos pocos componentes o por dos puertas lgicas conectadas en realimentacin. En primer lugar, al tratar con flip-flops, alguien errneamente, puede pensar que una frecuencia, slo se puede dividir por nmeros pares, la divisin de una frecuencia por un nmero impar tambin es posible, como veremos ms adelante. Este es, un ejemplo sencillo de un divisor de impulsos, puede observarse que de cada dos impulsos introducidos en A, en la salida Q, nos entrega la mitad, la puerta I es un inversor que se ha dispuesto en esa posicin para evitar en lo posible los estados indeterminados que suelen aparecer en este tipo de bsculas cableadas. El circuito de un flip-flop tipo D, es algo ms que el circuito de una bscula tipo D, aunque parece muy similar, tambin tiene una nica entrada de datos y una de reloj. Es bastante ms complicado, la diferencia bsica est en la nueva forma de utilizar la seal de reloj. A veces, en los circuitos digitales, interesa asegurar que no pueda cambiar un dato de entrada durante el intervalo de ser transferido este dato a la salida entonces, se utiliza lo que se conoce como la tcnica de 'flanco de disparo'. Por consiguiente, llamaremos bscula a los elementos que

39

utilicen el nivel activo de reloj y flip-flop a los que utilicen el flanco de subida o disparo. En la Figura

58, presentamos un FF tipo D.

Figura 58

Flip Flop tipo D

Desarrollo
Para el desarrollo de esta prctica se hizo uso de una FPGA, donde mediante programacin en VHDL, se elaboraron los defasamientos de las seales y las operaciones XOR, y la implementacin de un Flip Flop tipo D, donde la seal de reloj ser la proveniente de la segundo compuerta XOR. En la Figura 59, estn la bibliotecas y la declaracin de entradas y salidas, donde el oscilador interno de la FPGA ser una entrada de reloj y una seal que ser un vector donde las salidas son las seales en cada etapa.

40

Figura 59

Bibliotecas y seales utilizadas

En la siguiente Figura 60, se muestran las seales auxiliares para la generacin de los defasamientos as como las operaciones XOR.

Figura 60

Seales auxiliares

A continuacin se presenta la forma en que se generan la seales en un ambiente en VHDL, mediante contadores y condicionales if. Esto se observa en la Figura 61.

41

Figura 61

Generacin de las Seales

Posteriormente se realiza la operacin XOR y se crea una nueva seal desfasada con respecto a la salida de la XOR. Esto se muestra en la Figura 62.

Figura 62

Operacin XOR y Seal defasada

Por ltimo se presentan la implementacin del Flip Flop, donde la seal de reloj esta dada por la segunda operacin XOR. Esto se observa en la Figura 63.

42

Figura 63

Implementacin del Flip Flop..

Resultados
Este programa lo vamos a analizar con un circuito equivalente en Multisim, el cual nos entrega la primera seal vista en la Figura 64.

Figura 64

Primera Seal

Despus de aplicar el defasamiento a las seales mediante compuertas logicas tenesmo lo mostrado en la Figura 65.

43

Figura 65. Seales desfasadas.

En la Figura 66, tenemos el resultado de la operacin XOR donde se nota que los picos son el desfasamiento de las seales originales.

Figura 66

Seal de salida de la XOR

En la Figura 67, tenemos la seal resultante de la segunda compuerta XOR, que son 2 picos debido a que el ciclo til no es del 50%. Pero la frecuencia si se cuadriplico.

44

Figura 67

Seales de salida de las XOR

Por ltimo presentamos la seal de salida del FF. Con la frecuencia del doble de la primera pero con un ciclo til diferente de 50%. Esto se observa en la seal de la Figura 68.

Figura 68

Salida final del FF

45

Conclusiones
Tras lla realizacin de esta practica se pudo observar una de las ventajas que se tiene al usar la compuerta XOR, como un duplicador de frecuencia y a su vez la utilizacin de un Flip Flop tipo D como un divisor de frecuencia que son aplicaciones importantes dentro de la ingeniera.

46

Multiplicacin serie de 4 bits

Fundamento terico
Este algoritmo es de los primeros que se disearon ya que tiene una simplicidad en las operaciones a realizar, con el inconveniente que se vuelve ineficiente. Este algoritmo presentan las siguientes ventajas: Reproduce fielmente el mtodo de multiplicar empleado manualmente. -Se multiplica usando nicamente sumas y desplazamientos.

Y tenemos que el algoritmo es el siguiente: 1. Se observa el bit menos significativo de Q. Si es 1, se copia M y se suma. Si es 0, se suman todos ceros. 2. Se desplazan los registros A y Q a la derecha. 3. Se repiten los pasos 1 y 2 tantas veces como bits tenga el multiplicador (Q). 4. El resultado se encuentra en A y Q.

Esto se puede observar en la Figura 69 con la multiplicacin de los nmeros 0010 y 0101 que en decimal representan el 2 y 5 respectivamente , y que multiplicandolos se obtiene el numero 10, que en binario es el 1010 .

47

Figura 69

Representacin del algoritmo de multiplicacin Serie

Desarrollo

Para el desarrollo de la practica se implemento el algoritmo en una FPGA, utilizando el lenguaje VHDL, presentando algunos inconvenientes con el paralelismo al igual que ocurri con el algoritmo de Booth, que se resolvieron mediante la utilizacin de maquinas de estado.

En la Figura 70, tenemos la declaracin de bibliotecas, as como las variables de entrada que en este caso se trata de un vector que recibir los datos a travs de los switchs, los leds para mostrarlos y dos botones para reinicio y para ejecutar el programa paso a paso.

48

Figura 70

Declaracin de bibliotecas y entradas

En la Figura 71, se presentan las variables que sern utilizadas en la realizacin de este algoritmo, ya que permitirn ir guardando los datos para la realizacin de la iteraciones.

Figura 71

Declaracin de Variables auxiliares

Posteriormente de realiza el primer proceso que es el que da la pauta para hacer nuestro algoritmo tipo secuencial ya que en este proceso, permitir que se ejecute por partes o estados, en donde

49

cada estado esta asociado a realizar ya sea los desplazamientos y sumas. Esto se observa en la Figura 72.

Figura 72

Procesos que permite la realizacin secuencial

Los primeros 2 estados, sirven para poder cargar los valores introducidos por el usuario y guardarlos en variables auxiliares para posteriormente operar con ellos. Esta asignacin se observa en la Figura 73.

Figura 73

Estados para cargar los datos y guardarlos

50

En los estados posteriores se irn realizando los desplazamientos o las sumas siempre dependiendo del bit menso significativo del multiplicador. Esto se observa en la Figura 74.

Figura 74

Desplazamientos o sumas

Este proceso se debe repetir tantas veces como numero de bits se tengan, es decir en nuestro caso al ser operaciones con datos de 4 bits se deben hacer 4 iteraciones y los resultados sern de 8 bits.

Resultados
A continuacin se presenta la implementacin en la FPGA. Para mostrar el funcionamiento correcto del algoritmo, se realizara la multiplicacin de dos datos el 1010 y el 1011. En la FIGURA 75 se tiene que se carga el primer dato.

Figura 75

Carga del Primer dato

51

En la Figura 76, se presenta cuando se carga el segundo dato.

Figura 76

Carga del segundo dato.

Posteriormente se hace el anlisis, como el primer bit del numero 1011 es 1, entonces implica realizar la suma del registro A (inicialmente en 0) en el registro M( que contiene al multiplicando), por lo que el dato nuevo queda de la siguiente manera, 1010 1101, para posteriormente desplazarse quedando el numero 0101 0101 donde los bits menos significativo son el registro Q y los otros 4 al nuevo registro A. Esto se observa en la siguiente Figura 77.

Figura 77

Desplazamiento y suma de la primera iteracin.

Como el nuevo numero tiene nuevamente en 1 su bit menso sinificativo por lo que realiza la suma y posteriormente desplaza, eso se observa en la siguiente Figura 78.

Figura 78

Segunda iteracin.

En este ltimo resultado observamos que existe un cero en el LSB ltimo en el nmero (0111 1010), por ello en la siguiente iteracin nicamente existe desplazamiento, quedando el nmero 0011 1101, esto se observa en el Figura 79.

52

Figura 79 Resultados de la tercera iteracin.

Para la ultima iteracin observamos que el ultimo nmero tiene un 1 en su bit menos significativo, por lo que implica la suma y el desplazamiento, quedando el nmero 0110 1110, que en decimal es el numero 110, que como podemos comprobar es el resultado de multiplicar 1010 y 1011, comprobando que se realizo bien la operacin. Esto se observa en la Figura 80.

Figura 80

Resultado de la multiplicacin

Conclusiones
La multiplicacin es una operacin muy importante, que como se pudo comprobar con esta prctica se puede realizar mediante sumas y desplazamientos, lo cual se puede realizar mediante circuitos secuenciales, lo que es muy importante dentro de los sistemas digitales, y como pudimos darnos cuenta el desarrollarlo en VHDL, represento una dificultad que fue superada mediante la realizacin de maquinas de estados.

53

Divisin serie de 4 bits

Fundamento terico
La divisin es algo ms compleja que la multiplicacin, pero est basada en los mismos principios generales. En la Figura 81 se muestra el diagrama de flujo de un algoritmo mquina que corresponde al proceso de divisin larga discutido. El divisor se ubica en el registro M, y el dividendo en el registro Q. En cada, paso, los registros A y Q son desplazados conjuntamente un bit a la izquierda. M es restado de A para determinar si A divide el resto parcial. Si esto se cumple, entonces Q0 se hace 1. Si no, Q0 se hace 0, y M debe sumarse de nuevo a A para restablecer el valor anterior. La cuenta, entonces, se decrementa, y el proceso contina hasta n pasos. Al final, el cociente queda en el registro Q y el resto en el A. Este proceso puede, con cierta dificultad, aplicarse tambin a nmeros negativos.

Figura 81

Algoritmo de la divisin binaria en serie

54

Desarrollo
Mediante mquinas de estado en VHDL, fuimos capaces de realizar el algoritmo mostrado en la

Figura 82. El cdigo diseado fue el siguiente:

55

56

Figura 82

Cdigo en VHDL

Resultados
Con el cdigo diseado, se prosigui a implementarlo y programarlo en el FPGA. Y para demostrar su funcionamiento se propuso realizar la divisin: 135, y as probar que el programa despus de realizar las iteraciones correspondientes mostrar el cociente (para este caso es 2) y el residuo (para este caso es 3). Por tanto, para dar mayor credibilidad se realiz esta operacin de forma manual, siguiendo el algoritmo mostrado en la Figura 83:

57

Figura 83

Algoritmo desarrollado en la divisin de 13/5.

Ahora es momento de implementar y demostrar el funcionamiento de nuestro cdigo en VHDL sobre nuestro FPGA. A continuacin se muestra y describe en la Figura 84 el funcionamiento del hardware en el FPGA. Como se puede apreciar el bit A4 no se puede mostrar debido al nmero limitado de LEDs, pero internamente en la ejecucin del programa este se toma en cuenta.

Figura 84

Implementacin del Hardware ocupado en el FPGA.

58

Con las entradas se ingresa M = 0101(2) = 5(10), y se observan dichas entradas con el nibble ms bajo de LEDs. Se dio NEXT (Figura 85).

Figura 85

Ingreso de M = 5.

Con las entradas se ingresa M = 1101(2) = 13(10), y dichas entradas son observables con el nibble ms bajo de LEDs. Se dio NEXT (Figura 86).

Figura 86

Ingreso de Q = 13

Iteracin 1. Se muestran los valores iniciales y despus se dio NEXT.

Figura 87

Valores Iniciales

Se desplaza AQ a la izquierda y se dio NEXT.

Figura 88

Desplazamiento a la izquierda de A y Q.

59

Se resta A-M, o bien, se saca el complemento a dos de M y se le suma a A. Se dio NEXT.

Figura 89

Resta A-M y se almacena la diferencia en A.

Se recupera A y Q0 = 0, debido a que A4 = 1. Se dio NEXT.

Figura 90

Se recupera A y Q0 = 0, debido a que A4 = 1.

Iteracin 2. Se desplaza AQ a la izquierda, por tanto, A y Q tienen nuevos valores. Se dio NEXT.

Figura 91

Desplazamiento a la izquierda de valores nuevos de A y Q

Se resta A-M. Se da NEXT.

Figura 92

Resta A-M y se almacena la diferencia en A.

60

Se recupera A y Q0=0, debido a que en el paso anterior A4 = 1. Se da NEXT.

Figura 93

Se recupera A y Q0 = 0, debido a que A4 = 1.

Iteracin 3. Se desplaza AQ a la izquierda. A y Q tienen nuevos valores. Se da NEXT.

Figura 94

Desplazamiento a la izquierda de los nuevos valores de A y Q.

Se resta A-M. Se da NEXT.

Figura 95

Resta A-M y almacena la diferencia en A.

Se mantiene A y Q0=1, debido a que A4=0. Se da NEXT.

Figura 96

Se mantiene A y Q0 = 1, debido a que a4 = 0.

61

Iteracin 4.
Se desplaza a la izquierda AQ, por lo que A y Q tienen nuevos valores. Se da NEXT.

Figura 97

Desplazamiento a la izquierda de los nuevos valores de A y Q.

Se resta A-M. Se da NEXT.

Figura 98

Resta A-M y almacena la diferencia en A.

Se recupera A y Q0=0, debido a que A4=1. El resultado es: Q = 0010(2) y el residuo es: A = 0011(2). Que en decimal es Q = 2, y A = 3.

Figura 99

Recupera A y Q0 = 0, debido a que A4 = 0. Esta ltima iteracin mostrar en A el residuo y en Q el cociente

62

Conclusiones
La divisin es una operacin muy importante, que como se pudo comprobar con esta prctica se puede realizar mediante restas, complementos a dos, sumas y desplazamientos, lo cual se puede realizar mediante circuitos secuenciales, lo que es muy importante dentro del diseo lgico de ciertas unidades u operaciones que conforman a un computador, y que a base de los sistemas digitales, diseando estos en cdigo VHDL, represent una dificultad que fue superada mediante la realizacin de maquinas de estados.

63

Algoritmo de Booth y multiplicacin de 4 bits

Fundamento terico
El algoritmo de Booth es un mtodo rpido y sencillo para obtener el producto de dos nmeros binarios con signo en notacin complemento a dos. Debemos saber que un nmero binario est formado por bits de ceros y unos, y que se puede traducir a decimal fcilmente como se muestra en la Figura 100.

Figura 100

Representacin de un nmero en sistema binario.

Sabiendo que la posicin de cada bit es 2^n (elevado a n) y partimos de n=0 de derecha a izquierda, slo queda realizar la suma total de multiplicar por dicho bit, en este caso, lo que muestro a continuacin: 027+126+025+124+023+122+121+020 = 86.

Tambin debemos saber que el complemento a uno de un nmero binario es cambiar sus ceros por unos, y sus unos por ceros (complementar): (010010 -> ca1: 101101) y que el complemento a dos de un nmero binario es el resultado de sumar 1 al complemento a uno de dicho nmero binario esto lo podemos observar en la Figura 101.

Figura 101

Ejemplo de complemento a 1 y a 2

64

El algoritmo de Booth se basa en buscar secuencias de 1s en el multiplicador, y realizar restas y sumas al principio y final de las secuencias, respectivamente Un diagrama de flujo asociado a este algoritmo se puede ver en la Figura 102.

Figura 102

Diagrama de Flujo Booth

Donde podemos observar que es un procedimiento secuencial lo que significo para nosotros algo difcil de solventar, ya que la programacin en VHDL, es en paralelo lo que significo una dificultad. Un ejemplo de este algoritmo se presenta en la Figura 103, con los siguiente valores M = 6 = 0110, Q = 3 = 0011, -M = 1010

Q-1

0000 0011 1010 0011 1101 0001 1110 1000 0100 1000 0010 0100 0001 0010
Figura 103

0 0 1 1 1 0 0

Inicio A=A-M Desplazamiento Desplazamiento A=A+M Desplazamiento Desplazamiento

Ejemplo del algoritmo de Booth

65

Donde se observa que el resultado de la ultima fila corresponde a la multiplicacin de 6 por 3 que es igual 18. El algoritmo presenta ciertos inconvenientes cuando el multiplicando tiene muchas

transiciones entres ceros y uno, por lo que existe un algoritmo denominado Booth mejorado, el cual optimiza este hecho basndose en la transicin de pares de bits, esto se ejemplifica en la Figura

104.

Figura 104 Algoritmo mejorado de Booth

Desarrollo
Para el desarrollo de esta practica se implemento en una FPGA y se programo en lenguaje VHDL, el cual se explicara paso a paso a continuacin. En la Figura 105 se puede aprecia las libreras a utilizar as como la implementacin de las que sern las entradas, en este caso, tendremos como entradas a un vector, que ser el que permita asignar a los operandos, as como otras dos entradas, una que reiniciara el sistema y otra para las transiciones entre los estados, por ultimo tenemos tambin los leds que permitirn visualizar el progreso del algoritmo.

66

Figura 105 Declaracin de libreras y de entradas -salidas.

Posteriormente en la Figura 106, mostramos todas las variables auxiliares que se utilizaron para la realizacin del algoritmo.

Figura 106

Declaracin de las variables auxiliares

En la Figura 107 se observa el primer proceso llamado multi el cual permite la implementacin del concepto de estados, el cual es fundamental para poder emular un programa serie y as evitar el paralelismo mismo de VHDL. 67

Figura 107

Proceso multi que permite la programacin secuencial.

En la Figura 108, presentamos los primeros 2 estados, los cuales su nica funcin es asignar a ciertas variables, los valores que sern multiplicados.

Figura 108

Estados que permiten guarda los valores de los operandos.

A partir del estado 3, es cuando se empieza a tomar las decisiones sobre, los cambios de niveles lgicos, que es el principio de ser del algoritmo de Booth. En donde si encuentra un cero seguido de un cero, implica solo desplazamientos, pero sin embargo si encuentra 1 despus de un 0, significa complementar, y si encuentra 0 despus de un 1 significa deja el nmero con su debido desplazamiento. Esto puede observarse en la Figura 109.

68

Figura 109

Realizacin del algoritmo de Booth

Este procedimiento se repite hasta que se hayan hecho todos anlisis de transicin de estados lgicos, para al final sumarse unos con otros, para as obtener el resultado final.

Resultados
Para corroborar el correcto funcionamiento del cdigo, se ejemplificara con la multiplicacin de dos nmeros. En al Figura 110, se presenta la implementacin del multiplicando, en este caso el numero 1010.

Figura 110 Implementacin del numero 1010.

Posteriormente en la Figura 111 se muestra la implementacin del segundo nmero (multiplicador), el cual es el 1011.

69

Figura 111 Implementacin del segundo numero 1011.

Como el multiplicador tiene un 1 en su MLB, eso indica hacer el complemento al multiplicando, sea pasa de ser 00001010 a 11110110, que es precisamente el numero que se aprecia en la Figura 112.

Figura 112 Complemento a 2 del numero 00001010.

Posteriormente se tiene como siguiente bit nuevamente un 1, lo que implica desplazamiento, en este caso el multiplicando se desplaza 2 posiciones, esto quiere decir que paso de ser 00001010 a 00101000 lo que se observa en la Figura 113.

70

Figura 113

Corrimiento del Multiplicando.

En el siguiente paso, tenemos nuevamente una transicin de 0 a 1, lo que implica 2 cosas, un corrimiento y despus del corrimiento aplicar el complemento a 2, es decir el nmero 00001010 paso a ser el 01010000 y luego se complemento a 2, quedando el nmero 10110000 que es en numero que se aprecia en la Figura 114.

Figura 114 Desplazamiento y complemento a 2.

71

Ahora existe una transicin de 1 a 0, lo que implica otro desplazamiento del numero 00001010, es decir, ahora tenemos el numero 10100000, que es el que apreciamos en la Figura 115.

Figura 115

Ultimo desplazamiento

Como ltimo paso, se tienen que sumar lo datos anteriormente desplazados y complementados, obtenindose as el nmero 01101110, que en decimal es el 110, que como podemos comprobar es el resultado de multiplicar 1010 que es 10 en decimal, y el 1011 es el 11 en decimal, que como resultado dan e numero 110. (Figura 116)

Figura 116

Resultado de la multiplicacin por el algoritmo de Booth.

72

Conclusiones

El algoritmo de Booth, resulta ser una herramienta muy importante en la realizacin de la multiplicacin binaria, sobre todo si el multiplicador, contiene gran cantidad de 1s 0s consecutivos, reducindose as en nmero de iteraciones, en cambio si existe un gran nmero de transiciones entres 1s y 0s, lo que hace a este algoritmo ineficiente en ese caso, por lo que se cre el Booth mejorado, que pretende solventar esta desventaja, por lo que a nuestro parecer es un buen algoritmo que puede ser ocupado en muchas aplicaciones, obtenindose resultados aceptables con respecto a tiempo e iteraciones.

73

Multiplicador paralelo de 4 bits

Fundamento terico

Multiplicador matricial paralelo.

La estructura de un multiplicador matricial sistlico se ilustra en la Figura 117. En la parte inferior de la figura se muestra un elemento para el clculo de un producto parcial (PP). A travs de la compuerta Y se realiza el producto de un bit del multiplicando (mi) por un bit del multiplicador (qi) lo que genera un producto parcial en la posicin (i j) de la matriz. Este producto parcial se suma con el producto parcial obtenido desde la etapa previa (bI) y con cualquier arrastre que se hubiese generado en dicha etapa (aI). El resultado tiene 2w bits y se lo obtiene en la parte inferior de la matriz (los w bits ms significativos) y a la derecha de la misma (los w bits menos significativos).

Figura 117

Multiplicador paralelo de matriz segmentada.

74

Desarrollo

Cdigo en VHDL

library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity multparalelo is Port ( int : in STD_LOGIC_VECTOR (3 downto 0); push : in STD_LOGIC; salida : out STD_LOGIC_VECTOR (7 downto 0)); end multparalelo; architecture paralelo of multparalelo is type edos is (e0,e1,e2,e3); signal edosp,edosf:edos; signal min:std_logic:='0'; signal q:std_logic_vector(3 downto 0):="0000"; signal m:std_logic_vector(3 downto 0):="0000"; signal suma:std_logic_vector(19 downto 0):="00000000000000000000"; signal c:std_logic_vector(19 downto 0):="00000000000000000000"; begin process(push)begin if(push'event and push='1') then edosp<=edosf; end if; end process;

process(int)begin case edosp is when e0 => m(3 downto 0)<=int; salida(3 downto 0)<=int; salida(7 downto 4)<="0000"; edosf<=e1;

75

when e1 =>

q(3 downto 0)<=int; salida(3 downto 0)<=int; edosf<=e2;

when e2 => ----------salida(0)

--------------------------------------------------------------------------suma(0)<=(min xor min) xor (m(0) and q(0));-----------c(0)<=(min and min) or ((m(0) and q(0)) and(min xor

min)); suma(1)<=(min xor min) xor (m(1) and q(0)); c(1)<=(min and min) or ((m(1) and q(0)) and(min xor min)); suma(2)<=(min xor min) xor (m(2) and q(0)); c(2)<=(min and min) or ((m(2) and q(0)) and(min xor min)); suma(3)<=(min xor min) xor (m(3) and q(0)); c(3)<=(min and min) or ((m(3) and q(0)) and(min xor min)); --------------------------------------------------------------------------suma(4)<=(c(0) xor suma(1)) xor (m(0) and q(1));----------------salida(1) c(4)<=(c(0) and suma(1)) or ((m(0) and q(1)) and(c(0) xor suma(1))); suma(5)<=(c(1) xor suma(2)) xor (m(1) and q(1)); c(5)<=(c(1) and suma(2)) or ((m(1) and q(1)) and(c(1) xor suma(2))); suma(6)<=(c(2) xor suma(3)) xor (m(2) and q(1)); c(6)<=(c(2) and suma(3)) or ((m(2) and q(1)) and(c(2) xor suma(3))); suma(7)<=(c(3) xor min) xor (m(3) and q(1)); c(7)<=(c(3) and min) or ((m(3) and q(1)) and(c(3) xor min)); --------------------------------------------------------------------------suma(8)<=(c(4) xor suma(5)) xor (m(0) and q(2));----------------salida(2) c(8)<=(c(4) and suma(5)) or ((m(0) and q(2)) and(c(4) xor suma(5))); suma(9)<=(c(5) xor suma(6)) xor (m(1) and q(2)); c(9)<=(c(5) and suma(6)) or ((m(1) and q(2)) and(c(5) xor suma(6)));

76

suma(10)<=(c(6) xor suma(7)) xor (m(2) and q(2)); c(10)<=(c(6) and suma(7)) or ((m(2) and q(2)) and(c(6) xor suma(7))); suma(11)<=(c(7) xor min) xor (m(3) and q(2)); c(11)<=(c(7) and min) or ((m(3) and q(2)) and(c(7) xor min)); --------------------------------------------------------------------------suma(12)<=(c(8) xor suma(9)) xor (m(0) and q(3));---------------salida(3) c(12)<=(c(8) and suma(9)) or ((m(0) and q(3)) and(c(8) xor suma(9))); suma(13)<=(c(9) xor suma(10)) xor (m(1) and q(3)); c(13)<=(c(9) and suma(10)) or ((m(1) and q(3)) and(c(9) xor suma(10))); suma(14)<=(c(10) xor suma(11)) xor (m(2) and q(3)); c(14)<=(c(10) and suma(11)) or ((m(2) and q(3)) and(c(10) xor suma(11))); suma(15)<=(c(11) xor min) xor (m(3) and q(3)); c(15)<=(c(11) and min) or ((m(3) and q(3)) and(c(11) xor min)); --------------------------------------------------------------------------suma(16)<=(c(12) xor suma(13)) xor (m(0) and min);--------------salida(4) suma(17)<=(c(13) xor suma(14)) xor (m(1) and min);--------------salida(5) suma(18)<=(c(14) xor suma(15)) xor (m(2) and min);--------------salida(6) suma(19)<=(c(15) xor min) xor (m(3) and min);-------------------salida(7) edosf<=e3;

when e3 =>

salida(0)<=suma(0); salida(1)<=suma(4); salida(2)<=suma(8); salida(3)<=suma(12); salida(4)<=suma(16); salida(5)<=suma(17); salida(6)<=suma(18);

77

salida(7)<=suma(19);

edosf<=e0;

end case; end process; end paralelo; --Asignacin de pines de entradas y salidas. NET "int[0]" LOC = P11; NET "int[1]" LOC = L3; NET "int[2]" LOC = K3; NET "int[3]" LOC = B4; NET "push" LOC = A7; NET "salida[0]" LOC = M5; NET "salida[1]" LOC = M11; NET "salida[2]" LOC = P7; NET "salida[3]" LOC = P6; NET "salida[4]" LOC = N5; NET "salida[5]" LOC = N4; NET "salida[6]" LOC = P4; NET "salida[7]" LOC = G1;

Resultados
Ejemplos. Se prob nuestro programa y los resultados los describiremos a continuacin. Se ingresan 2 multiplicaciones. En la Figura 118 se ingresa el primer dato que es 00000110 que en decimal es 6. A continuacin en la Figura 119 se ingresa el segundo dato que es 00001010 que en decimal es 10. Finalmente en la

Figura 120 se muestra el resultado de la multiplicacin que es 00111100 que en decimal es 60. Se
verifica que hace correctamente la multiplicacin.

78

Figura 118 Primer dato a multiplicar.

Figura 119 Segundo dato a multiplicar.

Figura 120 Resultado de la multiplicacin.

Finalmente en la Figura 121 se ingresa el primer dato que es 00001111 que en decimal es 15. A continuacin en la Figura 122 se ingresa el segundo dato que es 00001111 que en decimal es 15. Finalmente en la Figura 123 se muestra el resultado de la multiplicacin que es 11100001 que en decimal es 225. Se verifica que opera correctamente la multiplicacin.

Figura 121 Primer dato a multiplicar.

79

Figura 122 Segundo dato a multiplicar.

Figura 123 Resultado de la multiplicacin.

Conclusiones
Tras la verificacin de esta prctica se realiz el multiplicador matricial paralelo, el cual de manera inmediata ingresando los datos nos entrega el resultado. Este multiplicador fue ms sencillo su programacin comparndolo con la multiplicacin serie debido a que al estar programando en paralelo, algo en serie es mucho ms complejo.

80

Referencias
[1] Tanembaum, Andrew S., Organizacin de computadoras. Un enfoque estructurado. Murdocca, J. Miles, Principios de arquitectura de computadoras. Stallings, William, Arquitectura de Computadoras.
http://www.emezeta.com/articulos/multiplicacion-algoritmo-de-booth http://www.monografias.com/trabajos4/vco/vco.shtm http://www.hispavila.com/3ds/lecciones/lecc8.html

[2]

[3]

[4] [5] [6]

81