Diseño modular con Verilog.

Transcripción

1 1 Diseño modular con Verilog. 1. Especificación. Se desea diseñar 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 número de unos que la palabra de entrada, pero justificados a la izquierda. Ejemplo: Palabra de entrada Palabra de salida Diseño bruta forza. Desde un punto de vista combinacional se tienen que realizar 16 diseños, para cada una de las funciones de salida, a partir de tablas de verdad que tienen 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;

2 2 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 más 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 s

3 Diseño Modular e 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 diseño, en dos niveles, en formato eqn. Se muestran sólo algunas de las ecuaciones. El archivo con las expresiones tiene un peso de más 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);.

4 4 Sistemas Digitales s0 = (e15&e14&e13&e12&e11&e10&e9&e8&e7&e6&e5&e4&e3&e2&e1&e0); El formato eqn, es fácilmente traducido a verilog, basta encabezar y terminar el módulo; además de preceder con assign a las ecuaciones de salida, daremos ejemplo de esto más adelante. En caso de ocurrir señales negadas, éstas son precedidas con el símbolo!, en el formato eqn; el cual debe reemplazarse globalmente con el símbolo de la negación de verilog: ~. El diseño en dos niveles tiene un costo demasiado elevado. 3. Diseño modular. La estrategia: Dividir para vencer requiere conceptualizar módulos que permitan descomponer el problema en otros menos complejos. Si se conociera el número de unos de la palabra de entrada, mediante una función combinacional es sencillo generar el formato de salida. Veremos esto luego, cuando estudiemos en detalle el módulo denominado TablaSuma, en el diagrama de la Figura 1. Para determinar el número de unos contenidos en la palabra de entrada se requiere un módulo combinacional que entregue como salida el número de unos de una palabra de n bits; este diseño es sencillo de realizar si n es pequeño. Se requieren 5 bits de salida para contener el binario que equivale a la máxima cuenta de unos, que es 16 decimal. El módulo SumaUnos es combinacionalmente complejo de diseñar, ya que se requieren 5 tablas de verdad de renglones. Lo cual conduce a la necesidad de descomponer la entrada en partes. Entrada SumaUnos 4..0 TablaSuma Salida Figura 1. Diagrama en bloques. Si concebimos un módulo que determine los unos en una palabra de 4 bits, para su diseño se tiene una tabla de verdad de 16 renglones y tres bits de salida, ya que el máximo número de unos es 4, y éste se representa en binario mediante: 100. Se requieren 4 de estos módulos; cuyas entradas se conectan a cuatro grupos de 4 bits de la entrada. Si el módulo se denomina cuenta1, el diagrama de la Figura 2, ilustra la descomposición:

5 Diseño Modular. 5 Entrada cuenta1 cuenta1 cuenta1 cuenta suma1 suma Sumador TablaSuma Salida Figura 2 Detalle de módulos Se han agregado dos módulos suma1, que suman dos de las tres salidas binarias de dos módulos cuenta1; éste es un sumador, suma1 en el diagrama de la Figura 2, en el que los operandos llegan a un máximo de 4, en binario. Por lo tanto su salida debe expresarse en 4 bits para poder representar la suma máxima con valor 8 decimal, que equivale a 1000 en binario. Es preciso agregar un sumador adicional, el sumador5, con entradas con valores máximos iguales a 8 y salida con valor máximo 16, este sumador requiere 5 bits de salida. También 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 (módulo 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 diseño en más niveles. Un esquema de esta solución se muestra en la Figura 5. De esta forma hemos descompuesto un problema de grandes dimensiones, en el diseño de cuatro módulos más sencillos. Algunos de los subproblemas, podrían diseñarse con métodos para papel y lápiz. Las tablas de verdad de todos ellos, pueden generarse mediante sencillos programas escritos en C, lo cual permite automatizar el diseño. Los módulos basados en comandos assign son siempre sintetizables. La estructura concatenada de los módulos implica el aumento de los niveles del diseño, y la menor velocidad en la generación de la salida. Se economiza en número de compuertas, pero se degrada el funcionamiento temporal Módulo cuenta1. Queda especificado por la siguiente tabla de verdad, expresada en formato pla.

6 6 Sistemas Digitales #cuenta unos en palabra de 4 bits..i 4.o 3.ilb e3 e2 e1 e0.ob s2 s1 s e Es sencillo modificar el programa en C, visto al inicio, para generar automáticamente 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 módulo 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

7 Diseño Modular Módulo suma1. #suma palabras de 3 bits. Operandos con valor máximo 4.i 6.o 4.ilb a2 a1 a0 b2 b1 b0.ob su3 su2 su1 su e Debe notarse que solamente se especifican los unos de la función. 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);

8 8 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 módulo verilog: //suma palabras de 3 bits. Operandos con valor máximo 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. Módulo suma5. Para evitar errores en la generación de la tabla de verdad, ésta se genera mediante un programa. Se muestra sólo la función 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 }

9 Diseño Modular. 9 Una modificación menor de la rutina anterior, permite generar la tabla de verdad de suma1. La ejecución del programa anterior, genera la tabla: #Suma operandos enteros sin signo de 4 bits. Máximo operando 8.i 8.o 5.ilb a3 a2 a1 a0 b3 b2 b1 b0.ob n4 n3 n2 n1 n

10 10 Sistemas Digitales e 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);

11 Diseño 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 módulo verilog: //Suma operandos enteros sin signo de 4 bits. Máximo 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

12 12 Sistemas Digitales 3.4. Módulo 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 sa 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

13 Diseño 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. Instanciación de módulos. El en diagrama de la Figura 3, se definen los nombres de las instancias de los módulos. También se han definido tres conjuntos de alambres para efectuar las conexiones entre los módulos. Entrada cuenta13 cuenta12 cuenta11 cuenta sum suma11 suma sum2 Sumador Tabla sum3 Salida Figura 3. Interconexión de módulos El código verilog para el armado del conjunto es:

14 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 diseño anterior fue minimizado en dos niveles para cada uno de los módulos. Al ser implementado en base a fpga, mediante la aplicación, se obtienen los resúmenes de ocupación de espacio y de velocidad Design Statistics Cell Usage : # BELS : 83 # LUT2 : 5 # LUT3 : 8 # LUT4 : 68 # MUXF5 : 2 # IO Buffers : 32 # IBUF : 16 # OBUF : 16 ====================================================================

15 Diseño Modular. 15 Device utilization summary: Selected Device : 3s400pq208-5 Number of Slices: 46 out of % Number of 4 input LUTs: 81 out of % Number of bonded IOBs: 32 out of % 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: ns 4. Diseño abstracto. La descripción del problema, empleando verilog, permite describir lo que se desea realizar, en la forma más abstracta posible. En este caso el módulo que suma los unos de la palabra es sencillo de describir, y dejamos a la herramienta de síntesis que tome la iniciativa para descomponer el problema en submódulos. Para la descripción 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; 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'b ; 5'b00001: salida = 16'b ; 5'b00010: salida = 16'b ; 5'b00011: salida = 16'b ; 5'b00100: salida = 16'b ; 5'b00101: salida = 16'b ; 5'b00110: salida = 16'b ; 5'b00111: salida = 16'b ; 5'b01000: salida = 16'b ; 5'b01001: salida = 16'b ; 5'b01010: salida = 16'b ; 5'b01011: salida = 16'b ;

16 16 Sistemas Digitales endcase end 5'b01100: salida = 16'b ; 5'b01101: salida = 16'b ; 5'b01110: salida = 16'b ; 5'b01111: salida = 16'b ; 5'b10000: salida = 16'b ; default: salida = 16'b ; La herramienta de síntesis determina que la sentencia case puede implementares con una ROM de 5 entradas para el bus de dirección, 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 síntesis se alejan bastante de los postulados y teoremas del álgebra de Boole y de los métodos basados en papel y lápiz. Si la descripción es sintetizable podría seguirse adelante en el diseño, salvo que los tiempos de propagación fueran excesivos; en este caso habría que intentar otra descripción verilog, en la cual el programador debería participar en la descomposición del problema en módulos sintetizables que logren una síntesis en menos niveles. Observando el siguiente resumen, proporcionado por la herramienta, vemos que la descomposición emplea un nivel de sumadores adicionales a la descomposición en módulos estructurales vista antes HDL Synthesis Report Macro Statistics # ROMs : 1 32x16-bit ROM : 1 # Adders/Subtractors : 15 1-bit adder carry out : 8 2-bit adder carry out : 4 3-bit adder carry out : 2 4-bit adder carry out : Esquemático RTL El módulo verilog, que describe la relación entre la entrada y salida, se muestra en la Figura 4. Figura 4. Esquemático red combinacional.

17 Diseño Modular. 17 Con más detalle se muestra el esquemático de la descomposición, en la Figura 5. Sumador5 Tablasuma Suma1 Figura 5. Módulos del diseño abstracto. Se han indicado los nombres de los bloques que se usaron en la descripción estructural, vista al inicio Timing Summary: Observando el resumen de especificaciones temporales, vemos el máximo tiempo de propagación, que se tiene con la componente elegida para el diseño. Esto puede mejorarse eligiendo una componente más rápida, o disminuyendo los niveles del diseño. Esto último implica cambiar el diseño 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: ns 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: 31 out of % Number of 4 input LUTs: 58 out of % Number of bonded IOBs: 32 out of %

18 18 Sistemas Digitales 5. Comparación entre diseño abstracto y estructural Comparación empleando FPGA. En el caso del ejemplo que se está analizando, el diseño abstracto conduce a mejores resultados, tanto en tiempo como en espacio. La explicación de esto es que los diseños optimizados en dos niveles de compuertas, pero de numerosas entradas, no se mapean adecuadamente en los bloques lógicos de las fpga. Además la herramienta de síntesis emplea un bloque de ROM, para implementar la Tabla de salida Comparación empleando CPLD. En la implementación basada en CPLD, resulta que el diseño basado en módulos optimizados en dos niveles ocupa menos macroceldas y menos productos Módulos optimizados en dos niveles. Design Name Fitting Status cta1 Software Version I.25 Device Used Date Successful XC PQ , 6:51PM RESOURCES SUMMARY Macrocells Function Block Pterms Used Registers Used Pins Used Used Inputs Used 46/144 (32%) 551/720 (77%) 0/144 (0%) 32/81 (40%) 253/288 (88%) Diseño abstracto. Design Name Fitting Status ctaunos Software Version I.25 Device Used Date Successful XC PQ , 6:58PM RESOURCES SUMMARY Macrocells Function Block Pterms Used Registers Used Pins Used Used Inputs Used 64/144 (45%) 622/720 (87%) 0/144 (0%) 32/81 (40%) 179/288 (63%)

19 Diseño Modular Diseño empleando Precision RTL Synthesis de Mentor Graphics Corporation Nivel RTL. A partir del diseño abstracto descompone el sumador de bits, en cuatro niveles de sumadores, como se muestra en la Figura 6. Figura 6. Sumador de unos. La función combinacional, que transforma la salida del sumador, la descompone, en términos de compuertas, según: Figura 7. Salida combinacional.

20 20 Sistemas Digitales Nivel tecnológico. El diseño en un dispositivo ispxpga de Lattice, mostrando la descomposición en LUTS: Figura 8. Diseño en base a LUTs. La herramienta de síntesis produce una descripción interna de cada LUT, lo que puede verse en la Figura 9.

21 Diseño Modular Diseño secuencial. Figura 9. Esquema interno de LUTs. Puede lograrse un diseño, que cumpla con la especificación inicial, mediante una máquina secuencial que emplee registros de desplazamiento. Este diseño requiere especificar señales de control y además disponer de una señal de reloj.

22 22 Sistemas Digitales Índice general. DISEÑO MODULAR CON VERILOG ESPECIFICACIÓN DISEÑO BRUTA FORZA DISEÑO MODULAR Módulo cuenta Módulo suma Módulo suma Módulo tablasuma Instanciación de módulos Design Statistics Timing Summary: DISEÑO ABSTRACTO HDL Synthesis Report Esquemático RTL Timing Summary: Device utilization summary: COMPARACIÓN ENTRE DISEÑO ABSTRACTO Y ESTRUCTURAL Comparación empleando FPGA Comparación empleando CPLD Módulos optimizados en dos niveles Diseño abstracto DISEÑO EMPLEANDO PRECISION RTL SYNTHESIS DE MENTOR GRAPHICS CORPORATION Nivel RTL Nivel tecnológico DISEÑO SECUENCIAL ÍNDICE Índice de Figuras FIGURA 1. DIAGRAMA EN BLOQUES FIGURA 2 DETALLE DE MÓDULOS... 5 FIGURA 3. INTERCONEXIÓN DE MÓDULOS FIGURA 4. ESQUEMÁTICO RED COMBINACIONAL FIGURA 5. MÓDULOS DEL DISEÑO ABSTRACTO FIGURA 6. SUMADOR DE UNOS FIGURA 7. SALIDA COMBINACIONAL FIGURA 8. DISEÑO EN BASE A LUTS FIGURA 9. ESQUEMA INTERNO DE LUTS