1

Diseo modular con Verilog.

1. Especificacin.
Se desea disear un sistema combinacional que tenga como entrada una palabra binaria de 16
bits y que genere una salida de 16 bits, la cual debe tener igual nmero de unos que la palabra
de entrada, pero justificados a la izquierda.
Ejemplo:
Palabra de entrada
0101010000110011
0100000000111111
0000000000000001

Palabra de salida
1111111000000000
1111111000000000
1000000000000000

2. Diseo bruta forza.

Desde un punto de vista combinacional se tienen que realizar 16 diseos, para cada una de las
funciones de salida, a partir de tablas de verdad que tienen 65536 renglones cada una.
Con el apoyo de programas puede generarse la tabla de verdad en formato .pla. El que puede ser
procesado por el minimizador espresso.
El siguiente programa en C, genera la tabla de verdad.
#include <stdio.h>
#define DIGITOS 16
static char bufc[DIGITOS + 1];
char * prtint(int i, int largo)
//imprime en binario
{ int j, k=1;
char *p = bufc;
for (j=15; j>=0; j--) if((k<<j)&i) *p++='1'; else *p++='0';
return (bufc+DIGITOS-largo);
}
void prtstr(char * p)
{
while(*p) putchar(*p++);
}
//La siguente rutina puede modificarse para generar otras tablas de verdad
void prtinfile(FILE * stream)
{ unsigned int j,t,s;
Profesor Leopoldo Silva Bijit

19-01-2010

Sistemas Digitales
unsigned long int i;
fprintf(stream, "%s\n", "#Unos en palabra de 16 bits.");
fprintf(stream, "%s\n", ".i 16");
fprintf(stream, "%s\n", ".o 16");
fprintf(stream, "%s\n", ".ilb e15 e14 e13 e12 e11 e10 e9 e8 e7 e6 e5 e4 e3 e2 e1 e0");
fprintf(stream, "%s\n", ".ob s15 s14 s13 s12 s11 s10 s9 s8 s7 s6 s5 s4 s3 s2 s1 s0");
for(i=0;i<65536L;i++) //2^16
{ fprintf(stream, "%s\t", prtint(i, 16));
t=i;s=0;
for(j=0;j<16;j++)
{ if (t&1) {s=s>>1;s=s|0x8000; }
t=t>>1;
}
fprintf(stream, "%s\n", prtint(s,16));
printf("%ld \n",i); //comenta avance en consola
}
fprintf(stream, "%s\n", ".e");

}
int escribe_archivo(void)
{ FILE *stream;
/* Abre stream para escritura, en modo texto. Puede elegirse el nombre del archivo de salida*/
if ((stream = fopen("unos.pla", "w")) == NULL) {
fprintf(stderr, "No pudo abrir archivo de salida.\n");
return 1;
}
prtinfile(stream);
fclose(stream); /* close stream */
return 0;
}
int main(void)
{
escribe_archivo();
return 0;
}

El archivo generado tiene un peso de ms de 2MB. Se da un listado del comienzo y del final del
archivo.
#Unos en palabra de 16 bits.
.i 16
.o 16
.ilb e15 e14 e13 e12 e11 e10 e9 e8 e7 e6 e5 e4 e3 e2 e1 e0
.ob s15 s14 s13 s12 s11 s10 s9 s8 s7 s6 s5 s4 s3 s2 s1 s0
0000000000000000
0000000000000000
0000000000000001
1000000000000000
0000000000000010
1000000000000000
0000000000000011
1100000000000000
Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.
0000000000000100
0000000000000101
0000000000000110
0000000000000111

1111111111110111
1111111111111000
1111111111111001
1111111111111010
1111111111111011
1111111111111100
1111111111111101
1111111111111110
1111111111111111
.e

3
1000000000000000
1100000000000000
1100000000000000
1110000000000000
1111111111111110
1111111111111000
1111111111111100
1111111111111100
1111111111111110
1111111111111100
1111111111111110
1111111111111110
1111111111111111

Si el archivo anterior se procesa con espresso, con el siguiente comando:

Espresso Dexact oeqntott unos.pla > unos.eqn
Se obtiene un listado de las ecuaciones minimizadas de diseo, en dos niveles, en formato eqn.
Se muestran slo algunas de las ecuaciones. El archivo con las expresiones tiene un peso de
ms de 2 MB.
#Unos en palabra de 16 bits.
s15 = (e0) | (e1) | (e2) | (e3) | (e4) | (e5) | (e6) | (e7) | (e8) | (e9) | (
e10) | (e11) | (e12) | (e13) | (e14) | (e15);
s14 = (e1&e0) | (e2&e0) | (e3&e0) | (e4&e0) | (e5&e0) | (e6&e0) | (e7&e0) | (
e8&e0) | (e9&e0) | (e10&e0) | (e11&e0) | (e12&e0) | (e13&e0) | (e14
&e0) | (e15&e0) | (e2&e1) | (e3&e1) | (e4&e1) | (e5&e1) | (e6&e1) | (
e7&e1) | (e8&e1) | (e9&e1) | (e10&e1) | (e11&e1) | (e12&e1) | (e13&e1) | (
e14&e1) | (e15&e1) | (e3&e2) | (e4&e2) | (e5&e2) | (e6&e2) | (e7&e2) | (
e8&e2) | (e9&e2) | (e10&e2) | (e11&e2) | (e12&e2) | (e13&e2) | (e14
&e2) | (e15&e2) | (e4&e3) | (e5&e3) | (e6&e3) | (e7&e3) | (e8&e3) | (
e9&e3) | (e10&e3) | (e11&e3) | (e12&e3) | (e13&e3) | (e14&e3) | (e15
&e3) | (e5&e4) | (e6&e4) | (e7&e4) | (e8&e4) | (e9&e4) | (e10&e4) | (
e11&e4) | (e12&e4) | (e13&e4) | (e14&e4) | (e15&e4) | (e6&e5) | (e7
&e5) | (e8&e5) | (e9&e5) | (e10&e5) | (e11&e5) | (e12&e5) | (e13&e5) | (
e14&e5) | (e15&e5) | (e7&e6) | (e8&e6) | (e9&e6) | (e10&e6) | (e11&e6) | (
e12&e6) | (e13&e6) | (e14&e6) | (e15&e6) | (e8&e7) | (e9&e7) | (e10
&e7) | (e11&e7) | (e12&e7) | (e13&e7) | (e14&e7) | (e15&e7) | (e9&e8) | (
e10&e8) | (e11&e8) | (e12&e8) | (e13&e8) | (e14&e8) | (e15&e8) | (
e10&e9) | (e11&e9) | (e12&e9) | (e13&e9) | (e14&e9) | (e15&e9) | (
e11&e10) | (e12&e10) | (e13&e10) | (e14&e10) | (e15&e10) | (e12&e11) | (
e13&e11) | (e14&e11) | (e15&e11) | (e13&e12) | (e14&e12) | (e15&e12) | (
e14&e13) | (e15&e13) | (e15&e14);
.

Profesor Leopoldo Silva Bijit

19-01-2010

Sistemas Digitales

s0 = (e15&e14&e13&e12&e11&e10&e9&e8&e7&e6&e5&e4&e3&e2&e1&e0);

El formato eqn, es fcilmente traducido a verilog, basta encabezar y terminar el mdulo; adems
de preceder con assign a las ecuaciones de salida, daremos ejemplo de esto ms adelante. En
caso de ocurrir seales negadas, stas son precedidas con el smbolo !, en el formato eqn; el cual
debe reemplazarse globalmente con el smbolo de la negacin de verilog: ~.
El diseo en dos niveles tiene un costo demasiado elevado.

3. Diseo modular.
La estrategia: Dividir para vencer requiere conceptualizar mdulos que permitan
descomponer el problema en otros menos complejos.
Si se conociera el nmero de unos de la palabra de entrada, mediante una funcin
combinacional es sencillo generar el formato de salida. Veremos esto luego, cuando estudiemos
en detalle el mdulo denominado TablaSuma, en el diagrama de la Figura 1.
Para determinar el nmero de unos contenidos en la palabra de entrada se requiere un mdulo
combinacional que entregue como salida el nmero de unos de una palabra de n bits; este diseo
es sencillo de realizar si n es pequeo. Se requieren 5 bits de salida para contener el binario
10000 que equivale a la mxima cuenta de unos, que es 16 decimal. El mdulo SumaUnos es
combinacionalmente complejo de disear, ya que se requieren 5 tablas de verdad de 65536
renglones. Lo cual conduce a la necesidad de descomponer la entrada en partes.
Entrada 15..0
15..0
SumaUnos
4..0
TablaSuma
15..0
Salida 15..0

Figura 1. Diagrama en bloques.

Si concebimos un mdulo que determine los unos en una palabra de 4 bits, para su diseo se
tiene una tabla de verdad de 16 renglones y tres bits de salida, ya que el mximo nmero de
unos es 4, y ste se representa en binario mediante: 100.
Se requieren 4 de estos mdulos; cuyas entradas se conectan a cuatro grupos de 4 bits de la
entrada. Si el mdulo se denomina cuenta1, el diagrama de la Figura 2, ilustra la
descomposicin:

Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.

5
Entrada 15..0
15..12
11..8
7..4
3..0
cuenta1 cuenta1 cuenta1 cuenta1
12 2..0 12 2..0 12 2..0 12 2..0
suma1
suma1
3..0
3..0
Sumador5
4..0
TablaSuma

Salida 15..0

Figura 2 Detalle de mdulos

Se han agregado dos mdulos suma1, que suman dos de las tres salidas binarias de dos mdulos
cuenta1; ste es un sumador, suma1 en el diagrama de la Figura 2, en el que los operandos
llegan a un mximo de 4, en binario. Por lo tanto su salida debe expresarse en 4 bits para poder
representar la suma mxima con valor 8 decimal, que equivale a 1000 en binario.
Es preciso agregar un sumador adicional, el sumador5, con entradas con valores mximos
iguales a 8 y salida con valor mximo 16, este sumador requiere 5 bits de salida.
Tambin es posible descomponer la entrada en grupos de a dos, lo cual requiere 8 sumadores de
dos bits de entrada y dos de salida. Luego mediante 4 sumadores con cuatro entradas y salidas
de tres bits, se alimentan dos sumadores de 6 entradas y 4 salidas (mdulo suma1, en el
diagrama), para finalmente un sumador de 8 bits de entrada y 5 de salida (sumador5, en el
diagrama). Esto lleva a un diseo en ms niveles. Un esquema de esta solucin se muestra en la
Figura 5.
De esta forma hemos descompuesto un problema de grandes dimensiones, en el diseo de
cuatro mdulos ms sencillos. Algunos de los subproblemas, podran disearse con mtodos
para papel y lpiz. Las tablas de verdad de todos ellos, pueden generarse mediante sencillos
programas escritos en C, lo cual permite automatizar el diseo. Los mdulos basados en
comandos assign son siempre sintetizables.
La estructura concatenada de los mdulos implica el aumento de los niveles del diseo, y la
menor velocidad en la generacin de la salida. Se economiza en nmero de compuertas, pero se
degrada el funcionamiento temporal.
3.1. Mdulo cuenta1.
Queda especificado por la siguiente tabla de verdad, expresada en formato pla.

Profesor Leopoldo Silva Bijit

19-01-2010

Sistemas Digitales

#cuenta unos en palabra de 4 bits.

.i 4
.o 3
.ilb e3 e2 e1 e0
.ob s2 s1 s0
0001
001
0010
001
0011
010
0100
001
0101
010
0110
010
0111
011
1000
001
1001
010
1010
010
1011
011
1100
010
1101
011
1110
011
1111
100
.e

Es sencillo modificar el programa en C, visto al inicio, para generar automticamente la tabla

anterior.
Minimizado con espresso, resultan las ecuaciones.
#cuenta unos en palabra de 4 bits.
s2 = (e3&e2&e1&e0);
s1 = (!e2&e1&e0) | (!e3&e2&e1&e0) | (e2&!e1&e0) | (e3&!e1&e0) | (e2&e1&!e0) |
(e3&e1&!e0) | (e3&e2&!e0);
s0 = (!e3&!e2&!e1&e0) | (!e3&!e2&e1&!e0) | (!e3&e2&!e1&!e0) | (e3&!e2&!e1&!e0) |
(e3&!e2&e1&e0) | (e3&e2&!e1&e0) | (e3&e2&e1&!e0) | (!e3&e2&e1&e0);

Formato que puede traducirse al siguiente mdulo verilog, empleando un editor de texto:
//cuenta unos en palabra de 4 bits.
module cuenta1(s2,s1,s0,e3,e2,e1,e0);
input e3,e2,e1,e0;
output s2,s1,s0;
assign s2 = (e3&e2&e1&e0);
assign s1 = (~e2&e1&e0) | (~e3&e2&e1&e0) | (e2&~e1&e0) |
(e3&~e1&e0) |(e2&e1&~e0) | (e3&e1&~e0) | (e3&e2&~e0);
assign s0 = (~e3&~e2&~e1&e0) | (~e3&~e2&e1&~e0) | (~e3&e2&~e1&~e0) |
(e3&~e2&~e1&~e0) | (e3&~e2&e1&e0) |
(e3&e2&~e1&e0) | (e3&e2&e1&~e0) | (~e3&e2&e1&e0);
endmodule

Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.

3.2. Mdulo suma1.

#suma palabras de 3 bits. Operandos con valor mximo 4
.i 6
.o 4
.ilb a2 a1 a0 b2 b1 b0
.ob su3 su2 su1 su0
000000 0000
000001 0001
000010 0010
000011 0011
000100 0100
001000 0001
001001 0010
001010 0011
001011 0100
001100 0101
010000 0010
010001 0011
010010 0100
010011 0101
010100 0110
011000 0011
011001 0100
011010 0101
011011 0110
011100 0111
100000 0100
100001 0101
100010 0110
100011 0111
100100 1000
.e

Debe notarse que solamente se especifican los unos de la funcin. Las combinaciones que no
pueden presentarse se tratan como condiciones superfluas.
Con el comando: espresso Dexact oeqntott suma1.pla > suma1.eqn
Se obtienen las ecuaciones minimizadas en dos niveles:
#suma palabras de 3 bits. Operandos con valor maximo 4
su3 = (a2&!a1&!a0&b2&!b1&!b0);
su2 = (!a2&a0&!b2&b1&b0) | (!a2&a1&a0&!b2&b0) | (!a2&b2&!b1&!b0) |
(a2&!a1&!a0&!b2) | (!a2&a1&!b2&b1);
Profesor Leopoldo Silva Bijit

19-01-2010

Sistemas Digitales

su1 = (!a2&a1&a0&!b2&b1&b0) | (!a2&!a1&a0&!b2&!b1&b0) | (!a2&!a1&!b2&b1&!b0) |

(!a2&a1&!a0&!b2&!b1) | (!a2&a1&!b1&!b0) | (!a1&!a0&!b2&b1);
su0 = (!a2&a0&!b1&!b0) | (!a1&!a0&!b2&b0) | (!a2&a0&!b2&!b0) | (!a2&!a0 &!b2&b0);

Formato que puede traducirse al mdulo verilog:

//suma palabras de 3 bits. Operandos con valor mximo 4
module suma1(a2,a1,a0,b2,b1,b0,su3,su2,su1,su0);
input a2,a1,a0,b2,b1,b0;
output su3,su2,su1,su0;
assign su3 = (a2&~a1&~a0&b2&~b1&~b0);
assign su2 = (~a2&a0&~b2&b1&b0) | (~a2&a1&a0&~b2&b0) | (~a2&b2&~b1&~b0) |
(a2&~a1&~a0&~b2) | (~a2&a1&~b2&b1);
assign su1 = (~a2&a1&a0&~b2&b1&b0) | (~a2&~a1&a0&~b2&~b1&b0) |
(~a2&~a1&~b2&b1&~b0) | (~a2&a1&~a0&~b2&~b1) |
(~a2&a1&~b1&~b0) | (~a1&~a0&~b2&b1);
assign su0 = (~a2&a0&~b1&~b0) | (~a1&~a0&~b2&b0) | (~a2&a0&~b2&~b0) |
(~a2&~a0&~b2&b0);
endmodule
3.3. Mdulo suma5.
Para evitar errores en la generacin de la tabla de verdad, sta se genera mediante un programa.
Se muestra slo la funcin que genera la tabla, el resto de las funciones son similares a las vistas
en el programa que se ilustr al inicio.
void prtinfile(FILE * stream)
{ unsigned int i, j;
//encabezado archivo pla
fprintf(stream, "%s\n", "#Suma operandos enteros sin signo de 4 bits.");
fprintf(stream, "%s\n", ".i 8");
//6 cada operando
fprintf(stream, "%s\n", ".o 5");
for(i=0; i<9; i++)
//maximo operando en 4 bits = 8
{
for(j=0; j<9; j++)
{ fprintf(stream, "%s", prtint(i, 4));
fprintf(stream, "%s\t", prtint(j, 4)); //se separa con tab la entrada de la salida
fprintf(stream, "%s\n", prtint(i+j,5));
fprintf(stream, "%s\n", ".ilb a3 a2 a1 a0 b3 b2 b1 b0");
fprintf(stream, "%s\n", ".ob n4 n3 n2 n1 n0");
}
printf("%d \n",i); //comenta avance
}
fprintf(stream, "%s\n", ".e"); //fin de archivo formato pla
}
Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.

Una modificacin menor de la rutina anterior, permite generar la tabla de verdad de suma1.
La ejecucin del programa anterior, genera la tabla:
#Suma operandos enteros sin signo de 4 bits. Mximo operando 8
.i 8
.o 5
.ilb a3 a2 a1 a0 b3 b2 b1 b0
.ob n4 n3 n2 n1 n0
00000000
00000
00000001
00001
00000010
00010
00000011
00011
00000100
00100
00000101
00101
00000110
00110
00000111
00111
00001000
01000
00010000
00001
00010001
00010
00010010
00011
00010011
00100
00010100
00101
00010101
00110
00010110
00111
00010111
01000
00011000
01001
00100000
00010
00100001
00011
00100010
00100
00100011
00101
00100100
00110
00100101
00111
00100110
01000
00100111
01001
00101000
01010
00110000
00011
00110001
00100
00110010
00101
00110011
00110
00110100
00111
00110101
01000
00110110
01001
00110111
01010
00111000
01011
01000000
00100
01000001
00101
01000010
00110
01000011
00111
01000100
01000

Profesor Leopoldo Silva Bijit

19-01-2010

10
01000101
01000110
01000111
01001000
01010000
01010001
01010010
01010011
01010100
01010101
01010110
01010111
01011000
01100000
01100001
01100010
01100011
01100100
01100101
01100110
01100111
01101000
01110000
01110001
01110010
01110011
01110100
01110101
01110110
01110111
01111000
10000000
10000001
10000010
10000011
10000100
10000101
10000110
10000111
10001000
.e

Sistemas Digitales
01001
01010
01011
01100
00101
00110
00111
01000
01001
01010
01011
01100
01101
00110
00111
01000
01001
01010
01011
01100
01101
01110
00111
01000
01001
01010
01011
01100
01101
01110
01111
01000
01001
01010
01011
01100
01101
01110
01111
10000

La que procesada con espresso, obtiene las ecuaciones minimizadas en dos niveles:
#Suma operandos enteros sin signo de 4 bits.
n4 = (a3&!a2&!a1&!a0&b3&!b2&!b1&!b0);
n3 = (!a3&b3&!b2&!b1&!b0) | (a3&!a2&!a1&!a0&!b3) | (!a3&a0&!b3&b2&b1&b0) |
(!a3&a2&a0&!b3&b1&b0) | (!a3&a1&a0&!b3&b2&b0) | (!a3&a2&a1&a0&!b3&b0) |
( !a3&a1&!b3&b2&b1) | (!a3&a2&a1&!b3&b1) | (!a3&a2&!b3&b2);
Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.

11

n2 = (!a3&!a2&a0&!b3&!b2&b1&b0) | (!a3&a2&a0&!b3&b2&b1&b0) |
(!a3&!a2&a1&a0&!b3&!b2&b0) | (!a3&a2&a1&a0&!b3&b2&b0) |
(!a3&!a2&!b3&b2&!b1&!b0) | ( !a3&a2&!a1&!b3&!b2&!b0) |
(!a3&!a2&!a1&!b3&b2&!b0) | (!a3&a2&!a0&!b3&!b2&!b1) |
(!a3&!a2&!a0&!b3&b2&!b1) | (!a3&!a2&a1&!b3&!b2&b1) |
(!a3&a2&a1&!b3&b2&b1) | (!a3&a2&!a1&!a0&!b3&!b2) |
(!a3&a2&!a1&!b3&!b2&!b1) | ( !a3&!a2&!a1&!b3&b2&!b1) |
(!a3&a2&!b2&!b1&!b0) | (!a2&!a1&!a0&!b3&b2);
n1 = (!a3&a1&a0&!b3&b1&b0) | (!a3&!a1&a0&!b3&!b1&b0) | (!a3&a1&!b2&!b1&!b0) |
(!a2&!a1&!a0&!b3&b1) | (!a3&a1&!b3&!b1&!b0) | (!a3&!a1&!b3&b1&!b0) |
(!a3&a1&!a0&!b3&!b1) | (!a3&!a1&!a0&!b3&b1);
n0 = (!a3&a0&!b2&!b1&!b0) | (!a2&!a1&!a0&!b3&b0) | (!a3&a0&!b3&!b0) |
(!a3&!a0&!b3&b0);
El que permite escribir el mdulo verilog:
//Suma operandos enteros sin signo de 4 bits. Mximo operando 8
module sumadorU5(a3,a2,a1,a0,b3,b2,b1,b0,n4,n3,n2,n1,n0);
input a3,a2,a1,a0,b3,b2,b1,b0;
output n4,n3,n2,n1,n0;
assign n4 = (a3&~a2&~a1&~a0&b3&~b2&~b1&~b0);
assign n3 = (~a3&b3&~b2&~b1&~b0) | (a3&~a2&~a1&~a0&~b3) |
(~a3&a0&~b3&b2&b1&b0) | (~a3&a2&a0&~b3&b1&b0) |
(~a3&a1&a0&~b3&b2&b0) | (~a3&a2&a1&a0&~b3&b0) |
(~a3&a1&~b3&b2&b1) | (~a3&a2&a1&~b3&b1) | (~a3&a2&~b3&b2);
assign n2 = (~a3&~a2&a0&~b3&~b2&b1&b0) | (~a3&a2&a0&~b3&b2&b1&b0) |
(~a3&~a2&a1&a0&~b3&~b2&b0) | (~a3&a2&a1&a0&~b3&b2&b0) |
(~a3&~a2&~b3&b2&~b1&~b0) | (~a3&a2&~a1&~b3&~b2&~b0) |
(~a3&~a2&~a1&~b3&b2&~b0) | (~a3&a2&~a0&~b3&~b2&~b1) |
(~a3&~a2&~a0&~b3&b2&~b1) | (~a3&~a2&a1&~b3&~b2&b1) |
(~a3&a2&a1&~b3&b2&b1) |(~a3&a2&~a1&~a0&~b3&~b2) |
(~a3&a2&~a1&~b3&~b2&~b1) | (~a3&~a2&~a1&~b3&b2&~b1) |
(~a3&a2&~b2&~b1&~b0) | (~a2&~a1&~a0&~b3&b2);
assign n1 = (~a3&a1&a0&~b3&b1&b0) | (~a3&~a1&a0&~b3&~b1&b0) |
(~a3&a1&~b2&~b1&~b0) | (~a2&~a1&~a0&~b3&b1) |
(~a3&a1&~b3&~b1&~b0) | (~a3&~a1&~b3&b1&~b0) |
(~a3&a1&~a0&~b3&~b1) | (~a3&~a1&~a0&~b3&b1);
assign n0 = (~a3&a0&~b2&~b1&~b0) | (~a2&~a1&~a0&~b3&b0) |
(~a3&a0&~b3&~b0) | (~a3&~a0&~b3&b0);
endmodule

Profesor Leopoldo Silva Bijit

19-01-2010

12

Sistemas Digitales

3.4. Mdulo tablasuma.

#convierte binarios de 0 a 16 en unos justificados a la derecha en ancho de 16 bits
.i 5
.o 16
.ilb n4 n3 n2 n1 n0
.ob sa15 sa14 sa13 sa12 sa11 sa10 sa09 sa08 sa07 sa06 sa05 sa04 sa03 sa02 sa01 sa00
00000 0000000000000000
00001 1000000000000000
00010 1100000000000000
00011 1110000000000000
00100 1111000000000000
00101 1111100000000000
00110 1111110000000000
00111 1111111000000000
01000 1111111100000000
01001 1111111110000000
01010 1111111111000000
01011 1111111111100000
01100 1111111111110000
01101 1111111111111000
01110 1111111111111100
01111 1111111111111110
10000 1111111111111111
.e

Las ecuaciones minimizadas:

#convierte binarios de 0 a 16 en unos justificados a la derecha en ancho de 16 bits
sa15 = (n4&!n3&!n2&!n1&!n0) | (!n4&n0) | (!n4&n1) | (!n4&n2) | (!n4&n3);
sa14 = (n4&!n3&!n2&!n1&!n0) | (!n4&n1) | (!n4&n2) | (!n4&n3);
sa13 = (n4&!n3&!n2&!n1&!n0) | (!n4&n1&n0) | (!n4&n2) | (!n4&n3);
sa12 = (n4&!n3&!n2&!n1&!n0) | (!n4&n2) | (!n4&n3);
sa11 = (n4&!n3&!n2&!n1&!n0) | (!n4&n2&n0) | (!n4&n2&n1) | (!n4&n3);
sa10 = (n4&!n3&!n2&!n1&!n0) | (!n4&n2&n1) | (!n4&n3);
sa09 = (n4&!n3&!n2&!n1&!n0) | (!n4&n2&n1&n0) | (!n4&n3);
sa08 = (n4&!n3&!n2&!n1&!n0) | (!n4&n3);
sa07 = (n4&!n3&!n2&!n1&!n0) | (!n4&n3&n0) | (!n4&n3&n1) | (!n4&n3&n2);
sa06 = (n4&!n3&!n2&!n1&!n0) | (!n4&n3&n1) | (!n4&n3&n2);
sa05 = (n4&!n3&!n2&!n1&!n0) | (!n4&n3&n1&n0) | (!n4&n3&n2);
sa04 = (n4&!n3&!n2&!n1&!n0) | (!n4&n3&n2);
sa03 = (n4&!n3&!n2&!n1&!n0) | (!n4&n3&n2&n0) | (!n4&n3&n2&n1);
sa02 = (n4&!n3&!n2&!n1&!n0) | (!n4&n3&n2&n1);
sa01 = (!n4&n3&n2&n1&n0) | (n4&!n3&!n2&!n1&!n0);
sa00 = (n4&!n3&!n2&!n1&!n0);

Traducida a verilog:
//convierte binarios de 0 a 16 en unos justificados a la derecha en ancho de 16 bits

Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.

13

module suma1(n4,n3,n2,n1,n0,
sa15,sa14,sa13,sa12,sa11,sa10,sa09,sa08,
sa07,sa06,sa05,sa04,sa03,sa02,sa01,sa00);
input n4,n3,n2,n1,n0;
output sa15,sa14,sa13,sa12,sa11,sa10,sa09,sa08,sa07,sa06,sa05,sa04,sa03,sa02,sa01,sa00;
assign sa15 = (n4&~n3&~n2&~n1&~n0) | (~n4&n0) | (~n4&n1) | (~n4&n2) | (~n4&n3);
assign sa14 = (n4&~n3&~n2&~n1&~n0) | (~n4&n1) | (~n4&n2) | (~n4&n3);
assign sa13 = (n4&~n3&~n2&~n1&~n0) | (~n4&n1&n0) | (~n4&n2) | (~n4&n3);
assign sa12 = (n4&~n3&~n2&~n1&~n0) | (~n4&n2) | (~n4&n3);
assign sa11 = (n4&~n3&~n2&~n1&~n0) | (~n4&n2&n0) | (~n4&n2&n1) | (~n4&n3);
assign sa10 = (n4&~n3&~n2&~n1&~n0) | (~n4&n2&n1) | (~n4&n3);
assign sa09 = (n4&~n3&~n2&~n1&~n0) | (~n4&n2&n1&n0) | (~n4&n3);
assign sa08 = (n4&~n3&~n2&~n1&~n0) | (~n4&n3);
assign sa07 = (n4&~n3&~n2&~n1&~n0) | (~n4&n3&n0) | (~n4&n3&n1) | (~n4&n3&n2);
assign sa06 = (n4&~n3&~n2&~n1&~n0) | (~n4&n3&n1) | (~n4&n3&n2);
assign sa05 = (n4&~n3&~n2&~n1&~n0) | (~n4&n3&n1&n0) | (~n4&n3&n2);
assign sa04 = (n4&~n3&~n2&~n1&~n0) | (~n4&n3&n2);
assign sa03 = (n4&~n3&~n2&~n1&~n0) | (~n4&n3&n2&n0) | (~n4&n3&n2&n1);
assign sa02 = (n4&~n3&~n2&~n1&~n0) | (~n4&n3&n2&n1);
assign sa01 = (~n4&n3&n2&n1&n0) | (n4&~n3&~n2&~n1&~n0);
assign sa00 = (n4&~n3&~n2&~n1&~n0);
endmodule

3.5. Instanciacin de mdulos.

El en diagrama de la Figura 3, se definen los nombres de las instancias de los mdulos. Tambin
se han definido tres conjuntos de alambres para efectuar las conexiones entre los mdulos.
Entrada 15..0
15..12
11..8
7..4
3..0
cuenta13 cuenta12
cuenta11 cuenta10
12
11..9
8..6
5..3 12 2..0 sum
suma11
suma10
7..4
3..0
sum2
Sumador5
4..0
sum3
Tabla

Salida 15..0

Figura 3. Interconexin de mdulos

El cdigo verilog para el armado del conjunto es:
Profesor Leopoldo Silva Bijit

19-01-2010

14

Sistemas Digitales

`timescale 1ns / 1ps

module cta1(entrada, salida);
input [15:0] entrada;
output [15:0] salida;
wire sum[11:0];
wire sum2[7:0];
wire sum3[4:0];
scuenta1 cuenta10(sum[2],sum[1],sum[0],entrada[3],entrada[2],entrada[1],entrada[0]);
scuenta1 cuenta11(sum[5],sum[4],sum[3],entrada[7],entrada[6],entrada[5],entrada[4]);
scuenta1 cuenta12(sum[8],sum[7],sum[6],entrada[11],entrada[10],entrada[9],entrada[8]);
scuenta1 cuenta13(sum[11],sum[10],sum[9],entrada[15],entrada[14],entrada[13],entrada[12]);
suma1 suma10(sum[2],sum[1],sum[0],sum[5],sum[4],sum[3],
sum2[3],sum2[2],sum2[1],sum2[0]);
suma1 suma11(sum[8],sum[7],sum[6],sum[11],sum[10],sum[9],
sum2[7],sum2[6],sum2[5],sum2[4]);
sumadorU5 sumador5( sum2[3],sum2[2],sum2[1],sum2[0],
sum2[7],sum2[6],sum2[5],sum2[4],
sum3[4],sum3[3],sum3[2],sum3[1],sum3[0]);
tablasuma tabla(sum3[4],sum3[3],sum3[2],sum3[1],sum3[0],
salida[15],salida[14],salida[13],salida[12],salida[11],
salida[10],salida[9],salida[8],salida[7],salida[6],
salida[5],salida[4],salida[3],salida[2],salida[1],salida[0]);
endmodule
El diseo anterior fue minimizado en dos niveles para cada uno de los mdulos. Al ser
implementado en base a fpga, mediante la aplicacin, se obtienen los resmenes de ocupacin
de espacio y de velocidad.
3.6. Design Statistics
Cell Usage :
# BELS
: 83
#
LUT2
:5
#
LUT3
:8
#
LUT4
: 68
#
MUXF5
:2
# IO Buffers
: 32
#
IBUF
: 16
#
OBUF
: 16
====================================================================

Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.
Device utilization summary:
Selected Device : 3s400pq208-5
Number of Slices:
Number of 4 input LUTs:
Number of bonded IOBs:

15

46 out of 3584 1%
81 out of 7168 1%
32 out of 141 22%

3.7. Timing Summary:

Speed Grade: -5
Minimum period: No path found
Minimum input arrival time before clock: No path found
Maximum output required time after clock: No path found
Maximum combinational path delay: 21.247ns

4. Diseo abstracto.
La descripcin del problema, empleando verilog, permite describir lo que se desea realizar, en la
forma ms abstracta posible. En este caso el mdulo que suma los unos de la palabra es sencillo
de describir, y dejamos a la herramienta de sntesis que tome la iniciativa para descomponer el
problema en submdulos. Para la descripcin de la tabla de salida, empleamos una sentencia
case. Resulta:
module ctaunos(entrada, salida);
input [15:0] entrada;
output [15:0] salida;
reg [4:0] sumau;
reg [15:0] salida;
always @(*)
begin
sumau = entrada[15]+entrada[14]+entrada[13]+entrada[12]+
entrada[11]+entrada[10]+entrada[9] +entrada[8]+
entrada[7] +entrada[6] +entrada[5] +entrada[4]+
entrada[3] +entrada[2] +entrada[1] +entrada[0];
case (sumau)
5'b00000: salida = 16'b0000000000000000;
5'b00001: salida = 16'b1000000000000000;
5'b00010: salida = 16'b1100000000000000;
5'b00011: salida = 16'b1110000000000000;
5'b00100: salida = 16'b1111000000000000;
5'b00101: salida = 16'b1111100000000000;
5'b00110: salida = 16'b1111110000000000;
5'b00111: salida = 16'b1111111000000000;
5'b01000: salida = 16'b1111111100000000;
5'b01001: salida = 16'b1111111110000000;
5'b01010: salida = 16'b1111111111000000;
5'b01011: salida = 16'b1111111111100000;

Profesor Leopoldo Silva Bijit

19-01-2010

16

Sistemas Digitales
5'b01100: salida = 16'b1111111111110000;
5'b01101: salida = 16'b1111111111111000;
5'b01110: salida = 16'b1111111111111100;
5'b01111: salida = 16'b1111111111111110;
5'b10000: salida = 16'b1111111111111111;
default: salida = 16'b0000000000000000;
endcase
end

La herramienta de sntesis determina que la sentencia case puede implementares con una ROM
de 5 entradas para el bus de direccin, con palabras de largo 16. La suma de los bits la
implementa en cuatro niveles de sumadores que generan reservas de salida.
Los algoritmos empleados para realizar la sntesis se alejan bastante de los postulados y
teoremas del lgebra de Boole y de los mtodos basados en papel y lpiz.
Si la descripcin es sintetizable podra seguirse adelante en el diseo, salvo que los tiempos de
propagacin fueran excesivos; en este caso habra que intentar otra descripcin verilog, en la
cual el programador debera participar en la descomposicin del problema en mdulos
sintetizables que logren una sntesis en menos niveles.
Observando el siguiente resumen, proporcionado por la herramienta, vemos que la
descomposicin emplea un nivel de sumadores adicionales a la descomposicin en mdulos
estructurales vista antes.
4.1. HDL Synthesis Report
Macro Statistics
# ROMs
32x16-bit ROM
# Adders/Subtractors
1-bit adder carry out
2-bit adder carry out
3-bit adder carry out
4-bit adder carry out

:1
:1
: 15
:8
:4
:2
:1

4.2. Esquemtico RTL

El mdulo verilog, que describe la relacin entre la entrada y salida, se muestra en la Figura 4.

Figura 4. Esquemtico red combinacional.

Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.

17

Con ms detalle se muestra el esquemtico de la descomposicin, en la Figura 5.

Sumador5

Tablasuma

Suma1

Figura 5. Mdulos del diseo abstracto.

Se han indicado los nombres de los bloques que se usaron en la descripcin estructural, vista al
inicio.
4.3. Timing Summary:
Observando el resumen de especificaciones temporales, vemos el mximo tiempo de
propagacin, que se tiene con la componente elegida para el diseo. Esto puede mejorarse
eligiendo una componente ms rpida, o disminuyendo los niveles del diseo. Esto ltimo
implica cambiar el diseo abstracto original.
Speed Grade: -5
Minimum period: No path found
Minimum input arrival time before clock: No path found
Maximum output required time after clock: No path found
Maximum combinational path delay: 17.324ns
El costo espacial, empleando una fpga, en base a LUTs, se resume en:
4.5. Device utilization summary:
Selected Device : 3s400pq208-5
Number of Slices:
Number of 4 input LUTs:
Number of bonded IOBs:

Profesor Leopoldo Silva Bijit

31 out of 3584 0%
58 out of 7168 0%
32 out of 141 22%

19-01-2010

18

Sistemas Digitales

5. Comparacin entre diseo abstracto y estructural.

5.1. Comparacin empleando FPGA.
En el caso del ejemplo que se est analizando, el diseo abstracto conduce a mejores resultados,
tanto en tiempo como en espacio. La explicacin de esto es que los diseos optimizados en dos
niveles de compuertas, pero de numerosas entradas, no se mapean adecuadamente en los
bloques lgicos de las fpga. Adems la herramienta de sntesis emplea un bloque de ROM, para
implementar la Tabla de salida.
5.2. Comparacin empleando CPLD.
En la implementacin basada en CPLD, resulta que el diseo basado en mdulos optimizados
en dos niveles ocupa menos macroceldas y menos productos.
5.2.1. Mdulos optimizados en dos niveles.
Design Name

cta1

Fitting Status

Successful

Software Version

I.25

Device Used

XC95144-7-PQ100

Date

3-24-2007, 6:51PM

RESOURCES SUMMARY
Macrocells
Pterms Used Registers Used
Used
46/144 (32%) 551/720 (77%) 0/144 (0%)

Pins Used
32/81 (40%)

Function Block
Inputs Used
253/288 (88%)

5.2.2. Diseo abstracto.

Design Name

ctaunos

Fitting Status

Successful

Software Version

I.25

Device Used

XC95144-7-PQ100

Date

3-24-2007, 6:58PM

RESOURCES SUMMARY
Macrocells
Pterms Used Registers Used
Used
64/144 (45%) 622/720 (87%) 0/144 (0%)

Profesor Leopoldo Silva Bijit

Pins Used
32/81 (40%)

Function Block
Inputs Used
179/288 (63%)

19-01-2010

Diseo Modular.

19

6. Diseo empleando Precision RTL Synthesis de Mentor Graphics Corporation

Nivel RTL.
A partir del diseo abstracto descompone el sumador de bits, en cuatro niveles de sumadores,
como se muestra en la Figura 6.

Figura 6. Sumador de unos.

La funcin combinacional, que transforma la salida del sumador, la descompone, en trminos de
compuertas, segn:

Figura 7. Salida combinacional.

Profesor Leopoldo Silva Bijit

19-01-2010

20

Sistemas Digitales

Nivel tecnolgico.
El diseo en un dispositivo ispXPGA de Lattice, mostrando la descomposicin en LUTS:

Figura 8. Diseo en base a LUTs.

La herramienta de sntesis produce una descripcin interna de cada LUT, lo que puede verse en
la Figura 9.

Profesor Leopoldo Silva Bijit

19-01-2010

Diseo Modular.

21

Figura 9. Esquema interno de LUTs.

7. Diseo secuencial.
Puede lograrse un diseo, que cumpla con la especificacin inicial, mediante una mquina
secuencial que emplee registros de desplazamiento. Este diseo requiere especificar seales de
control y adems disponer de una seal de reloj.

Profesor Leopoldo Silva Bijit

19-01-2010

22

Sistemas Digitales

ndice general.
DISEO MODULAR CON VERILOG. ..................................................................................................1
1. ESPECIFICACIN. ...................................................................................................................................1
2. DISEO BRUTA FORZA. ..........................................................................................................................1
3. DISEO MODULAR. ................................................................................................................................4
3.1. Mdulo cuenta1. ...........................................................................................................................5
3.2. Mdulo suma1. ..............................................................................................................................7
3.3. Mdulo suma5. ..............................................................................................................................8
3.4. Mdulo tablasuma.......................................................................................................................12
3.5. Instanciacin de mdulos. ...........................................................................................................13
3.6. Design Statistics ..........................................................................................................................14
3.7. Timing Summary: ........................................................................................................................15
4. DISEO ABSTRACTO. ...........................................................................................................................15
4.1. HDL Synthesis Report .................................................................................................................16
4.2. Esquemtico RTL .......................................................................................................................16
4.3. Timing Summary: ........................................................................................................................17
4.5. Device utilization summary: .......................................................................................................17
5. COMPARACIN ENTRE DISEO ABSTRACTO Y ESTRUCTURAL. .............................................................18
5.1. Comparacin empleando FPGA. ................................................................................................18
5.2. Comparacin empleando CPLD. ................................................................................................18
5.2.1. Mdulos optimizados en dos niveles. ................................................................................................... 18
5.2.2. Diseo abstracto. .................................................................................................................................. 18

6. DISEO EMPLEANDO PRECISION RTL SYNTHESIS DE MENTOR GRAPHICS CORPORATION ..................19

Nivel RTL. ..........................................................................................................................................19
Nivel tecnolgico. ..............................................................................................................................20
7. DISEO SECUENCIAL. ..........................................................................................................................21
NDICE.....................................................................................................................................................22

ndice de Figuras
FIGURA 1. DIAGRAMA EN BLOQUES. ..............................................................................................................4
FIGURA 2 DETALLE DE MDULOS ..................................................................................................................5
FIGURA 3. INTERCONEXIN DE MDULOS....................................................................................................13
FIGURA 4. ESQUEMTICO RED COMBINACIONAL. ........................................................................................16
FIGURA 5. MDULOS DEL DISEO ABSTRACTO. ...........................................................................................17
FIGURA 6. SUMADOR DE UNOS. ...................................................................................................................19
FIGURA 7. SALIDA COMBINACIONAL. ..........................................................................................................19
FIGURA 8. DISEO EN BASE A LUTS. ...........................................................................................................20
FIGURA 9. ESQUEMA INTERNO DE LUTS. ....................................................................................................21

Profesor Leopoldo Silva Bijit

19-01-2010