DisenoModular2 PDF

1
Diseño modular con Verilog.
1. Especificación.
Se desea diseñar un sistema combinacional que tenga como entrada cuatro palabras de dos bits
cada una, denominadas a, b, c y d; y que genere dos salidas. La salida f1 debe generar una señal
alta cuando se tenga: a>b>c>d. La salida f2 debe colocarse en alto cuando a<=c o cuando a<d.
2
a
2 f1
b 2
c f2
2
d
Figura 1. Diagrama de sistema combinacional.
2. Diseño de abajo hacia arriba. (bottom-up).
2.1. Empleando espresso.
Desde un punto de vista combinacional se tienen que realizar 2 diseños, ya que hay dos
funciones de salida, a partir de tablas de verdad que tienen 256 renglones cada una, ya que es un
espacio de 8 variables de entrada.
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 las tablas de verdad.

#include <stdio.h>
#define INT_DIGITOS 63
static char buf[INT_DIGITOS + 2];
/* Buffer para INT_DIGITS dígitos, signo - y fin de string '\0' */
char * prtint(int i, int largo)

{ int j;
char *p = buf;
for (j=INT_DIGITOS-1; j>=0; j--) if((1<<j)&i) *p++='1'; else *p++='0';
return (buf+INT_DIGITOS-largo);
}
Profesor Leopoldo Silva Bijit 19-01-2010

2 Sistemas Digitales
//La siguiente función debe modificarse para generar otras tablas de verdad.
void prtinfile(FILE * stream)
{ unsigned int i, j,k,m;
//encabezado archivo pla

fprintf(stream, "%s\n", "#Comparador multiple sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)");
fprintf(stream, "%s\n", ".i 8"); //2 cada operando
fprintf(stream, "%s\n", ".o 2");
fprintf(stream, "%s\n", ".ilb a1 a0 b1 b0 c1 c0 d1 d0");
fprintf(stream, "%s\n", ".ob f1 f2");
for(i=0; i<4; i++) //2^2=4
{
for(j=0; j<4; j++)
{
for(k=0; k<4; k++)
for(m=0; m<4; m++)
{ fprintf(stream, "%s", prtint(i, 2));
fprintf(stream, "%s", prtint(j, 2)); //se separa con tab la entrada de la salida
fprintf(stream, "%s", prtint(k, 2));
fprintf(stream, "%s\t", prtint(m, 2));
if ((i>j)&(j>k)&(k>m)) fprintf(stream, "%s", prtint(1,1));
else fprintf(stream, "%s", prtint(0,1));
if ((i<=k)|(m>i)) fprintf(stream, "%s\n", prtint(1,1));
else fprintf(stream, "%s\n", prtint(0,1));
}
}
printf("%d \n",i); //comenta avance
}
fprintf(stream, "%s\n", ".e"); //fin de archivo formato pla
}
int escribe_archivo(void)
{ FILE *stream;
/* Abre stream para escritura, en modo texto. */
if ((stream = fopen("modcomp2.txt", "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 de datos generado tiene un peso de 4 KB. Se da un listado de los 256 renglones de la
tabla de verdad.

Diseño Modular. 3
#Comparador múltiple sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)
.i 8
.o 2
.ilb a1 a0 b1 b0 c1 c0 d1 d0
.ob f1 f2
00000000 01 00101100 01 01011000 01 10000100 00
00000001 01 00101101 01 01011001 01 10000101 00
00000010 01 00101110 01 01011010 01 10000110 00
00000011 01 00101111 01 01011011 01 10000111 01
00000100 01 00110000 01 01011100 01 10001000 01
00000101 01 00110001 01 01011101 01 10001001 01
00000110 01 00110010 01 01011110 01 10001010 01
00000111 01 00110011 01 01011111 01 10001011 01
00001000 01 00110100 01 01100000 00 10001100 01
00001001 01 00110101 01 01100001 00 10001101 01
00001010 01 00110110 01 01100010 01 10001110 01
00001011 01 00110111 01 01100011 01 10001111 01
00001100 01 00111000 01 01100100 01 10010000 00
00001101 01 00111001 01 01100101 01 10010001 00
00001110 01 00111010 01 01100110 01 10010010 00
00001111 01 00111011 01 01100111 01 10010011 01
00010000 01 00111100 01 01101000 01 10010100 00
00010001 01 00111101 01 01101001 01 10010101 00
00010010 01 00111110 01 01101010 01 10010110 00
00010011 01 00111111 01 01101011 01 10010111 01
00010100 01 01000000 00 01101100 01 10011000 01
00010101 01 01000001 00 01101101 01 10011001 01
00010110 01 01000010 01 01101110 01 10011010 01
00010111 01 01000011 01 01101111 01 10011011 01
00011000 01 01000100 01 01110000 00 10011100 01
00011001 01 01000101 01 01110001 00 10011101 01
00011010 01 01000110 01 01110010 01 10011110 01
00011011 01 01000111 01 01110011 01 10011111 01
00011100 01 01001000 01 01110100 01 10100000 00
00011101 01 01001001 01 01110101 01 10100001 00
00011110 01 01001010 01 01110110 01 10100010 00
00011111 01 01001011 01 01110111 01 10100011 01
00100000 01 01001100 01 01111000 01 10100100 00
00100001 01 01001101 01 01111001 01 10100101 00
00100010 01 01001110 01 01111010 01 10100110 00
00100011 01 01001111 01 01111011 01 10100111 01
00100100 01 01010000 00 01111100 01 10101000 01
00100101 01 01010001 00 01111101 01 10101001 01
00100110 01 01010010 01 01111110 01 10101010 01
00100111 01 01010011 01 01111111 01 10101011 01
00101000 01 01010100 01 10000000 00 10101100 01
00101001 01 01010101 01 10000001 00 10101101 01
00101010 01 01010110 01 10000010 00 10101110 01
00101011 01 01010111 01 10000011 01 10101111 01

10110000 00 11000101 00 11011010 00 11101111 01
10110001 00 11000110 00 11011011 00 11110000 00
10110010 00 11000111 00 11011100 01 11110001 00
10110011 01 11001000 00 11011101 01 11110010 00
10110100 00 11001001 00 11011110 01 11110011 00
10110101 00 11001010 00 11011111 01 11110100 00
10110110 00 11001011 00 11100000 00 11110101 00
10110111 01 11001100 01 11100001 00 11110110 00
10111000 01 11001101 01 11100010 00 11110111 00
10111001 01 11001110 01 11100011 00 11111000 00
10111010 01 11001111 01 11100100 10 11111001 00
10111011 01 11010000 00 11100101 00 11111010 00
10111100 01 11010001 00 11100110 00 11111011 00
10111101 01 11010010 00 11100111 00 11111100 01
10111110 01 11010011 00 11101000 00 11111101 01
10111111 01 11010100 00 11101001 00 11111110 01
11000000 00 11010101 00 11101010 00 11111111 01
11000001 00 11010110 00 11101011 00 .e
11000010 00 11010111 00 11101100 01
11000011 00 11011000 00 11101101 01
11000100 00 11011001 00 11101110 01
Si el archivo anterior se procesa con espresso, con el siguiente comando:
espresso –Dexact modcomp2.txt > modcomp.pla

Se obtienen los implicantes primos que cubren las funciones. En la matriz de cobertura, los
ceros de la salida consideran que los implicantes no pertenecen a la función. Es una pla de tipo
fd.
#Comparador multiple sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)

.i 8
.o 2
.ilb a1 a0 b1 b0 c1 c0 d1 d0
.ob f1 f2
.p 8
00------ 01
0---1--- 01
-0--1--- 01
0----1-- 01
----11-- 01
0-----1- 01
-0----11 01
11100100 10
.e
El comando:
Espresso –Dexact –oeqntott modcomp2.txt > modcomp.eqn
Obtiene un listado de las ecuaciones minimizadas de diseño, en dos niveles, en formato eqn.

#Comparador múltiple sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)
# exact Time was 0.00 sec, cost is c=8(8) in=23 out=8 tot=31
f1 = (a1&a0&b1&!b0&!c1&c0&!d1&!d0);
f2 = (!a1&!a0) | (!a1&c1) | (!a0&c1) | (!a1&c0) | (c1&c0) | (!a1&d1) | ( !a0&d1&d0);
El formato eqn, es fácilmente traducido a un diseño estructural en verilog, basta encabezar y

terminar el módulo; además de preceder con assign a las ecuaciones de salida. 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: ~.
#Comparador especial con operados a, b, c, d sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)

module mayor(a1, a0, b1, b0, c1, c0, d1, d0, f1, f2);
input a1, a0, b1, b0, c1, c0, d1, d0;
output f1, f2;
assign f1 = (a1&a0&b1&~b0&~c1&c0&~d1&~d0);
assign f2 = (~a0&d1&d0) | (c1&c0) | (~a0&c1) | (~a1&d1) | (~a1&c0) |
(~a1&~a0) | (~a1&c1);
Endmodule
El commando: espresso -Dexact -s -epos modcomptv.pla

Produce el diseño en producto de sumas.
#Comparador multiple sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)

.i 8
.o 2
.ilb a1 a0 b1 b0 c1 c0 d1 d0
.ob f1 f2
#.phase 00
.p 10
---1---- 10
--0----- 10
1---0--0 01
11---0-- 01
1---0-01 11
-1--000- 11
11--0-1- 11
----1--- 10
-0------ 10
0------- 10
.e
El commando: espresso -Dexact -s -epos -oeqntott modcomptv.pla

Produce las ecuaciones, donde las salidas deben considerarse que son el complemento de las
buscadas:
f1 = (b0) | (!b1) | (a1&!c1&!d1&d0) | (a0&!c1&!c0&!d1) | (a1&a0&!c1&d1) | ( c1) | (!a0) |
(!a1);
f2 = (a1&!c1&!d0) | (a1&a0&!c0) | (a1&!c1&!d1&d0) | (a0&!c1&!c0&!d1)

Diseño Modular. 3
| ( a1&a0&!c1&d1);
El diseño en forma de producto de sumas:

f1 = (!b0) (b1) (!a1+c1+d1+!d0)(!a0+c1+c0+d1)(!a1+!a0+c1+!d1)(!c1)(a0)(a1);
f2 = (!a1+c1+d0)(!a1+!a0+c0)(!a1+c1+d1+!d0)(!a0+c1+c0+d1)(!a1+!a0+c1+!d1);
2.2. Empleando métodos para papel y lápiz.
Puede notarse que la expresión lógica para la función f1, podría haberse deducido considerando
que la tabla de verdad sólo tiene un mintérmino. Ya que a>b>c>d sólo puede cumplirse para la
combinación a=3, b=2, c=1 y d=0, en decimal. Lo que permite escribir directamente:
f1 =a1a0b1b0’c1’c0d1’d0’
Para f2, puede considerarse la siguiente descomposición en subsistemas:
a
a<=c
c
f2
d
d>a
a
Figura 2. Descomposición de f2.
Ahora los mapas de los subsistemas involucran a 4 variables, y pueden escribirse directamente:
a1a0 d1d0
c1 c0 00 01 11 10 a1 a0 00 01 11 10
0 4 12 8 0 4 12 8
00 1 0 0 0 00 0 1 1 1
1 5 13 9 1 2 5 13 9
01 1 1 0 0 01 0 0 1 1
15 11 15 11
11 13 17 1 1 11 03 07 0 0
2 6 14 10 2 6 14 10
10 1 1 0 1 10 0 0 1 0
a<=c d>a
Figura 3. Mapas de los subsistemas de la descomposición de f2.

Minimizando como suma de productos.
(a<=c) = a1’a0’ + c1c0 + a0’c1 + a1’c1 + a1’c0 10 literales, 15 entradas
(d >a ) = a1’a0’d0 + a0’d1d0 + a1’d1 8 literales, 11 entradas.
Entonces resulta:
f2 = a1’a0’ + c1c0 + a0’c1 + a1’c1 + a1’c0 + a0’d1d0 + a1’d1 15 literales, 22 entradas, 2
niveles.
Considerando que en la suma: a1’a0’+a1’a0’d0 se absorbe d0.

Debido a que la descomposición efectuada en la Figura 2, existe un or en la salida, esta forma
del diseño resulta en dos niveles.
Minimizando como producto de sumas.

(a<=c)’ = a0c1’c0’ + a0c0’c1 + a1c1’
(a<=c) = (a0’+c1+c0)(a0’+c0+c1’)( a1’+c1) 8 literales, 11 entradas.
(d>a)’ = d1’d0’ + a1a0 + d0’a1 + d1’a1 + d1’a0

(d>a) = (d1+d0)( a1’+a0’)(d0+a1’)( d1+a1’)(d1+a0’) 10 literales, 15 entradas.
Resultando:
f2=(a0’+c1+c0)(a0’+c0+c1’)( a1’+c1) + (d1+d0)( a1’+a0’)(d0+a1’)( d1+a1’)(d1+a0’)
Con 18 literales y 28 entradas en tres niveles.
Puede compararse con el resultado obtenido con espresso, con la opción –epos, en la cual f2 se
obtiene en 2 niveles con 18 literales, 23 entradas.
3. Diseño abstracto. De arriba hacia abajo. Top-down.
La siguiente descripción Verilog, mediante el empleo de buses de dos bits cada uno, representa
las funciones buscadas. Nótese que la especificación: a>b>c>d se reemplaza por la lógicamente
equivalente, mediante operadores and. Como el resultado de una comparación entre dos
operandos binarios da como resultado un valor de un bit, pueden emplearse operadores al bit.
En este caso, la descripción también puede efectuarse empleando operadores lógicos (&& y ||,
para el and y para el or de expresiones lógicas).
module compa2b (f1, f2, a, b, c, d);

output f1, f2;
input [1:0] a, b, c, d; // 4 entradas de dos bits cada una
assign
f1= (a>b) & (b>c) & (c>d),
f2= (a<=c) | (a<d );
endmodule
Si la herramienta de síntesis, puede descomponer el módulo en bloques disponibles en su

biblioteca, se puede proceder al diseño. En caso que la descripción no fuera sintetizable, el
diseñador debe descomponer en bloques su arquitectura inicial.

Diseño Modular. 5
3.1. Mapeo a compuertas. Descripción RTL.
En el caso del ejemplo, se reconocen 5 bloques comparadores de dos bits.

Las Figuras 4 y 5 muestran un diagrama en bloques de las entradas y salidas, y la
descomposición en bloques de comparación.
Figura 4. Diagrama en bloques.
c>d
b>c
a>b
a<d
a<=c
Figura 5. Arquitectura RTL del módulo, en base a comparadores.
Los bloques comparadores pueden ser descritos por compuertas lógicas básicas. Determinando
de este modo expresiones booleanas de las funciones. Al descenso de la descripción abstracta a
expresiones boolenas, mediante compuertas y registros, en el caso de sistemas secuenciales, se
lo denomina nivel de transferencia de registros o RTL (register transfer level).
Los distintos bloques comparadores de dos bits, pueden descomponerse en subsistemas

menores. Un esquema general se muestra en la Figura 6.

El primer bloque es una red booleana en base a compuertas que implementa la función xor, de
los bits más significativos de los comparadores.
El segundo bloque, implementa la función especial del comparador: mayor, menor o menor o
igual, en el caso del ejemplo que se analiza.
xor
Figura 6. Subsistemas de los comparadores.
Nótese que el xor se implementa en tres niveles. Esto se debe a que las compuertas de biblioteca
disponibles son compuertas and, or e inversores. La Figura 7, describe la expresión booleana:
Result = D1D0’ + D1’D0, empleando tres niveles.
Figura 7. Mapeo a compuertas de función xor.
Si los bits más significativos son iguales, la señal _n0002 luego del inversor estará en alto, en la
Figura 8. En este caso se comparan los dos bits menos significativos. Si no son iguales se
comparan los bits más significativos, generando la señal inferior del or de salida.
Figura 8. Expresiones para la función A mayor que B.
La descripción de la función mayor que, en términos de compuertas, resulta en tres niveles:

Diseño Modular. 7
AGB= a1b1’ + a0b0’ (a1==b1).
El descenso a nivel de compuertas, es una forma de representar las funciones por expresiones.
La Figura 8, muestra el esquemático para la función A menor que B. Que es representada por la
expresión: ALB= a1’b1 + a0’b0 (a1==b1).
Figura 9. Expresiones para la función A menor que B.
La Figura 10, muestra la implementación, en base a compuertas, de la función de comparación

A menor o igual que B. ALEB= (a0’ + ((a1==b1)+b0) ) (a1’+b1)
Figura 10. Expresiones para la función A menor o igual que B.
3.2. Mapeo a LUT. Implementación con FPGA.
Una vez descrita la red booleana por expresiones, se las minimiza, pero considerando que el
bloque mínimo de implementación física es una Tabla de búsqueda (LUT look-up table), de 4
bits de entrada y un bit de salida. Estas tablas permiten almacenar una tabla de verdad de una
función de cuatro variables. Por supuesto que este bloque también permite representar funciones
boolenas de dos y tres variables, pero en estos casos se estará perdiendo parte de la superficie
del chip.
La síntesis en base a LUT4 se muestra en la Figura 11.

Cada LUT se representa en forma resumida por el patrón hexadecimal almacenado en ella. Por
ejemplo la LUT 0002 almacena, en binario: 0000 0000 0000 0010. El primer bit está asociado a
la combinación 1111 de las entradas y el último bit a la combinación 0000 de las entradas.
Representa la ecuación: i0i1’i2’i3’. Donde i3 es la entrada dibujada en la posición superior en el
esquemático. La Figura 12 muestra la tabla de verdad, y la Figura 13 el mapa de Karnaugh.
d
f1
f2
Figura 11. Esquemático en base a LUTs de las funciones f1 y f2.

Diseño Modular. 9
Figura 12. Contenido LUT4__0002.
Figura 13. Mapa de Karnaugh de LUT4__0002.
Inspeccionando las entradas de la LUT0002, se obtiene que, en términos de las entradas,

representa la ecuación: c0d0’d1’c1’
De modo similar, la LUT4_0080, representa la ecuación: i0i1i2i3’, que en términos de las

variables de entrada puede escribirse: a1a0b1b0’.
La LUT2_8 es simplemente un and. Por lo cual la implementación de la función f1, resulta:

f1= (c0d0’d1’c1’)( a1a0b1b0’), la cual puede escribirse según:
f1=a1a0b1b0’c1’c0d1’d0’
Que es igual al resultado obtenido antes, empleando espresso o métodos manuales.

Para f2 se tiene un mux que bajo el control de la señal a0 deja pasar la salida de la
LUT4_EAFF, con a0=0; o la de la LUT4_D5D4, con a0=1.
La LUT EAFF representa a: i0+i1i2+i3’, que en términos de las entradas resulta: c1+d1d0+a1’.
La LUT D5D4 representa a: i0’i2+i1i2+i0’i3+i0’i1 que en términos de las entradas resulta:

a1’c1+c0c1+a1’d1+a1’c0.
Entonces f2, puede escribirse:
f2 = a0(a1’c1+c0c1+a1’d1+a1’c0) + a0’(c1+d1d0+a1’)
Que es equivalente al diseño mínimo de espresso obtenido antes, en 2.1:

f2 = (a1’a0’) + (a1’c1) + (a0’c1) + (a1’c0) + (c1c0) + (a1’d1) + (a0’d1d0);
3.3. Mapeo a CPLD. Implementación suma de productos.
En este tipo de síntesis se obtienen las ecuaciones de la red booleana en la forma suma de
productos. Puede escogerse que se desplieguen las ecuaciones minimizadas en Verilog.
assign f1 = (b[1] && !d[1] && !d[0] && !b[0] && c[0] && a[0] && !c[1] && a[1]);
assign f2 = !((!d[1] && !c[1] && a[1]) || (!d[0] && !c[1] && a[1])
|| (!c[0] && a[0] && a[1]) || (a[0] && !c[1] && a[1])
|| (!d[1] && !c[0] && a[0] && !c[1]));
La síntesis RTL genera en este caso comparadores sin emplear las funciones xor.
También puede obtenerse el esquemático con síntesis multinivel.
Figura 14. Mapeo a tecnología CPLD.

Diseño Modular. 11
4. Diseño estructural en Verilog.
Cuando se han obtenido las ecuaciones booleanas del sistema digital, desde las tablas de verdad
o mapas de Karnaugh, pueden representarse el sistema mediante un módulo estructural basado
en compuertas.
A continuación se describe en Verilog estructural el módulo que representa al sistema

combinacional que se desea diseñar.
module compa2b (f1, f2, a, b, c, d);

output f1, f2; // mux outputs de 8 bits
input [1:0] a, b, c, d; // mux inputs de 8 bits cada una
assign f1 = (b[1] & ~d[1] & ~d[0] & ~b[0] & c[0] & a[0] & ~c[1] & a[1]);
assign f2 = ~( (~d[1] & ~c[1] & a[1]) | (!d[0] & ~c[1] & a[1])
| (~c[0] & a[0] & a[1]) | (a[0] & ~c[1] & a[1])
| (~d[1] & ~c[0] & a[0] & ~c[1])
);
endmodule
4.1. Diseño basado en FPGA.
En este caso el mapeo tecnológico a FPGA, resulta igual al anterior. Pero el descenso a nivel de
compuertas es diferente, ya que no emplea los comparadores que sintetiza la descripción
abstracta. Ahora la descripción no es abstracta, ya que se da la arquitectura interna. La Figura
15 muestra los dos bloques que generan las funciones de salida.
Figura 15. Descripción RTL de la representación estructural en Verilog.

El bloque superior, de la Figura 15, implementa a f1. Cuyo diagrama interno se muestra en la
Figura 16.
El subsistema inferior, implementa a f2, nótese que sólo ingresan 6 señales. Su diagrama se
ilustra en la Figura 17.
Figura 16. Diseño RTL de f1, mediante Verilog estructural.
Figura 17. Diseño RTL de f2, mediante Verilog estructural.

Diseño Modular. 13
4.2. Diseño basado en CPLD.
En este caso se obtiene una minimización basada en suma de productos. Generando un esquema
RTL basado en una red booleana con nodos que implementan los productos o cubos que cubren
a las funciones. Cada producto se implementa en dos niveles, considerando la obtención de las
señales complementadas mediante inversores, dentro de los nodos.
Figura 18. RTL basado en CPLD. Nodos con los implicantes.
Se tiene para el nodo 4, la ecuación: n4= (c1+c0)’a0d1’.
Figura 19. Producto del nodo 4.
Se tiene para el nodo 3, la ecuación: n3= c1’a0a1.

Se tiene para el nodo 2, la ecuación: n2= c0’a1a0.
Se tiene para el nodo 1, la ecuación: n1= d0’a1c1’.
Se tiene para el nodo 0, la ecuación: n0= d1’a1c1’.
Entonces para f2, se tiene:

f2= (n4+n3+n2+n1+n0)’=((c1+c0)’a0d1’+ c1’a0a1+c0’a1a0+d0’a1c1’+d1’a1c1’)’

Diseño Modular. 15
El único producto asociado a f1, se sintetiza mediante:
f1= (c1+b0+d0+d1)’ a1a0c0b1.
Figura 24. Producto de función f1.
El mapeo tecnológico de los nodos anteriores a una CPLD, se muestra en la Figura 25.

Figura 25. Mapeo tecnológico de los nodos a una CPLD.
Ejercicios propuestos.
Modificar el diseño para emplear buses de datos de entrada de 3 bits.

Modificar el diseño para emplear buses de datos de entrada de 6 bits.
Modificar el diseño pero ahora con f1= a>b>c>d>7, con buses de entrada de 4 bits.

Diseño Modular. 17
Índice general.
DISEÑO MODULAR CON VERILOG. .................................................................................................. 1

1. ESPECIFICACIÓN. .................................................................................................................................. 1
2. DISEÑO DE ABAJO HACIA ARRIBA. (BOTTOM-UP). ................................................................................. 1
2.1. Empleando espresso. .................................................................................................................... 1
2.2. Empleando métodos para papel y lápiz. ....................................................................................... 3
Minimizando como suma de productos. .......................................................................................................... 4
Minimizando como producto de sumas. .......................................................................................................... 4
3. DISEÑO ABSTRACTO. DE ARRIBA HACIA ABAJO. TOP-DOWN. ................................................................ 4
3.1. Mapeo a compuertas. Descripción RTL. ...................................................................................... 5
3.2. Mapeo a LUT. Implementación con FPGA. ................................................................................. 7
3.3. Mapeo a CPLD. Implementación suma de productos. .............................................................. 10
4. DISEÑO ESTRUCTURAL EN VERILOG. .................................................................................................. 11
4.1. Diseño basado en FPGA. ........................................................................................................... 11
4.2. Diseño basado en CPLD. ........................................................................................................... 13
EJERCICIOS PROPUESTOS. ....................................................................................................................... 16
ÍNDICE GENERAL. ................................................................................................................................... 17
ÍNDICE DE FIGURAS. ............................................................................................................................... 17
Índice de Figuras.
FIGURA 1. DIAGRAMA DE SISTEMA COMBINACIONAL. .................................................................................. 1

FIGURA 2. DESCOMPOSICIÓN DE F2............................................................................................................... 3
FIGURA 3. MAPAS DE LOS SUBSISTEMAS DE LA DESCOMPOSICIÓN DE F2....................................................... 3
FIGURA 4. DIAGRAMA EN BLOQUES. ............................................................................................................. 5
FIGURA 5. ARQUITECTURA RTL DEL MÓDULO, EN BASE A COMPARADORES. ............................................... 5
FIGURA 6. SUBSISTEMAS DE LOS COMPARADORES. ....................................................................................... 6
FIGURA 7. MAPEO A COMPUERTAS DE FUNCIÓN XOR. ................................................................................... 6
FIGURA 8. EXPRESIONES PARA LA FUNCIÓN A MAYOR QUE B. ...................................................................... 6
FIGURA 9. EXPRESIONES PARA LA FUNCIÓN A MENOR QUE B. ...................................................................... 7
FIGURA 10. EXPRESIONES PARA LA FUNCIÓN A MENOR O IGUAL QUE B. ...................................................... 7
FIGURA 11. ESQUEMÁTICO EN BASE A LUTS DE LAS FUNCIONES F1 Y F2. .................................................... 8
FIGURA 12. CONTENIDO LUT4__0002. ........................................................................................................ 9
FIGURA 13. MAPA DE KARNAUGH DE LUT4__0002. .................................................................................... 9
FIGURA 14. MAPEO A TECNOLOGÍA CPLD. ................................................................................................ 10
FIGURA 15. DESCRIPCIÓN RTL DE LA REPRESENTACIÓN ESTRUCTURAL EN VERILOG. ............................... 11
FIGURA 16. DISEÑO RTL DE F1, MEDIANTE VERILOG ESTRUCTURAL. ........................................................ 12
FIGURA 17. DISEÑO RTL DE F2, MEDIANTE VERILOG ESTRUCTURAL. ........................................................ 12
FIGURA 18. RTL BASADO EN CPLD. NODOS CON LOS IMPLICANTES. ......................................................... 13
FIGURA 19. PRODUCTO DEL NODO 4. .......................................................................................................... 13
FIGURA 24. PRODUCTO DE FUNCIÓN F1....................................................................................................... 15

FIGURA 25. MAPEO TECNOLÓGICO DE LOS NODOS A UNA CPLD. ................................................................16

DisenoModular2 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

DisenoModular2 PDF

Cargado por

Copyright:

Formatos disponibles

1

Diseño modular con Verilog.

Figura 1. Diagrama de sistema combinacional.

2. Diseño de abajo hacia arriba. (bottom-up).

2.1. Empleando espresso.

El siguiente programa en C, genera las tablas de verdad.

char * prtint(int i, int largo)

Profesor Leopoldo Silva Bijit 19-01-2010

//encabezado archivo pla

Profesor Leopoldo Silva Bijit 19-01-2010

Profesor Leopoldo Silva Bijit 19-01-2010

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

espresso –Dexact modcomp2.txt > modcomp.pla

#Comparador multiple sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)

Profesor Leopoldo Silva Bijit 19-01-2010

El formato eqn, es fácilmente traducido a un diseño estructural en verilog, basta encabezar y

#Comparador especial con operados a, b, c, d sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)

El commando: espresso -Dexact -s -epos modcomptv.pla

#Comparador multiple sin signo de 2 bits. f1=a>b>c>d ; f2=(a<=c)|(d>a)

El commando: espresso -Dexact -s -epos -oeqntott modcomptv.pla

Profesor Leopoldo Silva Bijit 19-01-2010

El diseño en forma de producto de sumas:

2.2. Empleando métodos para papel y lápiz.

Para f2, puede considerarse la siguiente descomposición en subsistemas:

Figura 2. Descomposición de f2.

Figura 3. Mapas de los subsistemas de la descomposición de f2.

Profesor Leopoldo Silva Bijit 19-01-2010

Considerando que en la suma: a1’a0’+a1’a0’d0 se absorbe d0.

Minimizando como producto de sumas.

(d>a)’ = d1’d0’ + a1a0 + d0’a1 + d1’a1 + d1’a0

3. Diseño abstracto. De arriba hacia abajo. Top-down.

module compa2b (f1, f2, a, b, c, d);

Si la herramienta de síntesis, puede descomponer el módulo en bloques disponibles en su

Profesor Leopoldo Silva Bijit 19-01-2010

En el caso del ejemplo, se reconocen 5 bloques comparadores de dos bits.

Figura 4. Diagrama en bloques.

Figura 5. Arquitectura RTL del módulo, en base a comparadores.

Los distintos bloques comparadores de dos bits, pueden descomponerse en subsistemas

Profesor Leopoldo Silva Bijit 19-01-2010

Figura 6. Subsistemas de los comparadores.

Figura 7. Mapeo a compuertas de función xor.

Figura 8. Expresiones para la función A mayor que B.

La descripción de la función mayor que, en términos de compuertas, resulta en tres niveles:

Profesor Leopoldo Silva Bijit 19-01-2010

Figura 9. Expresiones para la función A menor que B.

La Figura 10, muestra la implementación, en base a compuertas, de la función de comparación

Figura 10. Expresiones para la función A menor o igual que B.

3.2. Mapeo a LUT. Implementación con FPGA.

La síntesis en base a LUT4 se muestra en la Figura 11.

Profesor Leopoldo Silva Bijit 19-01-2010

Figura 11. Esquemático en base a LUTs de las funciones f1 y f2.

Profesor Leopoldo Silva Bijit 19-01-2010

Figura 12. Contenido LUT4__0002.

Figura 13. Mapa de Karnaugh de LUT4__0002.

Inspeccionando las entradas de la LUT0002, se obtiene que, en términos de las entradas,

De modo similar, la LUT4_0080, representa la ecuación: i0i1i2i3’, que en términos de las

La LUT2_8 es simplemente un and. Por lo cual la implementación de la función f1, resulta:

Que es igual al resultado obtenido antes, empleando espresso o métodos manuales.

Profesor Leopoldo Silva Bijit 19-01-2010

La LUT D5D4 representa a: i0’i2+i1i2+i0’i3+i0’i1 que en términos de las entradas resulta:

Entonces f2, puede escribirse:

Que es equivalente al diseño mínimo de espresso obtenido antes, en 2.1:

3.3. Mapeo a CPLD. Implementación suma de productos.