Multiplicador de 3 bits x 3 bits en la GAL

Multiplicador Binario

La multiplicación de dos números binarios se hace con papel y lápiz por sumas sucesivas y
corrimientos. Este proceso se ilustra de mejor manera con un ejemplo numérico. Vamos a
multiplicar los dos números binarios 11011 y 10110

27 11011 multiplicando
22 10110 multiplicador
._____.
00000
11011
11011
00000
11011
.____________
594 1001010010

El proceso consiste en observar los bits sucesivos del multiplicador, empezando con el bit menos
significativo. Si tal bit es 1 el multiplicando se copia abajo. En caso contrario los 0s se copian
abajo. Los números que se copian abajo se corren una posición a la izquierda del número previo.
Al final, los números se adicionan y sus sumas forman el producto, como se hace para el caso
decimal que aprendimos desde la infancia. Obsérvese, que el producto de dos números binarios
de n bits puede ser hasta 2n bits de largo.

Cuando el proceso anterior se implementa en hardware digital resulta conveniente

cambiar el proceso. Primero, en vez de proporcionar circuitos lógicos para almacenar y sumar al
mismo tiempo tantos números binarios como 1s existan en el multiplicador, es mejor diseñar
circuitos para sumar dos números binarios y acumular en forma sucesiva los productos parciales
en un registro de tamaño conveniente. Segundo, en lugar de correr el producto parcial a la
izquierda éste se corre hacia la derecha lo cual resulta en dejar el producto parcial y el
multiplicando en las posiciones relativas necesarias. Tercero, cuando el bit correspondiente del
multiplicador es 0, no hay necesidad de sumar todos los ceros al producto, ya que esto no altera
su valor.

Especificación del Proyecto

Se desea usar una GAL para multiplicar dos números de tres bits cada uno. El primer número al
que designamos con A sólo puede tomar los valores de 0 a 5, mientras que el segundo número
varía entre 0 y 7. La salida será de seis bits, pues el producto máximo es 35, que requiere de seis
bits para su representación.

Método del Diseño

Se empleará una tabla de verdad con condiciones “no importa”, misma que se define de manera
compacta, según ilustra la figura 1. El diseño es puramente combinatorio.

Profr. S. Saucedo 1 ICE/2007

MODULE prod3

TITLE 'Producto de 3 bits x 3 bits'

X = .x.; " para decir no importa (irrelevante)

" entradas
A2..A0 PIN 1..3;
B2..B0 PIN 4..6;
" SALIDAS
P5..P0 PIN 14..19 ISTYPE 'COM';

A = [A2..A0]; " A < 6

B = [B2..B0]; " B = 0 a 7
P = [P5..P0];
@DCSET " Tomar como irrelevantes las condiciones no dadas
truth_table
([A2, A1, A0, B2, B1, B0]->[P5, P4, P3, P2, P1, P0])
[ 0, 0, 0, X, X, X]->[ 0, 0, 0, 0, 0, 0];
[ X, X, X, 0, 0, 0]->[ 0, 0, 0, 0, 0, 0];
[ 0, 0, 1, 0, 0, 1]->[ 0, 0, 0, 0, 0, 1];
[ 0, 0, 1, 0, 1, 0]->[ 0, 0, 0, 0, 1, 0];
[ 0, 0, 1, 0, 1, 1]->[ 0, 0, 0, 0, 1, 1];
[ 0, 0, 1, 1, 0, 0]->[ 0, 0, 0, 1, 0, 0];
[ 0, 0, 1, 1, 0, 1]->[ 0, 0, 0, 1, 0, 1];
[ 0, 0, 1, 1, 1, 0]->[ 0, 0, 0, 1, 1, 0];
[ 0, 0, 1, 1, 1, 1]->[ 0, 0, 0, 1, 1, 1];
[ 0, 1, 0, 0, 0, 1]->[ 0, 0, 0, 0, 1, 0];
[ 0, 1, 0, 0, 1, 0]->[ 0, 0, 0, 1, 0, 0];
[ 0, 1, 0, 0, 1, 1]->[ 0, 0, 0, 1, 1, 0];
[ 0, 1, 0, 1, 0, 0]->[ 0, 0, 1, 0, 0, 0];
[ 0, 1, 0, 1, 0, 1]->[ 0, 0, 1, 0, 1, 0];
[ 0, 1, 0, 1, 1, 0]->[ 0, 0, 1, 1, 0, 0];
[ 0, 1, 0, 1, 1, 1]->[ 0, 0, 1, 1, 1, 0];

[ 0, 1, 1, 0, 0, 1]->[ 0, 0, 0, 0, 1, 1];
[ 0, 1, 1, 0, 1, 0]->[ 0, 0, 0, 1, 1, 0];
[ 0, 1, 1, 0, 1, 1]->[ 0, 0, 1, 0, 0, 1];
[ 0, 1, 1, 1, 0, 0]->[ 0, 0, 1, 1, 0, 0];
[ 0, 1, 1, 1, 0, 1]->[ 0, 0, 1, 1, 1, 1];
[ 0, 1, 1, 1, 1, 0]->[ 0, 1, 0, 0, 1, 0];
[ 0, 1, 1, 1, 1, 1]->[ 0, 1, 0, 1, 0, 1]; “ 3x7 = 21

[ 1, 0, 0, 0, 0, 1]->[ 0, 0, 0, 1, 0, 0];
[ 1, 0, 0, 0, 1, 0]->[ 0, 0, 1, 0, 0, 0];
[ 1, 0, 0, 0, 1, 1]->[ 0, 0, 1, 1, 0, 0];
[ 1, 0, 0, 1, 0, 0]->[ 0, 1, 0, 0, 0, 0];
[ 1, 0, 0, 1, 0, 1]->[ 0, 1, 0, 1, 0, 0];
[ 1, 0, 0, 1, 1, 0]->[ 0, 1, 1, 0, 0, 0];
[ 1, 0, 0, 1, 1, 1]->[ 0, 1, 1, 1, 0, 0];
[ 1, 0, 1, 0, 0, 1]->[ 0, 0, 0, 1, 0, 1];
[ 1, 0, 1, 0, 1, 0]->[ 0, 0, 1, 0, 1, 0];
[ 1, 0, 1, 0, 1, 1]->[ 0, 0, 1, 1, 1, 1]; “ 5x3 = 15
[ 1, 0, 1, 1, 0, 0]->[ 0, 1, 0, 1, 0, 0];
[ 1, 0, 1, 1, 0, 1]->[ 0, 1, 1, 0, 0, 1];
[ 1, 0, 1, 1, 1, 0]->[ 0, 1, 1, 1, 1, 0];
[ 1, 0, 1, 1, 1, 1]->[ 1, 0, 0, 0, 1, 1];
Figura 1 Listado del módulo para el multiplicador (parte inicial)

Profr. S. Saucedo 2 ICE/2007

" Vectores para la simulacion
TEST_VECTORS
([A,B] -> P)
[0,6] -> 0;
[5,0] -> 0;
[1,4] -> 4;
[3,3] -> 9;
[2,5] -> 10;
[3,4] -> 12;
[2,7] -> 14;
[4,5] -> 20;

[5,5] -> 25;

[3,7] -> 21;
[4,6] -> 24;
[5,6] -> 30;

END
Figura 2 Vectores de prueba para la simulación (parte final del archivo fuente)

Asignación de Pines

La figura 3 exhibe como el software de desarrollo de Lattice asigna las patitas del integrado.

Figura 3 Distribución de pines de la GAL22V10

Profr. S. Saucedo 3 ICE/2007

Simulación con los Vectores de Prueba

La figura 4 ilustra el diagrama temporal de aplicar los vectores de prueba en el JEDEC grabado.

Figura 4 Respuesta en el tiempo de los vectores propuestos.

Para el diseño secuencial de un producto ver el libro Diseño Digital de Morris Mano; ed.
Prentice-Hall, 1987, pp 337-340.

Profr. S. Saucedo 4 ICE/2007